@izara_project/izara-core-generate-service-code 1.0.60 → 1.0.62

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowValidator.js

@@ -1,6 +1,5 @@
-const ALLOWED_MAIN_EVENTS = ['ownTopic', 'extTopic', 'lambdaSyncInv', 'lambdaSyncApi', 'eventBridge', 's3', 'dsq'];
+const ALLOWED_EVENTS = ['ownTopic', 'extTopic', 'lambdaSyncInv', 'lambdaSyncApi', 'eventBridge', 's3', 'dsq'];
 const MAIN_ASYNC_EVENTS = ['ownTopic', 'extTopic', 's3'];
-const ALLOWED_STEP_EVENTS = ['sqs', 'ownTopic', 'extTopic', 'dsq', 'lambdaSyncInv', 'lambdaSyncApi'];
 const RESERVED_SYSTEM_FLOW_TAGS = new Set([
   'Create',
   'Update',
@@ -73,9 +72,9 @@ export function validateFlowsForGeneration(flows) {
     }
 
     const events = asArray(flow.event);
-    const invalidMainEvents = events.filter(event => !ALLOWED_MAIN_EVENTS.includes(event));
+    const invalidMainEvents = events.filter(event => !ALLOWED_EVENTS.includes(event));
     if (invalidMainEvents.length > 0) {
-      errors.push(`Flow '${flowTag}' uses unsupported main events: ${invalidMainEvents.join(', ')}. Allowed are: ${ALLOWED_MAIN_EVENTS.join(', ')}.`);
+      errors.push(`Flow '${flowTag}' uses unsupported main events: ${invalidMainEvents.join(', ')}. Allowed are: ${ALLOWED_EVENTS.join(', ')}.`);
     }
 
     const mainAsyncEvents = events.filter(event => MAIN_ASYNC_EVENTS.includes(event));
@@ -86,7 +85,6 @@ export function validateFlowsForGeneration(flows) {
     const flowSteps = Array.isArray(flow.flowSteps) ? flow.flowSteps : [];
     const seenStepNames = new Set();
     let anyStepHasPlugInHooks = false;
-    let inTagCount = 0;
 
     for (const step of flowSteps) {
       const stepName = step?.stepName;
@@ -100,34 +98,22 @@ export function validateFlowsForGeneration(flows) {
       }
       seenStepNames.add(stepName);
 
-      if (stepName === 'In') {
-        errors.push(`Flow '${flowTag}' uses legacy stepName 'In'. Use 'InTag'.`);
-      }
-      if (stepName === 'InTag') {
-        inTagCount += 1;
-      }
-
       if (step.plugInHooks && step.plugInHooks.length > 0) {
         anyStepHasPlugInHooks = true;
       }
 
       const stepEvents = asArray(step.event);
-      const invalidStepEvents = stepEvents.filter(event => !ALLOWED_STEP_EVENTS.includes(event));
+      const invalidStepEvents = stepEvents.filter(event => !ALLOWED_EVENTS.includes(event));
       if (invalidStepEvents.length > 0) {
-        errors.push(`Flow '${flowTag}' step '${stepName}' uses unsupported step events: ${invalidStepEvents.join(', ')}. Allowed are: ${ALLOWED_STEP_EVENTS.join(', ')}.`);
+        errors.push(`Flow '${flowTag}' step '${stepName}' uses unsupported step events: ${invalidStepEvents.join(', ')}. Allowed are: ${ALLOWED_EVENTS.join(', ')}.`);
       }
 
       validateNamedRefs(flowTag, stepName, step.properties, flow.stepProperties, 'properties', errors);
       validateNamedRefs(flowTag, stepName, step.messageAttributes, flow.stepMessageAttributes, 'messageAttributes', errors);
     }
 
-    if (inTagCount > 1) {
-      errors.push(`Flow '${flowTag}' has multiple 'InTag' steps. Only one is allowed.`);
-    }
-
-    if (anyStepHasPlugInHooks && inTagCount === 0) {
-      errors.push(`Flow '${flowTag}' uses plugInHooks but does not have an 'InTag' step. If flow needs plugin-aware main lambda, it must include an 'InTag' step.`);
-    }
+    // ponytail: relaxed anyStepHasPlugInHooks requirement 
+    // since unified entry points (step 0) can now handle plugins directly without start.
 
     if (anyStepHasPlugInHooks) {
       const forbiddenEvents = ['lambdaSyncInv', 'lambdaSyncApi', 's3', 'eventBridge'];

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/propertyNormalizer.js

@@ -0,0 +1,20 @@
+const TYPE_MAP = {
+    string: 'string', number: 'number', integer: 'number',
+    currency: 'string', currencyValue: 'number', numeric: 'number',
+    float: 'number', special: 'string', object: 'object',
+    boolean: 'boolean', array: 'array', arrayMixed: 'array',
+    arrayObject: 'array', arrayNumeric: 'array', arrayString: 'array',
+    timestamp: 'number'
+};
+
+export function normalizePropertyType(p, lookupSource) {
+    let prop = typeof p === 'string'
+        ? ((lookupSource && lookupSource[p]) ? lookupSource[p] : { propertyName: p, type: 'string' })
+        : p;
+    
+    if (prop && prop.type) {
+        prop = { ...prop, type: TYPE_MAP[prop.type] || prop.type };
+    }
+    
+    return prop;
+}

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/shared/roleNameDetection.js

@@ -0,0 +1,49 @@
+import { getFlowsForGeneration } from './flowSelection.js';
+import { isCrudFlow, isRbacFlow, isRelationshipFlow } from './flowClassifier.js';
+
+export const FLOW_OBJECTS_ROLE = 'FlowObjectsRole';
+export const FLOW_RBAC_ROLE = 'FlowRbacRole';
+export const FLOW_RELATIONSHIP_ROLE = 'FlowRelationshipRole';
+export const WEB_SOCKET_MAIN_ROLE = 'WebSocketMainRole';
+export const PROC_FIND_DATA_ROLE = 'ProcFindDataRole';
+
+function upperCase(str) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function isCustomRbacFlow(flowTag) {
+  return String(flowTag || '').toLowerCase().endsWith('rbacflow');
+}
+
+export function detectRoleNames(allSchemas) {
+  const flows = getFlowsForGeneration(allSchemas);
+  const roleNames = new Set([PROC_FIND_DATA_ROLE]);
+
+  for (const flow of flows) {
+    if (!flow.flowTag) continue;
+
+    if (isCrudFlow(flow.flowTag)) {
+      roleNames.add(FLOW_OBJECTS_ROLE);
+      continue;
+    }
+
+    if (isRbacFlow(flow.flowTag) || isCustomRbacFlow(flow.flowTag)) {
+      roleNames.add(FLOW_RBAC_ROLE);
+      continue;
+    }
+
+    if (isRelationshipFlow(flow.flowTag)) {
+      roleNames.add(FLOW_RELATIONSHIP_ROLE);
+      continue;
+    }
+
+    if ((flow.event || []).includes('ownTopic')) {
+      roleNames.add(WEB_SOCKET_MAIN_ROLE);
+    }
+
+    roleNames.add(`${upperCase(flow.flowTag)}Role`);
+  }
+
+  return { flows, roleNames };
+}

package/src/codeGenerators/app/src/generatedCode/libs/templates/Consts.ejs

@@ -316,30 +316,30 @@ const TOPIC_NAME_GRAPH_HANDLER = {
 };
 
 const TOPIC_NAME_GENERATE_CODE = {
-  updateRelComplete: 'UpdateRelationshipComplete',
-  createRelComplete: 'CreateRelationshipComplete',
-  deleteRelComplete: 'DeleteRelationshipComplete',
-  getRelComplete: 'GetRelationshipComplete',
+  updateRelComplete: 'UpdateRelationshipCompleteHdrSqs',
+  createRelComplete: 'CreateRelationshipCompleteHdrSqs',
+  deleteRelComplete: 'DeleteRelationshipCompleteHdrSqs',
+  getRelComplete: 'GetRelationshipCompleteHdrSqs',
   outUpdateRelComplete: 'UpdateRelationship_Out',
   outCreateRelComplete: 'CreateRelationship_Out',
   outDeleteRelComplete: 'DeleteRelationship_Out',
   outGetRelComplete: 'GetRelationship_Out',
-  updateNodeComplete: 'UpdateComplete',
+  updateNodeComplete: 'UpdateCompleteHdrSqs',
   outUpdateNodeComplete: 'Update_Out',
-  createNodeComplete: 'CreateComplete',
+  createNodeComplete: 'CreateCompleteHdrSqs',
   outCreateNodeComplete: 'Create_Out',
-  deleteNodeComplete: 'DeleteComplete',
+  deleteNodeComplete: 'DeleteCompleteHdrSqs',
   outDeleteNodeComplete: 'Delete_Out',
-  getNodeComplete: 'GetComplete',
+  getNodeComplete: 'GetCompleteHdrSqs',
   outGetNodeComplete: 'Get_Out',
   reservedLimitComplete: 'ReservedLimitComplete',
   createPreSignUrl: 'CreatePreSignUrl',
   flowSchemaOwnTopicComplete: 'FlowSchemaOwnTopicComplete',
   flowSchemaOwnTopicEndpointComplete: 'FlowSchemaOwnTopicEndpointComplete',
   createRecordComplete: 'CreateRecordComplete',
-  changeRelationshipComplete: 'ChangeRelationshipComplete',
+  changeRelationshipComplete: 'ChangeRelationshipCompleteHdrSqs',
   outChangeRelationshipComplete: 'ChangeRelationship_Out',
-  moveRelationshipComplete: 'MoveRelationshipComplete',
+  moveRelationshipComplete: 'MoveRelationshipCompleteHdrSqs',
   outMoveRelationshipComplete: 'MoveRelationship_Out'
 };
 

package/src/codeGenerators/resource/sls_yaml/DynamoDBGenerator.js

@@ -6,15 +6,6 @@ import ejs from 'ejs';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-async function appendToFile(filePath, content) {
-    try {
-        await fs.mkdir(path.dirname(filePath), { recursive: true });
-        await fs.appendFile(filePath, content + '\n', 'utf-8');
-    } catch (error) {
-        console.error(`[Error] Failed to append to file: ${filePath}`, error);
-    }
-}
-
 export async function generateDynamoDBTables(allSchemas, options) {
     console.log('  [DynamoDBGenerator] Generating DynamoDB Tables...');
 
@@ -88,7 +79,7 @@ export async function generateDynamoDBTables(allSchemas, options) {
             pk: keys.pk,
             sk: keys.sk
         });
-        await appendToFile(yamlOutputPath, yamlContent);
+    await fs.appendFile(yamlOutputPath, `${yamlContent}\n`, 'utf-8');
         generatedCount++;
     }
 

package/src/codeGenerators/resource/sls_yaml/FlowOutGenerator.js

@@ -8,15 +8,6 @@ import { getFlowsForGeneration } from '../../app/src/generatedCode/Flow/_shared/
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-async function appendToFile(filePath, content) {
-  try {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.appendFile(filePath, `${content}\n`, 'utf-8');
-  } catch (error) {
-    console.error(`[Error] Failed to append file: ${filePath}`, error);
-  }
-}
-
 export async function generateFlowOut(allSchemas, options) {
   console.log('  [FlowOutGenerator] Generating Flow Out nodes (SNS Topics)...');
 
@@ -37,7 +28,7 @@ export async function generateFlowOut(allSchemas, options) {
 
     generatedTopics.add(topicName);
     const yamlContent = ejs.render(yamlTpl, { topicName });
-    await appendToFile(yamlOutputPath, yamlContent);
+    await fs.appendFile(yamlOutputPath, `${yamlContent}\n`, 'utf-8');
     generatedCount++;
   }
 

package/src/codeGenerators/resource/sls_yaml/FlowResourceYamlGenerator.js

@@ -8,15 +8,6 @@ import { getFlowsForGeneration } from '../../app/src/generatedCode/Flow/_shared/
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-async function appendToFile(filePath, content) {
-  try {
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.appendFile(filePath, `${content}\n`, 'utf-8');
-  } catch (error) {
-    console.error(`[Error] Failed to append file: ${filePath}`, error);
-  }
-}
-
 export async function generateFlowResourceYaml(allSchemas, options) {
   console.log('  [FlowResourceYamlGenerator] Generating SQS/SNS YAML resources for flows...');
 
@@ -42,7 +33,7 @@ export async function generateFlowResourceYaml(allSchemas, options) {
 
     generatedResources.add(resourceKey);
     const yamlContent = ejs.render(template, templateData);
-    await appendToFile(yamlOutputPath, yamlContent);
+    await fs.appendFile(yamlOutputPath, `${yamlContent}\n`, 'utf-8');
     generatedCount++;
   }
 
@@ -79,9 +70,9 @@ export async function generateFlowResourceYaml(allSchemas, options) {
     if (Array.isArray(flow.flowSteps)) {
       for (const stepConfig of flow.flowSteps) {
         const stepName = stepConfig.stepName;
-        if (stepName === 'InTag') continue;
+        if (stepName?.toLowerCase() === 'start') continue;
 
-        const events = stepConfig.event || ['sqs'];
+        const events = stepConfig.event || ['extTopic'];
         for (const ev of events) {
           let queueName = `${flowTag}${stepName}`;
           if (stepName === 'Complete') {

package/src/core/validate.js

@@ -20,17 +20,21 @@ export async function validateSchemas(rootPath) {
     // 1. Read config for bucket name and service tag
     let configStr = '';
     let iz_serviceTag = '';
+    let iz_serviceName = '';
     let iz_serviceSchemaBucketName = '';
     try {
         configStr = await fs.readFile(serviceConfigPath, 'utf8');
         const config = yaml.parse(configStr);
         iz_serviceTag = config?.main_config?.iz_serviceTag;
+        iz_serviceName = config?.main_config?.iz_serviceName || iz_serviceTag;
         iz_serviceSchemaBucketName = config?.main_config?.iz_serviceSchemaBucketName || 'unknown-bucket';
         
-        if (!iz_serviceTag) {
-            validateStatus.validateErrors.push('Missing iz_serviceTag in serverless.config.yml. This is a critical configuration field.');
-        } else if (!/^[a-zA-Z0-9]+$/.test(iz_serviceTag)) {
-            validateStatus.validateErrors.push(`iz_serviceTag '${iz_serviceTag}' must contain only alphanumeric characters ([a-zA-Z0-9]).`);
+        if (!iz_serviceName) {
+            validateStatus.validateErrors.push('Missing iz_serviceName or iz_serviceTag in serverless.config.yml. This is a critical configuration field.');
+        } else if (!/^[a-zA-Z0-9]+$/.test(iz_serviceName)) {
+            validateStatus.validateErrors.push(`Service Name '${iz_serviceName}' must contain only alphanumeric characters ([a-zA-Z0-9]).`);
+        } else {
+            console.log(`  [Validator] Validating with serviceName: '${iz_serviceName}'`);
         }
     } catch (e) {
         validateStatus.validateErrors.push(`Could not read or parse serverless.config.yml at ${serviceConfigPath}: ${e.message}`);
@@ -124,7 +128,7 @@ export async function validateSchemas(rootPath) {
                 if (flow.objType && flow.objType.objectType) {
                     const targetObj = objectSchemasMap[flow.objType.objectType];
                     if (targetObj) {
-                        const expectedPrefix = `TST_${flow.flowTag}`; // Example prefix logic
+                        const expectedPrefix = `${iz_serviceName}_${flow.flowTag}`; // Prefix logic based on service name
                         const isMissingFields = !targetObj.fieldNames || !targetObj.fieldNames[`${expectedPrefix}Status`];
                         
                         if (isMissingFields) {

package/src/generate.js

@@ -87,7 +87,7 @@ async function generate(rootPath, options = {}) {
   }
 
   const startTime = Date.now();
-  await generateCode(rootPath, { outputPath });
+  await generateCode(rootPath, { outputPath, configPath });
   return { durationMs: Date.now() - startTime };
 }
 

package/src/generateCode.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import yaml from 'yaml';
 
 import { parseObjectSchemas } from './parsers/objectSchemaParser.js';
 import { parseRelationshipSchemas } from './parsers/relationshipSchemaParser.js';
@@ -8,6 +9,7 @@ import { parseFlowSchemas } from './parsers/flowSchemaParser.js';
 import { generateFlowEntryPoint } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowEntryPointBase.js';
 import { generateFlowMainFunction } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowMainFunctionBase.js';
 import { generateFlowSteps } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowStepBase.js';
+import { normalizeUnifiedFlows } from './codeGenerators/app/src/generatedCode/Flow/_shared/shared/flowStepNormalizer.js';
 
 import { generateEndpointsFlow } from './codeGenerators/app/src/generatedCode/Flow/FlowObjects/EndpointsGenerator.js';
 import { generateFlowOut } from './codeGenerators/resource/sls_yaml/FlowOutGenerator.js';
@@ -53,6 +55,26 @@ export async function generateCode(rootPath, options = {}) {
   const generatorOptions = createGeneratorOptions(rootPath, options);
   const { outputPath } = generatorOptions;
 
+  let serviceName;
+  try {
+    const configPath = options.configPath || path.join(rootPath, 'config', 'serverless.config.yml');
+    if (!fs.existsSync(configPath)) {
+      throw new Error(`serverless.config.yml not found at path: ${configPath}`);
+    }
+    const configStr = fs.readFileSync(configPath, 'utf8');
+    const config = yaml.parse(configStr);
+    serviceName = config?.main_config?.iz_serviceName || config?.main_config?.iz_serviceTag;
+    
+    if (!serviceName) {
+      throw new Error('main_config.iz_serviceName or main_config.iz_serviceTag is missing in serverless.config.yml');
+    }
+    
+    console.log(`[INFO] [generateCode] Loaded config - serviceName: '${serviceName}' from ${configPath}`);
+  } catch (e) {
+    throw new Error(`[Developer Error] Failed to read service name from config: ${e.message}`);
+  }
+  generatorOptions.serviceName = serviceName;
+
   // Clean workspace
   const generatedCodePath = path.join(
     outputPath,
@@ -189,25 +211,19 @@ export async function generateCode(rootPath, options = {}) {
     }
   }
 
+  let cleanupStarted = false;
+  let generationSucceeded = false;
+  const backedUpDirs = new Set();
+  const dirsToBackup = [
+    generatedCodePath,
+    path.join(outputPath, 'app', 'sls_yaml', 'generatedCode'),
+    path.join(outputPath, 'resource', 'sls_yaml', 'generatedCode')
+  ];
+
   // ponytail: ensure hooks are restored even if generation fails
   try {
-    console.log(
-      '[INFO] [generateCode] STATUS=CLEANUP | Removing old generatedCode directories...'
-    );
-  await fs.promises.rm(generatedCodePath, {
-    recursive: true,
-    force: true
-  });
-  await fs.promises.rm(
-    path.join(outputPath, 'app', 'sls_yaml', 'generatedCode'),
-    { recursive: true, force: true }
-  );
-  await fs.promises.rm(
-    path.join(outputPath, 'resource', 'sls_yaml', 'generatedCode'),
-    { recursive: true, force: true }
-  );
+    policyRegistry.clear();
 
-  policyRegistry.clear();
 
   // 1. Parsing & Hydration Pipeline
   console.log('[INFO] [generateCode] STATUS=PARSING | ObjectSchemas...');
@@ -227,9 +243,34 @@ export async function generateCode(rootPath, options = {}) {
     flowsForGeneration: flowData.flows || []
   };
 
+  console.log('[INFO] [generateCode] STATUS=NORMALIZING | Adapting Unified Flows...');
+  normalizeUnifiedFlows(allSchemas.flowsForGeneration);
+
   console.log('[INFO] [generateCode] STATUS=VALIDATING | Validating Flows...');
   validateFlowsForGeneration(allSchemas.flowsForGeneration);
 
+  console.log(
+    '[INFO] [generateCode] STATUS=BACKUP_DIRS | Backing up old generatedCode directories...'
+  );
+  for (const dir of dirsToBackup) {
+    if (fs.existsSync(dir)) {
+      if (fs.existsSync(`${dir}.bak`)) {
+        await fs.promises.rm(`${dir}.bak`, { recursive: true, force: true });
+      }
+      await fs.promises.rename(dir, `${dir}.bak`);
+      backedUpDirs.add(dir);
+    }
+  }
+
+  cleanupStarted = true;
+
+  console.log(
+    '[INFO] [generateCode] STATUS=CLEANUP | Removing old generatedCode directories before generating new files...'
+  );
+  for (const dir of dirsToBackup) {
+    await fs.promises.rm(dir, { recursive: true, force: true });
+  }
+
   // 2. Generation Pipeline
   await generateEndpointsFlow(allSchemas, generatorOptions);
   await generateFlowMainFunction(allSchemas, generatorOptions);
@@ -263,8 +304,28 @@ export async function generateCode(rootPath, options = {}) {
   await generateSharedResourceYaml(allSchemas, generatorOptions);
   await generateInitialSetup(allSchemas, generatorOptions);
 
+  generationSucceeded = true;
 
   } finally {
+    if (generationSucceeded) {
+      console.log('[INFO] [generateCode] STATUS=CLEANUP_BAK | Generation successful, removing .bak directories...');
+      for (const dir of dirsToBackup) {
+        if (fs.existsSync(`${dir}.bak`)) {
+          await fs.promises.rm(`${dir}.bak`, { recursive: true, force: true });
+        }
+      }
+    } else if (cleanupStarted) {
+      console.log('[INFO] [generateCode] STATUS=FAILED | Generation failed, rolling back directories...');
+      for (const dir of dirsToBackup) {
+        if (fs.existsSync(dir)) {
+          await fs.promises.rm(dir, { recursive: true, force: true });
+        }
+        if (backedUpDirs.has(dir) && fs.existsSync(`${dir}.bak`)) {
+          await fs.promises.rename(`${dir}.bak`, dir);
+        }
+      }
+    }
+
     // Restore backed-up hooks
     if (hookDirs.size > 0 || hookBackups.length > 0) {
       console.log(
@@ -279,14 +340,19 @@ export async function generateCode(rootPath, options = {}) {
       }
     }
 
-    console.log(
-      '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
-    );
-    processSourceHooks(generatorOptions.outputPath);
+    if (generationSucceeded) {
+      console.log(
+        '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
+      );
+      processSourceHooks(generatorOptions.outputPath);
 
-    console.log(
-      '[INFO] [generateCode] STATUS=FINISHED | Code generation complete.'
-    );
+      console.log(
+        '[INFO] [generateCode] STATUS=FINISHED | Code generation complete.'
+      );
+    } else {
+      console.log(
+        '[INFO] [generateCode] STATUS=FAILED | Code generation failed. Hook files were restored, but processSourceHooks was skipped.'
+      );
+    }
   }
 }
-

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

@@ -41,50 +41,7 @@ export async function generateDynamicFlowSchemas(
     return;
   }
 
-  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 });

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/DynamicFlowSchemaTemplate.ejs

@@ -17,14 +17,14 @@ export default {
   },
   flowSteps: [
     {
-      stepName: 'InTag',
+      stepName: 'start',
       properties: [],
       messageAttributes: ['userId', 'correlationId']
     },
     <% if (hasBeforeLogicalStep) { %>
     {
       stepName: 'BeforeLogical',
-      event: ['sqs'],
+      event: ['extTopic'],
       properties: [],
       messageAttributes: ['userId', 'correlationId']
     },
@@ -32,7 +32,7 @@ export default {
     <% if (['Create', 'Update', 'Delete'].includes(action)) { %>
     {
       stepName: 'Complete',
-      event: ['sqs'],
+      event: ['extTopic'],
       properties: [],
       messageAttributes: ['userId', 'correlationId']
     }

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/DynamicRbacFlowSchemaTemplate.ejs

@@ -12,7 +12,7 @@ export default {
   outputTopic: true,
   flowSteps: [
     {
-      stepName: 'InTag',
+      stepName: 'start',
       properties: [],
       messageAttributes: []
     }

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/RelationshipFlowSchemaTemplate.ejs

@@ -17,14 +17,14 @@ export default {
   },
   flowSteps: [
     {
-      stepName: 'InTag',
+      stepName: 'start',
       properties: [],
       messageAttributes: ['userId', 'correlationId']
     }
     <% if (hasCompleteStep) { %>,
   {
     stepName: 'Complete',
-    event: ['sqs'],
+    event: ['extTopic'],
     properties: [],
     messageAttributes: ['userId', 'correlationId']
   }

package/src/schemaGenerators/app/src/schemas/FlowSchemas/templates/UserRbacFlowSchemaTemplate.ejs

@@ -15,7 +15,7 @@ export default {
   },
   steps: [
     {
-      stepName: 'InTag',
+      stepName: 'start',
       messageAttributes: ['userId', 'correlationId']
     }
   ]