@izara_project/izara-core-generate-service-code 1.0.52 → 1.0.53

package/src/generateResources/IntTest/consts.js

@@ -0,0 +1,36 @@
+/*
+Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+// IntTest-local constants. Inlined from the legacy src/libs/consts/tags.js
+// to remove the dependency on the legacy `#libs/*` import alias.
+import { consts as coreConsts } from '@izara_project/izara-core-library-service-schemas';
+const { HANDLER } = coreConsts;
+
+const GENERATE_SEED_DATA_TYPE = {
+  RANDOM_ON_CREATE_IDENTIFIERS: 'randomOnCreateIdentifier',
+  NON_RANDOM_ON_CREATE_IDENTIFIERS: 'notRandomOnIdentifier',
+  RELATIONSHIPS: 'relationships'
+};
+
+const SEED_DATA_TAG = {
+  dynamoDBSeedDataTags: 'dynamoDBSeedDataTags',
+  graphSeedDataTags: 'graphSeedDataTags',
+  cleaningDynamoOneRecordsTags: 'cleaningDynamoOneRecordsTags',
+  cleaningDynamoManyRecordsTags: 'cleaningDynamoManyRecordsTags'
+};
+
+export { HANDLER, GENERATE_SEED_DATA_TYPE, SEED_DATA_TAG };

package/src/generateResources/IntTest/generateResources/generateResources.js

@@ -20,22 +20,27 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
-import util from '#libs/Utils.js';
-import consts from '#libs/Consts.js';
+import { getObjectSchema, consts as coreConsts } from '@izara_project/izara-core-library-service-schemas';
 import libs from '../libs/libs.js';
 const { directoryPath } = libs;
-const { getLocalConfig } = util;
+const { STORAGE_TYPES } = coreConsts;
 const templatePath = path.join(__dirname, './templateResources.ejs');
 
 /**
  * Generates code with templates for different actions
+ *
+ * Refactored (Result-Driven): accept `serviceTag` from caller
+ * (previously read via getLocalConfig() from process.cwd()).
+ *
  * @param {Object} _izContext - Context object
  * @param {string} savePath - Path to the schema
+ * @param {Object} settings
+ * @param {string} settings.serviceTag
  * @returns {Array} Array of generated code parameters
  */
-async function generateCodeWithTemplate(_izContext, savePath) {
+async function generateCodeWithTemplate(_izContext, savePath, settings) {
   try {
+    const { serviceTag } = settings;
     let allCreateSource = [];
 
     let schemaPath = path.join(savePath, '../schemas');
@@ -43,11 +48,8 @@ async function generateCodeWithTemplate(_izContext, savePath) {
       savePath,
       '../../sls_yaml/generatedCode/source/'
     );
-    let serviceTag = getLocalConfig('iz_serviceTag');
     let functionPath = path.join(savePath, '../../sls_yaml/');
-    // console.log("serviceTag", serviceTag);
 
-    // let allObjectSchema = await getObjectSchemas.getAllLocalObjectSchemasWithHierarchy(_izContext, schemaPath)
     let allObjectSchema = await getObjectSchema.getAllLocalObjectSchemas(
       _izContext,
       schemaPath
@@ -57,13 +59,10 @@ async function generateCodeWithTemplate(_izContext, savePath) {
 
     let tableNames = new Set();
     for (let objectSchema of allObjectSchemas) {
-      // console.log("objectSchema", objectSchema)
       for (let storageResource of Object.values(
         objectSchema.storageResources
       )) {
-        // console.log("storageResource_Data", storageResource)
-        if (storageResource.storageType === consts.STORAGE_TYPES.dynamoDB) {
-          // console.log("storageResource_Data_Before_Push_Dynamo", storageResource)
+        if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
           tableNames.add(storageResource.tableName);
         }
       }
@@ -71,7 +70,6 @@ async function generateCodeWithTemplate(_izContext, savePath) {
 
     const generateFunctionComponent = directoryPath(slsYmlPath);
     const mainFunctionComponent = directoryPath(functionPath);
-    // console.log({ mainFunctionComponent, generateFunctionComponent })
     let lambdaComponent = {
       ...generateFunctionComponent,
       ...mainFunctionComponent
@@ -83,7 +81,6 @@ async function generateCodeWithTemplate(_izContext, savePath) {
         delete lambdaComponent[lambdaFunctionName];
       }
     }
-    // console.log(s3Component);
 
     allCreateSource.push({
       templatePath: templatePath,

package/src/generateResources/IntTest/generateTests/events/events.js

@@ -20,8 +20,6 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const templatePath = path.join(__dirname, './templateEvents.ejs');
-import utils from '#libs/Utils.js';
-const { getLocalConfig } = utils;
 
 import libs from '../../libs/libs.js';
 const {
@@ -31,9 +29,8 @@ const {
   getHandlerFromEventTag
 } = libs;
 
-async function data(_izContext, allIntTestConfig, srcPath) {
+async function data(_izContext, allIntTestConfig, srcPath, serviceTag) {
   let createEventSources = [];
-  let serviceTag = getLocalConfig('iz_serviceTag');
 
   // console.log({ allIntegrationTestConfig })
 

package/src/generateResources/IntTest/generateTests/generateTemplate.js

@@ -22,40 +22,39 @@ import generatePathIntTest from './pathIntTest/pathIntTest.js';
 // import generateBashScript from './bashScript/data.js'
 import libs from '../libs/libs.js';
 const { getIntTestConfig } = libs;
-import utils from '#libs/Utils.js';
-const { getLocalConfig } = utils;
+
 /**
  * Generates code with templates for different actions
+ *
+ * Refactored (Result-Driven): accept `serviceTag` and `rootPath` from caller
+ * (previously read via getLocalConfig() from process.cwd()).
+ *
  * @param {Object} _izContext - Context object
  * @param {string} savePath - Path to the schema
+ * @param {Object} settings
+ * @param {string} settings.serviceTag
+ * @param {string} settings.rootPath
+ * @param {string} [settings.s3Prefix]
  * @returns {Array} Array of generated code parameters
  */
 async function generateCodeWithTemplate(_izContext, savePath, settings) {
   try {
-    // console.log('settingsInGenerateCodeWithTemplate', settings);
-    let serviceTag = getLocalConfig('iz_serviceTag');
-    // console.log({ savePath })
-    // console.log("settings generateCodeWithTemplate", settings)
+    const { serviceTag, rootPath, s3Prefix } = settings;
     let allCreateSource = [];
-    // console.log("oo:", process.env.iz_resourcePrefix);
     let allIntTestConfig = await getIntTestConfig(
       _izContext,
-      'generateIntegrationTest/libs/'
+      'generateIntegrationTest/libs/',
+      rootPath
     );
-    // console.log({ settings })
-    const event = await generateEvent(_izContext, allIntTestConfig, savePath);
-    // console.log("event", event);
-    // console.log("event", JSON.stringify(event, null, 2))
-    const test = await generateTest(_izContext, allIntTestConfig, savePath);
-    // console.log("test", JSON.stringify(test, null, 2));
+    const event = await generateEvent(_izContext, allIntTestConfig, savePath, serviceTag);
+    const test = await generateTest(_izContext, allIntTestConfig, savePath, serviceTag);
     const intTestBucketPath = await generatePathIntTest(_izContext, savePath, {
       serviceTag,
-      s3Prefix: settings.s3Prefix
+      s3Prefix
     });
 
     allCreateSource.push(...event, ...test, intTestBucketPath);
 
-    // console.log("allCreateSource", allCreateSource)
     return allCreateSource;
   } catch (error) {
     _izContext.logger.error(

package/src/generateResources/IntTest/generateTests/pathIntTest/pathIntTest.js

@@ -20,8 +20,12 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const templatePath = path.join(__dirname, './template.ejs');
-import uploadIntTest from '../../upload/uploadIntTest.js';
-const { bucketPathForUpload } = uploadIntTest;
+
+// Refactored: legacy `bucketPathForUpload` (S3-based) was removed with IntTest/upload/.
+// The new flow doesn't sync IntTest configs to S3 — return empty array as no-op.
+async function bucketPathForUpload(_srcPath, _settings) {
+  return [];
+}
 
 async function data(_izContext, srcPath, settings) {
   // console.log('settingsInData', settings);

package/src/generateResources/IntTest/generateTests/tests/tests.js

@@ -21,8 +21,6 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 const templatePath = path.join(__dirname, './templateTests.ejs');
-import utils from '#libs/Utils.js';
-const { getLocalConfig } = utils;
 
 import libs from '../../libs/libs.js';
 const {
@@ -33,12 +31,10 @@ const {
   setInvokeTest
 } = libs;
 
-import consts from '#libs/Consts.js';
-const { HANDLER, GENERATE_SEED_DATA_TYPE, SEED_DATA_TAG } = consts;
+import { HANDLER, GENERATE_SEED_DATA_TYPE, SEED_DATA_TAG } from '../../consts.js';
 
-async function data(_izContext, allIntTestConfig, srcPath) {
+async function data(_izContext, allIntTestConfig, srcPath, serviceTag) {
   let createSourceData = [];
-  let serviceTag = getLocalConfig('iz_serviceTag');
 
   try {
     for (const intTestConfig of allIntTestConfig) {

package/src/generateResources/IntTest/libs/libs.js

@@ -1,9 +1,9 @@
-import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import { getObjectSchema, consts as coreConsts } from '@izara_project/izara-core-library-service-schemas';
 const { getDataFromPath } = getObjectSchema;
+const { HANDLER } = coreConsts;
 import yaml from 'yaml';
 import fs from 'fs';
-import consts from '#libs/Consts.js';
-const { HANDLER } = consts;
+import path from 'path';
 
 function lowercaseFirst(str) {
   if (!str) return '';
@@ -392,11 +392,11 @@ function createResourceName(eventTag) {
   return [serviceTag, functionName];
 }
 
-async function getIntTestConfig(_izContext, intTestPath) {
+async function getIntTestConfig(_izContext, intTestPath, rootPath) {
   return await getObjectSchema.getDataFromPath(
     _izContext,
     intTestPath,                 // :white_check_mark: ใช้ relative
-    path.join(process.cwd(), 'src/'),           // :white_check_mark: root ที่ถูก
+    path.join(rootPath, 'src/'), // :white_check_mark: root ที่ถูก (refactor: ใช้ rootPath แทน process.cwd())
     { exceptFileName: 'saveConfig' }
   );
 }

package/src/generateSchema.js

@@ -0,0 +1,63 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+
+import { parseObjectSchemas } from './parsers/objectSchemaParser.js';
+import { parseFlowSchemas } from './parsers/flowSchemaParser.js';
+import { parseRelationshipSchemas } from './parsers/relationshipSchemaParser.js';
+
+import { generateRelationshipFlowSchemas } from './schemaGenerators/app/src/schemas/FlowSchemas/RelationshipFlowSchemaGenerator.js';
+import { generateDynamicFlowSchemas } from './schemaGenerators/app/src/schemas/FlowSchemas/FlowSchemaGenerator.js';
+import { generateRbacFlowSchemas } from './schemaGenerators/app/src/schemas/FlowSchemas/RbacFlowSchemaGenerator.js';
+import { generateSystemTextSchemas } from './schemaGenerators/app/src/schemas/SystemTextSchemas/SystemTextGenerator.js';
+import { generatePropertyValueObjectSchemas } from './schemaGenerators/app/src/schemas/ObjectSchemas/PropertyValueSchemaGenerator.js';
+import { generatePropertyValueRelationshipSchemas } from './schemaGenerators/app/src/schemas/RelationshipSchemas/PropertyValueRelationshipSchemaGenerator.js';
+import { generateAttributeTreeObjectSchemas } from './schemaGenerators/app/src/schemas/ObjectSchemas/AttributeTreeSchemaGenerator.js';
+import { generateAttributeTreeRelationshipSchemas } from './schemaGenerators/app/src/schemas/RelationshipSchemas/AttributeTreeRelationshipSchemaGenerator.js';
+
+export async function generateSchema(rootPath, options) {
+  console.log(
+    '[INFO] [generateSchema] STATUS=STARTING | Generating dynamic schemas (FlowSchema, etc.)...'
+  );
+
+  // Parse service config to get serviceTag
+  const configPath = path.join(rootPath, 'config', 'serverless.config.yml');
+  let serviceTag = 'unknownService';
+  try {
+    const serviceConfigStr = fs.readFileSync(configPath, 'utf8');
+    const serviceConfig = yaml.parse(serviceConfigStr);
+    serviceTag = serviceConfig?.main_config?.iz_serviceTag || 'unknownService';
+  } catch (e) {
+    console.warn(
+      `[WARNING] Could not read service config at ${configPath}. Using default serviceTag.`
+    );
+  }
+
+  // Phase 1 parsing just to get the raw data needed for generation
+  const objectData = await parseObjectSchemas(rootPath);
+  const flowData = await parseFlowSchemas(rootPath, objectData);
+  const relationshipData = await parseRelationshipSchemas(rootPath, objectData);
+
+  // Call Schema Generators (Phase 1)
+  const generatorOptions = {
+    outputPath: options.outputPath || rootPath,
+    serviceTag
+  };
+  await generateSystemTextSchemas(
+    objectData,
+    relationshipData,
+    flowData,
+    generatorOptions
+  );
+  await generateRelationshipFlowSchemas(relationshipData, generatorOptions);
+  await generateDynamicFlowSchemas(objectData, flowData, generatorOptions);
+  await generateRbacFlowSchemas(objectData, generatorOptions);
+  await generatePropertyValueObjectSchemas(objectData, generatorOptions);
+  await generatePropertyValueRelationshipSchemas(objectData, generatorOptions);
+  await generateAttributeTreeObjectSchemas(objectData, generatorOptions);
+  await generateAttributeTreeRelationshipSchemas(objectData, generatorOptions);
+
+  console.log(
+    '[INFO] [generateSchema] STATUS=FINISHED | Dynamic schemas generated.'
+  );
+}

package/src/parsers/flowSchemaParser.js

@@ -0,0 +1,106 @@
+import { consts, getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import path from 'path';
+
+function buildObjectSchemaAllS3DebugParam(objType) {
+    return {
+        Bucket: process.env.iz_serviceSchemaBucketName || consts.OBJECT_SCHEMA_BUCKET_NAME,
+        Key: consts.UPLOAD_PATH_S3.objectSchemaAll({}, objType)
+    };
+}
+
+/**
+ * Parses FlowSchemas into a memory-resident data structure.
+ * Implements Hydration Strategy 3: Binding related flows directly to their owning ObjectSchema.
+ */
+export async function parseFlowSchemas(rootPath, hydratedObjectData, options = {}) {
+    const schemasPath = path.join(rootPath, 'app', 'src', 'schemas');
+    const _izContext = { reqId: 'generate-sandbox', logger: console };
+
+    // 1. Read FlowSchemas using existing library
+    const flowsResponse = await getObjectSchema.getAllLocalFlowSchemas(_izContext, schemasPath);
+    let flows = flowsResponse.records || [];
+
+    // Also read dynamic flows from generateCode directory in the output path
+    const targetSchemasDir = options.outputPath ? path.join(options.outputPath, 'app', 'src', 'schemas') : schemasPath;
+    const dynamicSchemasPath = path.join(targetSchemasDir, 'FlowSchemas', 'generateCode');
+    try {
+        const fs = await import('fs/promises');
+        const { pathToFileURL } = await import('url');
+        const files = await fs.readdir(dynamicSchemasPath);
+        for (const file of files) {
+            if (file.endsWith('.js')) {
+                const filePath = path.join(dynamicSchemasPath, file);
+                const mod = await import(pathToFileURL(filePath).href);
+                if (mod.default) {
+                    console.log(`[flowSchemaParser] Loaded dynamic flow: ${mod.default.flowTag}`);
+                    flows.push(mod.default);
+                } else {
+                    console.log(`[flowSchemaParser] No default export in ${file}`);
+                }
+            }
+        }
+    } catch (err) {
+        if (err.code !== 'ENOENT') {
+            console.error(`[flowSchemaParser] Failed to load dynamic schemas from ${dynamicSchemasPath}:`, err);
+        }
+    }
+
+    // 2. Hydration: Link flows to their parent ObjectSchema
+    for (const flow of flows) {
+        // If the flow explicitly defines an objType it handles (e.g. Validation, Search)
+        if (flow.objType && flow.objType.objectType) {
+            const targetObj = flow.objType.objectType;
+            if (hydratedObjectData.objectMap.has(targetObj)) {
+                hydratedObjectData.objectMap.get(targetObj).relatedFlows.push({
+                    flowTag: flow.flowTag,
+                    initiateBy: flow.initiateBy,
+                    type: 'explicit'
+                });
+            }
+
+            // --- RBAC Check ---
+            try {
+                let objSchema = hydratedObjectData.objectMap.get(targetObj);
+                if (!objSchema && flow.objType.serviceTag) {
+                    console.log(`[flowSchemaParser] Fetching objSchema from S3 for targetObj: ${targetObj}`);
+                    console.log(`[flowSchemaParser] getObjSchemaS3WithHierarchy param:`, {
+                        objType: flow.objType,
+                        s3: buildObjectSchemaAllS3DebugParam(flow.objType)
+                    });
+                    objSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(_izContext, flow.objType);
+                }
+
+                console.log(`[flowSchemaParser] targetObj: ${targetObj}, objSchema.belongTo:`, objSchema?.belongTo);
+
+                if (objSchema && objSchema.belongTo) {
+                    console.log(`[flowSchemaParser] Fetching belongToSchema from S3:`, objSchema.belongTo);
+                    console.log(`[flowSchemaParser] getObjSchemaS3WithHierarchy param:`, {
+                        objType: objSchema.belongTo,
+                        s3: buildObjectSchemaAllS3DebugParam(objSchema.belongTo)
+                    });
+                    const belongToSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(_izContext, objSchema.belongTo);
+                    console.log(`[flowSchemaParser] belongToSchema.addOnDataStructure:`, belongToSchema?.addOnDataStructure);
+                    if (belongToSchema && belongToSchema.addOnDataStructure) {
+                        const hasRbac = belongToSchema.addOnDataStructure.some(addOn => addOn.type === 'rbac');
+                        console.log(`[flowSchemaParser] flowTag: ${flow.flowTag}, hasRbac: ${hasRbac}`);
+                        if (hasRbac) {
+                            flow.isRbac = true;
+                        }
+                    }
+                }
+            } catch (err) {
+                console.error(`[flowSchemaParser] Failed to check RBAC for flow ${flow.flowTag}:`, err.message);
+            }
+        }
+
+        // Also check triggerFlowTypes if this flow triggers others
+        if (flow.triggerFlowTypes && Array.isArray(flow.triggerFlowTypes)) {
+            // Further hydration logic if needed...
+        }
+    }
+
+    return {
+        flows: flows,
+        flowMap: new Map(flows.map(f => [f.flowTag, f]))
+    };
+}

package/src/parsers/objectSchemaParser.js

@@ -0,0 +1,39 @@
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import path from 'path';
+
+/**
+ * Parses ObjectSchemas into a memory-resident data structure.
+ * Implements Hydration Strategy 1: Merging fieldNames and identifiers from extendObjType
+ */
+export async function parseObjectSchemas(rootPath) {
+    const schemasPath = path.join(rootPath, 'app', 'src', 'schemas');
+    // Dummy izContext for local parsing
+    const _izContext = { reqId: 'generate-sandbox', logger: console };
+
+    // 1. Fetch raw schemas using the existing library
+    const schemasResponse = await getObjectSchema.getAllLocalObjectSchemasWithoutHierarchy(_izContext, schemasPath);
+    const schemas = schemasResponse.records || [];
+    
+    // 2. Hydration: Merge extended objects
+    const schemaMap = new Map();
+    schemas.forEach(s => schemaMap.set(s.objectType, s));
+
+    const hydratedObjects = schemas.map(obj => {
+        const hydrated = { ...obj, relationships: {}, relatedFlows: [] };
+        
+        // If it extends another object, merge its fields
+        if (obj.extendObjType && obj.extendObjType.objectType) {
+            const parent = schemaMap.get(obj.extendObjType.objectType);
+            if (parent) {
+                hydrated.fieldNames = { ...parent.fieldNames, ...hydrated.fieldNames };
+                hydrated.identifiers = [ ...(parent.identifiers || []), ...(hydrated.identifiers || []) ];
+            }
+        }
+        return hydrated;
+    });
+
+    return {
+        objects: hydratedObjects,
+        objectMap: new Map(hydratedObjects.map(s => [s.objectType, s]))
+    };
+}

package/src/parsers/relationshipSchemaParser.js

@@ -0,0 +1,51 @@
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import path from 'path';
+
+/**
+ * Parses RelationshipSchemas into a memory-resident data structure.
+ * Implements Hydration Strategy 2: Two-way binding for links array.
+ */
+export async function parseRelationshipSchemas(rootPath, hydratedObjectData) {
+    const schemasPath = path.join(rootPath, 'app', 'src', 'schemas');
+    const _izContext = { reqId: 'generate-sandbox', logger: console };
+
+    // 1. Read from schemas/RelationshipSchemas
+    const relationships = await getObjectSchema.getAllLocalRelationshipSchema(_izContext, schemasPath);
+    
+    // 2. Hydrate ObjectSchemas with two-way bindings
+    relationships.forEach(rel => {
+        if (rel.links && Array.isArray(rel.links)) {
+            rel.links.forEach(link => {
+                const fromObj = link.from?.objType?.objectType;
+                const toObj = link.to?.objType?.objectType;
+
+                // Bind to "from" object
+                if (fromObj && hydratedObjectData.objectMap.has(fromObj)) {
+                    const obj = hydratedObjectData.objectMap.get(fromObj);
+                    obj.relationships[rel.relationshipTag] = {
+                        relationshipTag: rel.relationshipTag,
+                        direction: 'from',
+                        linkType: link.from.linkType,
+                        target: toObj
+                    };
+                }
+
+                // Bind to "to" object
+                if (toObj && hydratedObjectData.objectMap.has(toObj)) {
+                    const obj = hydratedObjectData.objectMap.get(toObj);
+                    obj.relationships[rel.relationshipTag] = {
+                        relationshipTag: rel.relationshipTag,
+                        direction: 'to',
+                        linkType: link.to.linkType,
+                        target: fromObj
+                    };
+                }
+            });
+        }
+    });
+
+    return {
+        relationships: relationships,
+        relationshipMap: new Map(relationships.map(r => [r.relationshipTag, r]))
+    };
+}

package/src/schemaGenerators/app/src/schemas/FlowSchemas/FlowSchemaGenerator.js

@@ -0,0 +1,151 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Dynamic Flow Schema Generator (Phase 1)
+ * Creates Service-Level Dynamic CRUD FlowSchemas that handle ANY userGenerated object.
+ */
+export async function generateDynamicFlowSchemas(
+  hydratedObjectData,
+  flowData,
+  options
+) {
+  console.log(
+    '  [FlowSchemaGenerator] Generating dynamic Service-Level CRUD FlowSchemas...'
+  );
+  const schemasOutputDir = path.join(
+    options.outputPath,
+    'app',
+    'src',
+    'schemas',
+    'FlowSchemas',
+    'generateCode'
+  );
+
+  // Check if there are any userGenerated or systemGenerated objects
+  const hasApplicableObjects = hydratedObjectData.objects.some(
+    obj =>
+      obj.generatedBy === 'userGenerated' ||
+      obj.generatedBy === 'systemGenerated'
+  );
+
+  if (!hasApplicableObjects) {
+    console.log(
+      '  [FlowSchemaGenerator] No applicable objects found. Skipping Dynamic FlowSchemas generation.'
+    );
+    return;
+  }
+
+  // Validate event types in custom flow schemas
+  const validMainEvents = [
+    'ownTopic',
+    'extTopic',
+    'dsq',
+    's3',
+    'eventBridge',
+    'lambdaSyncInv',
+    'lambdaSyncApi'
+  ];
+  const validStepEvents = [
+    'sqs',
+    'extTopic',
+    'dsq',
+    'lambdaSyncInv',
+    'lambdaSyncApi',
+    'queue'
+  ];
+
+  if (flowData && flowData.flows) {
+    for (const flow of flowData.flows) {
+      const flowName = flow.flowTag || 'UnknownFlow';
+      // Check main flow events
+      if (flow.event && Array.isArray(flow.event)) {
+        for (const ev of flow.event) {
+          if (!validMainEvents.includes(ev)) {
+            throw new Error(`[FlowSchemaGenerator] Invalid event type '${ev}' in main flow '${flowName}'. Allowed: ${validMainEvents.join(', ')}`);
+          }
+        }
+      }
+      // Check flow steps events
+      if (flow.flowSteps && Array.isArray(flow.flowSteps)) {
+        for (const step of flow.flowSteps) {
+          const stepName = step.stepName || 'UnknownStep';
+          if (step.event && Array.isArray(step.event)) {
+            for (const ev of step.event) {
+              if (!validStepEvents.includes(ev)) {
+                throw new Error(`[FlowSchemaGenerator] Invalid event type '${ev}' in flow '${flowName}' step '${stepName}'. Allowed: ${validStepEvents.join(', ')}`);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Ensure directory exists
+  await fs.mkdir(schemasOutputDir, { recursive: true });
+
+  let generatedCount = 0;
+  const actions = ['Create', 'Update', 'Delete', 'Get'];
+
+  // Read the EJS template
+  const templatePath = path.join(
+    __dirname,
+    'templates',
+    'DynamicFlowSchemaTemplate.ejs'
+  );
+  const templateString = await fs.readFile(templatePath, 'utf-8');
+
+  for (const action of actions) {
+    const flowTag = action;
+    const filePath = path.join(schemasOutputDir, `${flowTag}.js`);
+
+    let events = "['ownTopic']";
+    let outputTopic = true;
+    if (action === 'Get') {
+      events = "['lambdaSyncInv', 'lambdaSyncApi']";
+      outputTopic = false;
+    }
+
+    // Check custom flows for generatedCodeConfig hooks
+    let hasBeforeLogicalStep = false;
+    if (flowData && flowData.flows) {
+      for (const flow of flowData.flows) {
+        if (flow.generatedCodeConfig) {
+          const config = flow.generatedCodeConfig;
+          if (
+            config.generatedCodeTag === action.toLowerCase() &&
+            config.codeHookTag === 'beforeLogical'
+          ) {
+            // Check if invocationType is present in the custom flow's own event array
+            if (flow.event && flow.event.includes(config.invocationType)) {
+              hasBeforeLogicalStep = true;
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    // Render template with EJS
+    const fileContent = ejs.render(templateString, {
+      action: action,
+      flowTag: flowTag,
+      events: events,
+      outputTopic: outputTopic,
+      hasBeforeLogicalStep: hasBeforeLogicalStep
+    });
+
+    await fs.writeFile(filePath, fileContent, 'utf-8');
+    generatedCount++;
+  }
+
+  console.log(
+    `  [FlowSchemaGenerator] Wrote ${generatedCount} dynamic FlowSchemas to ${schemasOutputDir}`
+  );
+}