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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.54",
+  "version": "1.0.55",
   "description": "Code for locally generating per service files",
   "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "repository": {

package/src/codeGenerators/app/sls_yaml/FunctionYamlGenerator.js

@@ -103,7 +103,7 @@ export async function generateFunctionYaml(allSchemas, options) {
 
         // Function Name Config
         // e.g. ProcessCreateSqs or CreateCompleteSqs or GetApi
-        let suffixType = handlerSuffix.replace('Hdr', ''); // Sqs, Api, Inv
+let suffixType = handlerSuffix.startsWith('Hdr') ? handlerSuffix : handlerSuffix.replace('Hdr', '');
         let functionNameConfig = `${handlerBaseName}${suffixType}`;
         if (isCrud && handlerBaseName === `Process${upperCase(flowTag)}`) {
             // Legacy matches: CreateSqs, GetApi instead of ProcessCreateSqs
@@ -133,19 +133,19 @@ export async function generateFunctionYaml(allSchemas, options) {
         
         if (isCrud || isRel) {
             queueName = handlerBaseName.replace('Process', ''); 
-            if (handlerSuffix === 'HdrSqs' || handlerSuffix === 'HdrDsq') {
-                queueName += handlerSuffix.replace('Hdr', '');
-            }
+      if (handlerSuffix === 'HdrSqs' || handlerSuffix === 'HdrDsq') {
+        queueName += handlerSuffix;
+      }
         } else {
             // For Custom Flows (e.g. OwnTopicFlowProcess, ProcessExtTopicFlow)
             // The queue name exactly matches the handler name without the underscore.
             if (handlerSuffix === 'HdrSqs' || handlerSuffix === 'HdrDsq') {
                 if (handlerBaseName === `Process${upperCase(flowTag)}` && flowDefForQueue && flowDefForQueue.event && flowDefForQueue.event.includes('ownTopic')) {
                     // ownTopic flows in FlowResourceYamlGenerator omit 'Process' for the queue
-                    queueName = flowTag + handlerSuffix.replace('Hdr', '');
-                } else {
-                    queueName = handlerBaseName + handlerSuffix.replace('Hdr', '');
-                }
+        queueName = flowTag + handlerSuffix;
+      } else {
+        queueName = handlerBaseName + handlerSuffix;
+      }
             } else {
                 queueName = handlerBaseName;
             }
@@ -153,7 +153,7 @@ export async function generateFunctionYaml(allSchemas, options) {
 
         // Api routes
         let apiRoutes = [];
-        if (suffixType === 'Api') {
+ if (suffixType === 'HdrApi' || suffixType === 'Api') {
             const routesList = isCrud ? crudApiRoutes : (isRel ? relApiRoutes : []);
             const actionPath = flowTag.toLowerCase().replace('relationship', '');
             apiRoutes = routesList.map(r => ({
@@ -166,7 +166,7 @@ export async function generateFunctionYaml(allSchemas, options) {
         const handlerPath = `src/generatedCode/${subDir}/${flowTag}/source/${fileNameWithoutExt}.main`;
 
         let filterPatterns = '';
-        if (handlerBaseName.endsWith('Complete') && (suffixType === 'Sqs' || suffixType === 'Dsq')) {
+ if (handlerBaseName.endsWith('Complete') && (suffixType === 'HdrSqs' || suffixType === 'HdrDsq' || suffixType === 'Sqs' || suffixType === 'Dsq')) {
             filterPatterns = `        filterPatterns: #**** need to update serverless framework upper v.2.69.1
           - body: {"MessageAttributes":{"callingFlow":{"Value":["\${self:custom.iz_resourcePrefix}${functionNameConfig}"]}}} # functionName of callingFlow
           - body: {"MessageAttributes":{"callingFlow":{"Value":[{"exists":false}]}}}`;
@@ -190,15 +190,15 @@ export async function generateFunctionYaml(allSchemas, options) {
         };
 
         let yamlBlock = '';
-        if (schedules.length > 0 && suffixType === 'Inv') {
+        if (schedules.length > 0 && (suffixType === 'HdrInv' || suffixType === 'Inv')) {
             yamlBlock = ejs.render(templates.eventBridge, renderVars);
-        } else if (suffixType === 'Sqs' || suffixType === 'Dsq') {
+} else if (suffixType === 'HdrSqs' || suffixType === 'HdrDsq' || suffixType === 'Sqs' || suffixType === 'Dsq') {
             yamlBlock = ejs.render(templates.sqs, renderVars);
-        } else if (suffixType === 'Inv') {
+        } else if (suffixType === 'HdrInv' || suffixType === 'Inv') {
             yamlBlock = ejs.render(templates.inv, renderVars);
-        } else if (suffixType === 'Api') {
+        } else if (suffixType === 'HdrApi' || suffixType === 'Api') {
             yamlBlock = ejs.render(templates.api, renderVars);
-        } else if (suffixType === 'Wbs') {
+} else if (suffixType === 'HdrWbs' || suffixType === 'Wbs') {
             renderVars.routeName = flowTag;
             yamlBlock = ejs.render(templates.wbs, renderVars);
         } else {

package/src/codeGenerators/app/src/generatedCode/Flow/FlowSchemas/StatusFieldGenerator.js

@@ -17,14 +17,7 @@ function lowerCase(str) {
 }
 
 function shortNameHandler(handlerType) {
-    // Basic mapping for short names
-    const map = {
-        'HdrSqs': 'Sqs',
-        'HdrApi': 'Api',
-        'HdrWbs': 'Wbs',
-        'HdrDsq': 'Dsq'
-    };
-    return map[handlerType] || handlerType;
+    return handlerType;
 }
 
 export async function generateStatusField(flowSchema, appPath, outputBaseDir) {

package/src/codeGenerators/app/src/generatedCode/Flow/FlowSchemas/WebSocketGenerator.js

@@ -12,13 +12,7 @@ function upperCase(str) {
 }
 
 function shortNameHandler(handlerType) {
-    const map = {
-        'HdrSqs': 'Sqs',
-        'HdrApi': 'Api',
-        'HdrWbs': 'Wbs',
-        'HdrDsq': 'Dsq'
-    };
-    return map[handlerType] || handlerType;
+    return handlerType;
 }
 
 export async function generateWebSocket(allLocalFlowSchemas, appPath, outputBaseDir) {

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/events/BaseSqsHandler.js

@@ -14,9 +14,9 @@ export async function generateSqsHandler(flow, stepName, suffix, flowOutputDir,
     // For steps:      ${flowTag}${flowStepName} (e.g. OwnTopicFlowProcess)
     const functionName = stepName ? `${flowTag}${stepName}` : `Process${upperCase(flowTag)}`;
 
-    // Queue name: match the ARN generated in FunctionYamlGenerator
-    // suffix e.g. HdrSqs -> Sqs
-    const queueNameSuffix = suffix.replace('Hdr', '');
+    // Queue name: keep the full handler suffix so handler code matches
+    // the generated queue/resource names.
+    const queueNameSuffix = suffix;
     let queueName = '';
     if (stepName) {
         queueName = `${flowTag}${stepName}${queueNameSuffix}`;

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

@@ -13,13 +13,7 @@ function upperCase(str) {
 }
 
 function shortNameHandler(handlerType) {
-    const map = {
-        'HdrSqs': 'Sqs',
-        'HdrApi': 'Api',
-        'HdrWbs': 'Wbs',
-        'HdrDsq': 'Dsq'
-    };
-    return map[handlerType] || handlerType;
+    return handlerType;
 }
 
 export async function generateTriggerCache(flowSchema, appPath, outputBaseDir) {

package/src/codeGenerators/app/src/generatedCode/SystemFlowSchemas/RegisterGenerator.js

@@ -14,13 +14,7 @@ function upperCase(str) {
 }
 
 function shortNameHandler(handlerType) {
-  const map = {
-    HdrSqs: 'Sqs',
-    HdrApi: 'Api',
-    HdrWbs: 'Wbs',
-    HdrDsq: 'Dsq'
-  };
-  return map[handlerType] || handlerType;
+  return handlerType;
 }
 
 export async function generateRegisterFlow(allLocalFlowSchemas, _appPath, outputBaseDir) {

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

@@ -72,15 +72,15 @@ export async function generateDynamoDBTables(allSchemas, options) {
         }
     }
 
-    let generatedCount = 0;
-    const yamlOutputPath = path.join(resourceYamlDir, 'generated-dynamoDB-table.yml');
+  let generatedCount = 0;
+  const yamlOutputPath = path.join(resourceYamlDir, 'generated-dynamoDB-table.yml');
 
-    // Generate system tables first
-    const systemYamlTplPath = path.join(__dirname, 'templates', 'SystemDynamoDB_Yaml.ejs');
-    const systemYamlTpl = await fs.readFile(systemYamlTplPath, 'utf-8');
-    const systemYamlContent = ejs.render(systemYamlTpl, {});
-    await appendToFile(yamlOutputPath, systemYamlContent);
-    generatedCount += 8; // 8 system tables
+  // Generate system tables first
+  const systemYamlTplPath = path.join(__dirname, 'templates', 'SystemDynamoDB_Yaml.ejs');
+  const systemYamlTpl = await fs.readFile(systemYamlTplPath, 'utf-8');
+  const systemYamlContent = ejs.render(systemYamlTpl, {});
+  await fs.writeFile(yamlOutputPath, `${systemYamlContent}\n`, 'utf-8');
+  generatedCount += 8; // 8 system tables
 
     for (const [tableName, keys] of tables.entries()) {
         const yamlContent = ejs.render(yamlTpl, {

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

@@ -2,72 +2,80 @@ import path from 'path';
 import fs from 'fs/promises';
 import { fileURLToPath } from 'url';
 import ejs from 'ejs';
+
 import { getFlowsForGeneration } from '../../app/src/generatedCode/Flow/_shared/shared/flowSelection.js';
 
 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);
-    }
+  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)...');
-    
-    const resourceYamlDir = path.join(options.outputPath, 'resource', 'sls_yaml', 'generatedCode', 'source');
-    await fs.mkdir(resourceYamlDir, { recursive: true });
+  console.log('  [FlowOutGenerator] Generating Flow Out nodes (SNS Topics)...');
+
+  const resourceYamlDir = path.join(options.outputPath, 'resource', 'sls_yaml', 'generatedCode', 'source');
+  await fs.mkdir(resourceYamlDir, { recursive: true });
+
+  const yamlTplPath = path.join(__dirname, 'templates', 'FlowOut_Yaml.ejs');
+  const yamlTpl = await fs.readFile(yamlTplPath, 'utf-8');
 
-    const yamlTplPath = path.join(__dirname, 'templates', 'FlowOut_Yaml.ejs');
-    const yamlTpl = await fs.readFile(yamlTplPath, 'utf-8');
+  let generatedCount = 0;
+  const yamlOutputPath = path.join(resourceYamlDir, 'generated-sns-out.yml');
+  await fs.writeFile(yamlOutputPath, '', 'utf-8');
 
-    let generatedCount = 0;
-    const yamlOutputPath = path.join(resourceYamlDir, 'generated-sns-out.yml');
+  const generatedTopics = new Set();
 
-    const flows = getFlowsForGeneration(allSchemas);
-    for (const flow of flows) {
-        if (flow.outputTopic === true) {
-            const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
-            const topicName = upperCase(flow.flowTag);
+  async function appendTopic(topicName) {
+    if (generatedTopics.has(topicName)) return;
 
-            const yamlContent = ejs.render(yamlTpl, {
-                topicName: topicName
-            });
+    generatedTopics.add(topicName);
+    const yamlContent = ejs.render(yamlTpl, { topicName });
+    await appendToFile(yamlOutputPath, yamlContent);
+    generatedCount++;
+  }
 
-            await appendToFile(yamlOutputPath, yamlContent);
-            generatedCount++;
-        }
-    }
+  const flows = getFlowsForGeneration(allSchemas);
+  for (const flow of flows) {
+    if (flow.outputTopic !== true) continue;
+    await appendTopic(flow.flowTag.charAt(0).toUpperCase() + flow.flowTag.slice(1));
+  }
 
-    const systemTopics = [
-        'CreateObjectComplete',
-        'DeleteNodeComplete',
-        'UpdateNodeComplete',
-        'GetNodeComplete',
-        'ProcessLogicalComplete',
-        'FindDataComplete',
-        // CRUD Async Topics
-        'Create', 'Update', 'Delete',
-        // Relationship Topics
-        'CreateRelationship', 'UpdateRelationship', 'DeleteRelationship',
-        'GetRelationship', 'ChangeRelationship', 'MoveRelationship',
-        // RBAC Topics
-        'CreateTargetRole', 'ListTargetRole', 'DeleteTargetRole',
-        'CreateRolePermissions', 'ListRolePermissions', 'DeleteRolePermissions',
-        'CreateUserRole', 'ListUserInRoles', 'DeleteUserFromRole'
-    ];
+  const systemTopics = [
+    'CreateObjectComplete',
+    'DeleteNodeComplete',
+    'UpdateNodeComplete',
+    'ProcessLogicalComplete',
+    'FindDataComplete',
+    'Create',
+    'Update',
+    'Delete',
+    'CreateRelationship',
+    'UpdateRelationship',
+    'DeleteRelationship',
+    'GetRelationship',
+    'ChangeRelationship',
+    'MoveRelationship',
+    'CreateTargetRole',
+    'ListTargetRole',
+    'DeleteTargetRole',
+    'CreateRolePermissions',
+    'ListRolePermissions',
+    'DeleteRolePermissions',
+    'CreateUserRole',
+    'ListUserInRoles',
+    'DeleteUserFromRole'
+  ];
 
-    for (const topic of systemTopics) {
-        const yamlContent = ejs.render(yamlTpl, {
-            topicName: topic
-        });
-        await appendToFile(yamlOutputPath, yamlContent);
-        generatedCount++;
-    }
+  for (const topic of systemTopics) {
+    await appendTopic(topic);
+  }
 
-    console.log(`  [FlowOutGenerator] Generated ${generatedCount} SNS Topics for Flow Out nodes.`);
+  console.log(`  [FlowOutGenerator] Generated ${generatedCount} SNS Topics for Flow Out nodes.`);
 }

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

@@ -2,198 +2,171 @@ import path from 'path';
 import fs from 'fs/promises';
 import { fileURLToPath } from 'url';
 import ejs from 'ejs';
+
 import { getFlowsForGeneration } from '../../app/src/generatedCode/Flow/_shared/shared/flowSelection.js';
 
 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);
-    }
+  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...');
-    
-    const resourceYamlDir = path.join(options.outputPath, 'resource', 'sls_yaml', 'generatedCode', 'source');
-    await fs.mkdir(resourceYamlDir, { recursive: true });
-
-    const resourceYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceYaml.ejs');
-    const resourceBeforeLogicalYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceBeforeLogicalYaml.ejs');
-    
-    const resourceYamlTpl = await fs.readFile(resourceYamlTplPath, 'utf-8');
-    const resourceBeforeLogicalYamlTpl = await fs.readFile(resourceBeforeLogicalYamlTplPath, 'utf-8');
-
-    let generatedCount = 0;
-    const yamlOutputPath = path.join(resourceYamlDir, 'generated-sns-in-sqs.yml');
-
-    const flows = getFlowsForGeneration(allSchemas);
-    for (const flow of flows) {
-        const flowTag = flow.flowTag;
-        
-        // Generate In-Queue resources for any flow that listens on its own topic
-        if (flow.event && flow.event.includes('ownTopic')) {
-            // Render main ResourceYaml.ejs (e.g., InCreate, CreateHdrSqs)
-            const yamlContent = ejs.render(resourceYamlTpl, {
-                queueName: flowTag
-            });
-            await appendToFile(yamlOutputPath, yamlContent);
-            generatedCount++;
-
-            // Check if there are beforeLogical configs for this flow
-            const generateCodeConfigs = flows
-                .filter(f => f.generatedCodeConfig && f.generatedCodeConfig.generatedCodeTag.toLowerCase() === flowTag.toLowerCase())
-                .map(f => ({
-                    ...f.generatedCodeConfig,
-                    flowTag: f.flowTag
-                }));
-
-            const beforeLogicalConfigs = generateCodeConfigs.filter(c => c.codeHookTag === 'beforeLogical');
-
-            if (beforeLogicalConfigs.length > 0) {
-                // Collect unique flowTags (like ValidateUnitTrackedProperty) from the beforeLogical configs
-                const uniqueFlowTags = [...new Set(beforeLogicalConfigs.map(c => c.flowTag))];
-                
-                const beforeLogicalYamlContent = ejs.render(resourceBeforeLogicalYamlTpl, {
-                    queueName: `${flowTag}BeforeLogical`,
-                    flowTags: uniqueFlowTags
-                });
-
-                await appendToFile(yamlOutputPath, beforeLogicalYamlContent);
-                generatedCount++;
-            }
-        } else if (flow.event && flow.event.includes('extTopic')) {
-            // Custom flows using extTopic do not have ownTopic, but need an entry queue
-            const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
-            const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
-            const yamlContent = ejs.render(resourceSqsYamlTpl, {
-                queueName: `Process${flowTag}Sqs`
-            });
-            await appendToFile(yamlOutputPath, yamlContent);
-            generatedCount++;
-        }
-        
-        // Generate Complete queues for custom FlowSchema
-        // Also generate queues for any flowStep that uses sqs, dsq, or extTopic
-        if (flow.flowSteps && Array.isArray(flow.flowSteps)) {
-            for (const stepConfig of flow.flowSteps) {
-                const stepName = stepConfig.stepName;
-                if (stepName === 'InTag') continue;
-                
-                const events = stepConfig.event || ['sqs'];
-                for (const ev of events) {
-                    let queueName = flowTag + stepName;
-                    if (stepName === 'Complete') {
-                        queueName = flowTag + 'Complete';
-                    }
-
-                    if (ev === 'sqs' || ev === 'ownTopic') {
-                        // sqs and ownTopic create SNS Topic + Subscription + SQS Queue
-                        const yamlContent = ejs.render(resourceYamlTpl, {
-                            queueName: queueName
-                        });
-                        await appendToFile(yamlOutputPath, yamlContent);
-                        generatedCount++;
-                    } else if (ev === 'dsq' || ev === 'extTopic') {
-                        // extTopic and dsq create ONLY SQS Queue
-                        const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
-                        const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
-                        const yamlContent = ejs.render(resourceSqsYamlTpl, {
-                            queueName: queueName
-                        });
-                        await appendToFile(yamlOutputPath, yamlContent);
-                        generatedCount++;
-                    }
-                }
-            }
-        }
+  console.log('  [FlowResourceYamlGenerator] Generating SQS/SNS YAML resources for flows...');
 
-        // Generate SQS queues for S3 Event flows
-        if (flow.event && flow.event.includes('s3')) {
-            const queueNames = [
-                `${flowTag}CreatePreSignUrlSqs`,
-                `${flowTag}ReservedLimitSqs`
-            ];
-            
-            for (const qName of queueNames) {
-                const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
-                const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
-                const yamlContent = ejs.render(resourceSqsYamlTpl, {
-                    queueName: qName
-                });
-                await appendToFile(yamlOutputPath, yamlContent);
-                generatedCount++;
-            }
-        }
+  const resourceYamlDir = path.join(options.outputPath, 'resource', 'sls_yaml', 'generatedCode', 'source');
+  await fs.mkdir(resourceYamlDir, { recursive: true });
 
-        // Generate Dsq queues for Relationship
-        if (flow.isDynamicRelationshipType) {
-            // Usually Relationship has dead-letter queue processing
-            const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
-            const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
-            const queueName = flowTag + 'Dsq';
-            const yamlContent = ejs.render(resourceSqsYamlTpl, {
-                queueName: queueName
-            });
-            await appendToFile(yamlOutputPath, yamlContent);
-            generatedCount++;
-        }
+  const resourceYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceYaml.ejs');
+  const resourceBeforeLogicalYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceBeforeLogicalYaml.ejs');
+  const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
+
+  const resourceYamlTpl = await fs.readFile(resourceYamlTplPath, 'utf-8');
+  const resourceBeforeLogicalYamlTpl = await fs.readFile(resourceBeforeLogicalYamlTplPath, 'utf-8');
+  const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
+
+  let generatedCount = 0;
+  const yamlOutputPath = path.join(resourceYamlDir, 'generated-sns-in-sqs.yml');
+  await fs.writeFile(yamlOutputPath, '', 'utf-8');
+
+  const generatedResources = new Set();
+
+  async function appendUnique(resourceKey, template, templateData) {
+    if (generatedResources.has(resourceKey)) return;
+
+    generatedResources.add(resourceKey);
+    const yamlContent = ejs.render(template, templateData);
+    await appendToFile(yamlOutputPath, yamlContent);
+    generatedCount++;
+  }
+
+  const flows = getFlowsForGeneration(allSchemas);
+
+  for (const flow of flows) {
+    const flowTag = flow.flowTag;
+
+    if (flow.event && flow.event.includes('ownTopic')) {
+      await appendUnique(flowTag, resourceYamlTpl, { queueName: flowTag });
+
+      const generateCodeConfigs = flows
+        .filter((candidate) => candidate.generatedCodeConfig
+          && candidate.generatedCodeConfig.generatedCodeTag?.toLowerCase() === flowTag.toLowerCase())
+        .map((candidate) => ({
+          ...candidate.generatedCodeConfig,
+          flowTag: candidate.flowTag
+        }));
+
+      const beforeLogicalConfigs = generateCodeConfigs.filter((config) => config.codeHookTag === 'beforeLogical');
+      if (beforeLogicalConfigs.length > 0) {
+        const uniqueFlowTags = [...new Set(beforeLogicalConfigs.map((config) => config.flowTag))];
+        await appendUnique(`${flowTag}BeforeLogical`, resourceBeforeLogicalYamlTpl, {
+          queueName: `${flowTag}BeforeLogical`,
+          flowTags: uniqueFlowTags
+        });
+      }
+    } else if (flow.event && flow.event.includes('extTopic')) {
+      await appendUnique(`Process${flowTag}HdrSqs`, resourceSqsYamlTpl, {
+        queueName: `Process${flowTag}HdrSqs`
+      });
     }
 
-    // Add hardcoded ownTopic flows for CRUD, RBAC, Relationship
-    const systemOwnTopicFlows = [
-        'Create', 'Update', 'Delete', // CRUD
-        'CreateRelationship', 'UpdateRelationship', 'DeleteRelationship', 'ChangeRelationship', 'MoveRelationship', // Relationship
-        'CreateTargetRole', 'DeleteTargetRole', 'CreateRolePermissions', 'DeleteRolePermissions', 'CreateUserRole', 'DeleteUserFromRole' // RBAC
-    ];
-    for (const flowTag of systemOwnTopicFlows) {
-        const yamlContent = ejs.render(resourceYamlTpl, { queueName: flowTag });
-        await appendToFile(yamlOutputPath, yamlContent);
-        generatedCount++;
-        
-        // BeforeLogical queues for CRUD
-        if (['Create', 'Update', 'Delete'].includes(flowTag)) {
-            // Since we don't have beforeLogical configs here, we assume we might need them or we can just generate a generic one?
-            // For now, only custom flows generate beforeLogical dynamically above.
+    if (Array.isArray(flow.flowSteps)) {
+      for (const stepConfig of flow.flowSteps) {
+        const stepName = stepConfig.stepName;
+        if (stepName === 'InTag') continue;
+
+        const events = stepConfig.event || ['sqs'];
+        for (const ev of events) {
+          let queueName = `${flowTag}${stepName}`;
+          if (stepName === 'Complete') {
+            queueName = `${flowTag}Complete`;
+          }
+
+          if (ev === 'sqs' || ev === 'ownTopic') {
+            await appendUnique(queueName, resourceYamlTpl, { queueName });
+          } else if (ev === 'dsq' || ev === 'extTopic') {
+            await appendUnique(`${queueName}HdrDsq`, resourceSqsYamlTpl, {
+              queueName: `${queueName}HdrDsq`
+            });
+          }
         }
+      }
     }
 
-    // Generate Dsq queues for Relationship
-    const relationshipActions = ['CreateRelationship', 'UpdateRelationship', 'DeleteRelationship', 'GetRelationship', 'ChangeRelationship', 'MoveRelationship'];
-    const resourceSqsYamlTplPath = path.join(__dirname, 'templates', 'crud', 'ResourceSqsYaml.ejs');
-    const resourceSqsYamlTpl = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
-    for (const action of relationshipActions) {
-        const yamlContent = ejs.render(resourceSqsYamlTpl, { queueName: action + 'Dsq' });
-        await appendToFile(yamlOutputPath, yamlContent);
-        generatedCount++;
-    }
+    if (flow.event && flow.event.includes('s3')) {
+      const queueNames = [
+        `${flowTag}CreatePreSignUrlHdrSqs`,
+        `${flowTag}ReservedLimitHdrSqs`
+      ];
 
-    // Add System Queues
-    const systemQueues = [
-        'ProcessLogical',
-        'PaginateProcessLogical',
-        'FindData',
-        'Register',
-        'WebSocket',
-        'CreateObjectComplete',
-        'UpdateNodeComplete',
-        'DeleteNodeComplete',
-        'GetNodeComplete'
-    ];
-
-    const resourceSqsYamlTplGlobal = await fs.readFile(resourceSqsYamlTplPath, 'utf-8');
-
-    for (const sysQueue of systemQueues) {
-        const yamlContent = ejs.render(resourceSqsYamlTplGlobal, {
-            queueName: sysQueue
-        });
-        await appendToFile(yamlOutputPath, yamlContent);
-        generatedCount++;
+      for (const queueName of queueNames) {
+        await appendUnique(queueName, resourceSqsYamlTpl, { queueName });
+      }
     }
 
-    console.log(`  [FlowResourceYamlGenerator] Appended ${generatedCount} sections to generated-sns-in-sqs.yml.`);
+    if (flow.isDynamicRelationshipType) {
+      const queueName = `${flowTag}HdrDsq`;
+      await appendUnique(queueName, resourceSqsYamlTpl, { queueName });
+    }
+  }
+
+  const systemOwnTopicFlows = [
+    'Create',
+    'Update',
+    'Delete',
+    'CreateRelationship',
+    'UpdateRelationship',
+    'DeleteRelationship',
+    'ChangeRelationship',
+    'MoveRelationship',
+    'CreateTargetRole',
+    'DeleteTargetRole',
+    'CreateRolePermissions',
+    'DeleteRolePermissions',
+    'CreateUserRole',
+    'DeleteUserFromRole'
+  ];
+
+  for (const flowTag of systemOwnTopicFlows) {
+    await appendUnique(flowTag, resourceYamlTpl, { queueName: flowTag });
+  }
+
+  const relationshipActions = [
+    'CreateRelationship',
+    'UpdateRelationship',
+    'DeleteRelationship',
+    'GetRelationship',
+    'ChangeRelationship',
+    'MoveRelationship'
+  ];
+
+  for (const action of relationshipActions) {
+    const queueName = `${action}HdrDsq`;
+    await appendUnique(queueName, resourceSqsYamlTpl, { queueName });
+  }
+
+  const systemQueues = [
+    'ProcessLogical',
+    'PaginateProcessLogical',
+    'FindData',
+    'Register',
+    'WebSocket',
+    'CreateObjectComplete',
+    'UpdateNodeComplete',
+    'DeleteNodeComplete',
+    'GetNodeComplete'
+  ];
+
+  for (const sysQueue of systemQueues) {
+    const queueName = `${sysQueue}HdrSqs`;
+    await appendUnique(queueName, resourceSqsYamlTpl, { queueName });
+  }
+
+  console.log(`  [FlowResourceYamlGenerator] Appended ${generatedCount} sections to generated-sns-in-sqs.yml.`);
 }

package/src/codeGenerators/resource/sls_yaml/templates/crud/ResourceYaml.ejs

@@ -10,30 +10,30 @@
     Type: AWS::SNS::Subscription
     Properties:
       TopicArn: !Ref In<%- queueName %>
-      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>Sqs"
+      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>HdrSqs"
       Protocol: "sqs"
 
   ##===== [Queue]
-  <%- queueName %>Sqs:
+  <%- queueName %>HdrSqs:
     Type: "AWS::SQS::Queue"
     Properties:
-      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>Sqs
+      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>HdrSqs
       RedrivePolicy:
         deadLetterTargetArn:
           Fn::GetAtt:
-            - <%- queueName %>SqsDLQ
+            - <%- queueName %>HdrSqsDLQ
             - Arn
         maxReceiveCount: 3
       VisibilityTimeout: 120
 
   ##===== [Queue DLQ]
-  <%- queueName %>SqsDLQ:
+  <%- queueName %>HdrSqsDLQ:
     Type: AWS::SQS::Queue
     Properties:
-      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>SqsDLQ
+      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>HdrSqsDLQ
 
   ##===== [Queue Policy]
-  <%- queueName %>SqsPolicy:
+  <%- queueName %>HdrSqsPolicy:
     Type: AWS::SQS::QueuePolicy
     Properties:
       PolicyDocument:
@@ -44,11 +44,11 @@
             Principal: "*"
             Resource:
               Fn::GetAtt:
-                - <%- queueName %>Sqs
+                - <%- queueName %>HdrSqs
                 - Arn
             Action: "SQS:SendMessage"
       Queues:
-        - Ref: <%- queueName %>Sqs
+        - Ref: <%- queueName %>HdrSqs
 
   #<#<%- queueName %>QueueSetting#>
-  #<#/<%- queueName %>QueueSetting#>
+  #<#/<%- queueName %>QueueSetting#>

package/src/generateCode.js

@@ -5,8 +5,6 @@ import { parseObjectSchemas } from './parsers/objectSchemaParser.js';
 import { parseRelationshipSchemas } from './parsers/relationshipSchemaParser.js';
 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';
@@ -33,85 +31,106 @@ import { generateFindDataYaml } from './codeGenerators/app/sls_yaml/FindDataYaml
 import { policyRegistry } from './codeGenerators/app/sls_yaml/_policy/PolicyRegistry.js';
 import { emitManagedPolicies } from './codeGenerators/app/sls_yaml/_policy/PolicyEmitter.js';
 
-export async function generateCode(rootPath, options) {
+function createGeneratorOptions(rootPath, options = {}) {
+  return {
+    outputPath: options.outputPath || rootPath
+  };
+}
+
+export async function generateCode(rootPath, options = {}) {
   console.log(
     '[INFO] [generateCode] STATUS=STARTING | Generating code files from all schemas...'
   );
 
+  const generatorOptions = createGeneratorOptions(rootPath, options);
+  const { outputPath } = generatorOptions;
+
   // Clean workspace
-  const outputPath = options.outputPath || rootPath;
-  const generatedCodePath = path.join(outputPath, 'app', 'src', 'generatedCode');
+  const generatedCodePath = path.join(
+    outputPath,
+    'app',
+    'src',
+    'generatedCode'
+  );
 
   // Backup existing hook files to prevent them from being wiped out
- const hookBackups = [];
- const hookDirs = new Set();
- 
- function getHookTagMatchers(filePath) {
-   if (filePath.endsWith('.js')) {
-     return {
-       anyTag: /\/\/\(<(\w+)>\)([\s\S]*?)\/\/\(<\/\1>\)/gm,
-       tagPattern: (name) => new RegExp(
-         `\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)`,
-         'gm'
-       )
-     };
-   }
- 
-   if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
-     return {
-       anyTag: /#<#(\w+)#>([\s\S]*?)#<#\/\1#>/gm,
-       tagPattern: (name) => new RegExp(
-         `#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`,
-         'gm'
-       )
-     };
-   }
- 
-   return null;
- }
- 
- function mergeHookIntoSource(sourceContent, hookContent, filePath) {
-   const matchers = getHookTagMatchers(filePath);
-   if (!matchers) return hookContent;
- 
-   return sourceContent.replace(matchers.anyTag, (match, tagName) => (
-     hookContent.match(matchers.tagPattern(tagName))?.[0] ?? match
-   ));
- }
- 
- function collectHookBackups(currentDir) {
-   if (!fs.existsSync(currentDir)) return;
- 
-   const items = fs.readdirSync(currentDir, { withFileTypes: true });
-   const hasSource = items.some((item) => item.isDirectory() && item.name === 'source');
-   const hasHook = items.some((item) => item.isDirectory() && item.name === 'hook');
- 
-   if (hasSource && hasHook) {
-     const hookPath = path.join(currentDir, 'hook');
-     hookDirs.add(path.relative(outputPath, hookPath));
-     const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
- 
-     for (const hookItem of hookItems) {
-       if (!hookItem.isFile()) continue;
-       const hookFilePath = path.join(hookPath, hookItem.name);
-       hookBackups.push({
-         relativePath: path.relative(outputPath, hookPath),
-         name: hookItem.name,
-         content: fs.readFileSync(hookFilePath)
-       });
-     }
-   }
- 
-   for (const item of items) {
-     if (!item.isDirectory() || item.name === 'source' || item.name === 'hook') continue;
-     collectHookBackups(path.join(currentDir, item.name));
-   }
- }
- 
- console.log('[INFO] [generateCode] STATUS=BACKUP | Backing up existing hook files...');
- collectHookBackups(outputPath);
-
-console.log(
+  const hookBackups = [];
+  const hookDirs = new Set();
+
+  function getHookTagMatchers(filePath) {
+    if (filePath.endsWith('.js')) {
+      return {
+        anyTag: /\/\/\(<(\w+)>\)([\s\S]*?)\/\/\(<\/\1>\)/gm,
+        tagPattern: name =>
+          new RegExp(
+            `\\/\\/\\(<${name}>\\)([\\s\\S]*?)\\/\\/\\(<\\/${name}>\\)`,
+            'gm'
+          )
+      };
+    }
+
+    if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
+      return {
+        anyTag: /#<#(\w+)#>([\s\S]*?)#<#\/\1#>/gm,
+        tagPattern: name =>
+          new RegExp(`#<#${name}#>([\\s\\S]*?)#<#\\/${name}#>`, 'gm')
+      };
+    }
+
+    return null;
+  }
+
+  function mergeHookIntoSource(sourceContent, hookContent, filePath) {
+    const matchers = getHookTagMatchers(filePath);
+    if (!matchers) return hookContent;
+
+    return sourceContent.replace(
+      matchers.anyTag,
+      (match, tagName) =>
+        hookContent.match(matchers.tagPattern(tagName))?.[0] ?? match
+    );
+  }
+
+  function collectHookBackups(currentDir) {
+    if (!fs.existsSync(currentDir)) return;
+
+    const items = fs.readdirSync(currentDir, { withFileTypes: true });
+    const hasSource = items.some(
+      item => item.isDirectory() && item.name === 'source'
+    );
+    const hasHook = items.some(
+      item => item.isDirectory() && item.name === 'hook'
+    );
+
+    if (hasSource && hasHook) {
+      const hookPath = path.join(currentDir, 'hook');
+      hookDirs.add(path.relative(outputPath, hookPath));
+      const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
+
+      for (const hookItem of hookItems) {
+        if (!hookItem.isFile()) continue;
+        const hookFilePath = path.join(hookPath, hookItem.name);
+        hookBackups.push({
+          relativePath: path.relative(outputPath, hookPath),
+          name: hookItem.name,
+          content: fs.readFileSync(hookFilePath)
+        });
+      }
+    }
+
+    for (const item of items) {
+      if (!item.isDirectory() || item.name === 'source' || item.name === 'hook')
+        continue;
+      collectHookBackups(path.join(currentDir, item.name));
+    }
+  }
+
+  console.log(
+    '[INFO] [generateCode] STATUS=BACKUP | Backing up existing hook files...'
+  );
+  collectHookBackups(outputPath);
+
+  console.log(
     '[INFO] [generateCode] STATUS=CLEANUP | Removing old generatedCode and resource directories...'
   );
   await fs.promises.rm(generatedCodePath, {
@@ -150,8 +169,6 @@ console.log(
   console.log('[INFO] [generateCode] STATUS=VALIDATING | Validating Flows...');
   validateFlowsForGeneration(allSchemas.flowsForGeneration);
 
-  const generatorOptions = { outputPath: options.outputPath || rootPath };
-
   // 2. Generation Pipeline
   await generateEndpointsFlow(allSchemas, generatorOptions);
   await generateFlowMainFunction(allSchemas, generatorOptions);
@@ -161,11 +178,19 @@ console.log(
   await generateFlowResourceYaml(allSchemas, generatorOptions);
   await generateRbacFlows(allSchemas, generatorOptions);
   await generateRelationshipFlows(allSchemas, generatorOptions);
-  await generateWebSocket(allSchemas.flowsForGeneration, '', generatorOptions.outputPath);
-  await generateRegisterFlow(allSchemas.flowsForGeneration, '', generatorOptions.outputPath);
+  await generateWebSocket(
+    allSchemas.flowsForGeneration,
+    '',
+    generatorOptions.outputPath
+  );
+  await generateRegisterFlow(
+    allSchemas.flowsForGeneration,
+    '',
+    generatorOptions.outputPath
+  );
 
   // Call FunctionYamlGenerator after all Handlers have been generated
-  await generateFunctionYaml(allSchemas, options);
+  await generateFunctionYaml(allSchemas, generatorOptions);
   await generateDynamoDBTables(allSchemas, generatorOptions);
   await generateFindData(allSchemas, generatorOptions);
   await generateCodeLibs(generatorOptions);
@@ -178,69 +203,76 @@ console.log(
   await generateInitialSetup(allSchemas, generatorOptions);
 
   // 3. Hook Integration
- console.log(
-   '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
- );
- 
- function processSourceHooks(currentDir) {
-   if (!fs.existsSync(currentDir)) return;
- 
-   const items = fs.readdirSync(currentDir, { withFileTypes: true });
-   const hasSource = items.some((item) => item.isDirectory() && item.name === 'source');
-   const hasHook = items.some((item) => item.isDirectory() && item.name === 'hook');
-
-   if (hasSource && hasHook) {
-     const sourcePath = path.join(currentDir, 'source');
-     const hookPath = path.join(currentDir, 'hook');
-     const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
- 
-     for (const hookItem of hookItems) {
-       if (!hookItem.isFile()) continue;
- 
-       const hookFile = path.join(hookPath, hookItem.name);
-       const sourceFile = path.join(sourcePath, hookItem.name);
- 
-       if (!fs.existsSync(sourceFile)) {
-         fs.copyFileSync(hookFile, sourceFile);
-         console.log(
-           `[INFO] [generateCode] HOOK APPLIED: Created ${hookItem.name} from hook.`
-         );
-         continue;
-       }
- 
-       const mergedContent = mergeHookIntoSource(
-         fs.readFileSync(sourceFile, 'utf8'),
-         fs.readFileSync(hookFile, 'utf8'),
-         sourceFile
-       );
-       fs.writeFileSync(sourceFile, mergedContent);
-       console.log(
-         `[INFO] [generateCode] HOOK APPLIED: Merged ${hookItem.name} into source.`
-       );
-     }
-   } else if (hasSource) {
-     fs.mkdirSync(path.join(currentDir, 'hook'), { recursive: true });
-   }
- 
-   for (const item of items) {
-     if (!item.isDirectory() || item.name === 'source' || item.name === 'hook') continue;
-     processSourceHooks(path.join(currentDir, item.name));
-   }
- }
- 
- // Restore backed-up hooks
- if (hookDirs.size > 0 || hookBackups.length > 0) {
-   console.log(`[INFO] [generateCode] STATUS=RESTORE | Restoring ${hookBackups.length} hook files...`);
-   for (const relativeHookDir of hookDirs) {
-     fs.mkdirSync(path.join(outputPath, relativeHookDir), { recursive: true });
-   }
-   for (const backup of hookBackups) {
-     const hookDir = path.join(outputPath, backup.relativePath);
-     fs.writeFileSync(path.join(hookDir, backup.name), backup.content);
-   }
- }
- 
- processSourceHooks(generatorOptions.outputPath);
+  console.log(
+    '[INFO] [generateCode] STATUS=HOOKS | Processing hook folders beside source folders...'
+  );
+
+  function processSourceHooks(currentDir) {
+    if (!fs.existsSync(currentDir)) return;
+
+    const items = fs.readdirSync(currentDir, { withFileTypes: true });
+    const hasSource = items.some(
+      item => item.isDirectory() && item.name === 'source'
+    );
+    const hasHook = items.some(
+      item => item.isDirectory() && item.name === 'hook'
+    );
+
+    if (hasSource && hasHook) {
+      const sourcePath = path.join(currentDir, 'source');
+      const hookPath = path.join(currentDir, 'hook');
+      const hookItems = fs.readdirSync(hookPath, { withFileTypes: true });
+
+      for (const hookItem of hookItems) {
+        if (!hookItem.isFile()) continue;
+
+        const hookFile = path.join(hookPath, hookItem.name);
+        const sourceFile = path.join(sourcePath, hookItem.name);
+
+        if (!fs.existsSync(sourceFile)) {
+          fs.copyFileSync(hookFile, sourceFile);
+          console.log(
+            `[INFO] [generateCode] HOOK APPLIED: Created ${hookItem.name} from hook.`
+          );
+          continue;
+        }
+
+        const mergedContent = mergeHookIntoSource(
+          fs.readFileSync(sourceFile, 'utf8'),
+          fs.readFileSync(hookFile, 'utf8'),
+          sourceFile
+        );
+        fs.writeFileSync(sourceFile, mergedContent);
+        console.log(
+          `[INFO] [generateCode] HOOK APPLIED: Merged ${hookItem.name} into source.`
+        );
+      }
+    } else if (hasSource) {
+      fs.mkdirSync(path.join(currentDir, 'hook'), { recursive: true });
+    }
+
+    for (const item of items) {
+      if (!item.isDirectory() || item.name === 'source' || item.name === 'hook')
+        continue;
+      processSourceHooks(path.join(currentDir, item.name));
+    }
+  }
+
+  // Restore backed-up hooks
+  if (hookDirs.size > 0 || hookBackups.length > 0) {
+    console.log(
+      `[INFO] [generateCode] STATUS=RESTORE | Restoring ${hookBackups.length} hook files...`
+    );
+    for (const relativeHookDir of hookDirs) {
+      fs.mkdirSync(path.join(outputPath, relativeHookDir), { recursive: true });
+    }
+    for (const backup of hookBackups) {
+      const hookDir = path.join(outputPath, backup.relativePath);
+      fs.writeFileSync(path.join(hookDir, backup.name), backup.content);
+    }
+  }
+
+  processSourceHooks(generatorOptions.outputPath);
 
   console.log(
     '[INFO] [generateCode] STATUS=FINISHED | Code generation complete.'

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

@@ -22,18 +22,20 @@ export default {
       messageAttributes: ['userId', 'correlationId']
     },
     <% if (hasBeforeLogicalStep) { %>
-    {
-      stepName: 'beforeLogical',
-      properties: [],
-      messageAttributes: ['userId', 'correlationId']
-    },
+  {
+    stepName: 'beforeLogical',
+    event: ['sqs'],
+    properties: [],
+    messageAttributes: ['userId', 'correlationId']
+  },
     <% } %>
     <% if (['Create', 'Update', 'Delete'].includes(action)) { %>
-    {
-      stepName: 'Complete',
-      properties: [],
-      messageAttributes: ['userId', 'correlationId']
-    }
+  {
+    stepName: 'Complete',
+    event: ['sqs'],
+    properties: [],
+    messageAttributes: ['userId', 'correlationId']
+  }
     <% } %>
   ]
 };

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

@@ -22,11 +22,12 @@ export default {
       messageAttributes: ['userId', 'correlationId']
     }
     <% if (hasCompleteStep) { %>,
-    {
-      stepName: 'Complete',
-      properties: [],
-      messageAttributes: ['userId', 'correlationId']
-    }
+  {
+    stepName: 'Complete',
+    event: ['sqs'],
+    properties: [],
+    messageAttributes: ['userId', 'correlationId']
+  }
     <% } %>
   ]
 };