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

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/intTestGeneratorShared.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import yaml from 'yaml';
+
+function getServiceTag(rootPath) {
+  const configPath = join(rootPath, 'config', 'serverless.config.yml');
+  const config = yaml.parse(readFileSync(configPath, 'utf8'));
+  return config?.main_config?.iz_serviceTag;
+}
+
+async function runTemplateItems(items, { writeSource, errorPrefix }) {
+  const clearedPaths = new Set();
+
+  for (const item of items) {
+    if (!item || !item.templatePath || !item.templateData || !item.setting) {
+      throw new Error(`Invalid ${errorPrefix} item: missing templatePath/templateData/setting`);
+    }
+
+    const [status, error] = await writeSource(item, { checkCreateSourcePass: true });
+    if (!status) {
+      throw new Error(`${errorPrefix} template validation failed: ${error?.message || error}`);
+    }
+  }
+
+  for (const item of items) {
+    const savePath = item.setting?.savePath;
+    if (savePath && existsSync(savePath) && !clearedPaths.has(savePath)) {
+      rmSync(savePath, { recursive: true, force: true });
+      clearedPaths.add(savePath);
+    }
+
+    await writeSource(item, { checkCreateSourcePass: false });
+  }
+}
+
+export { getServiceTag, runTemplateItems };

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}`
+  );
+}

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

@@ -0,0 +1,84 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Creates Service-Level Dynamic RBAC FlowSchemas.
+ */
+export async function generateRbacFlowSchemas(hydratedObjectData, options) {
+  console.log(
+    '  [RbacFlowSchemaGenerator] Generating dynamic Service-Level RBAC FlowSchemas...'
+  );
+  const schemasOutputDir = path.join(
+    options.outputPath,
+    'app',
+    'src',
+    'schemas',
+    'FlowSchemas',
+    'generateCode'
+  );
+
+  // Check if there are any objects with 'rbac' addOnDataStructure
+  const rbacObjects = hydratedObjectData.objects.filter(obj => {
+    if (obj.addOnDataStructure && Array.isArray(obj.addOnDataStructure)) {
+      return obj.addOnDataStructure.some(addOn => addOn.type === 'rbac');
+    }
+    return false;
+  });
+
+  if (rbacObjects.length === 0) {
+    console.log('  [RbacFlowSchemaGenerator] No RBAC objects found. Skipping RBAC FlowSchemas generation.');
+    return;
+  }
+
+  // Ensure directory exists
+  await fs.mkdir(schemasOutputDir, { recursive: true });
+
+  let generatedCount = 0;
+  
+  const rbacFlowDefinitions = [
+    { flowTag: 'CreateTargetRole', eventNames: ['ownTopic'] },
+    { flowTag: 'ListTargetRole', eventNames: ['lambdaSyncApi'] },
+    { flowTag: 'DeleteTargetRole', eventNames: ['ownTopic'] },
+    { flowTag: 'CreateRolePermissions', eventNames: ['ownTopic'] },
+    { flowTag: 'ListRolePermissions', eventNames: ['lambdaSyncApi'] },
+    { flowTag: 'DeleteRolePermissions', eventNames: ['ownTopic'] },
+    { flowTag: 'CreateUserRole', eventNames: ['ownTopic'] },
+    { flowTag: 'ListUserInRoles', eventNames: ['lambdaSyncApi'] },
+    { flowTag: 'DeleteUserFromRole', eventNames: ['ownTopic'] }
+  ];
+
+  // Read the EJS template
+  const templatePath = path.join(__dirname, 'templates', 'DynamicRbacFlowSchemaTemplate.ejs');
+  const templateString = await fs.readFile(templatePath, 'utf-8');
+
+  for (const obj of rbacObjects) {
+    const objectType = obj.objectType;
+
+    for (const def of rbacFlowDefinitions) {
+      const flowTag = def.flowTag;
+      // Use the old naming convention: {objectType}{flowTag}Flow.js
+      const filePath = path.join(schemasOutputDir, `${objectType}${flowTag}Flow.js`);
+
+      const eventsArrayStr = JSON.stringify(def.eventNames).replace(/"/g, "'");
+
+      // Render template with EJS
+      const fileContent = ejs.render(templateString, {
+        flowTag: flowTag,
+        objectType: objectType,
+        events: eventsArrayStr
+      });
+
+      await fs.writeFile(filePath, fileContent, 'utf-8');
+      generatedCount++;
+    }
+  }
+
+  console.log(
+    `  [RbacFlowSchemaGenerator] Wrote ${generatedCount} dynamic RBAC FlowSchemas to ${schemasOutputDir}`
+  );
+}