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

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

@@ -0,0 +1,49 @@
+export const CRUD_FLOW_TAGS = ['Create', 'Update', 'Delete', 'Get'];
+
+export const RBAC_FLOW_TAGS = [
+    'CreateRolePermissions',
+    'CreateTargetRole',
+    'CreateUserRole',
+    'DeleteRolePermissions',
+    'DeleteTargetRole',
+    'DeleteUserFromRole',
+    'ListRolePermissions',
+    'ListTargetRole',
+    'ListUserInRoles'
+];
+
+export const REL_FLOW_TAGS = [
+    'CreateRelationship',
+    'UpdateRelationship',
+    'DeleteRelationship',
+    'GetRelationship',
+    'ChangeRelationship',
+    'MoveRelationship'
+];
+
+function equalsIgnoreCase(a, b) {
+    return String(a || '').toLowerCase() === String(b || '').toLowerCase();
+}
+
+function includesFlowTag(tags, flowTag) {
+    return tags.some(tag => equalsIgnoreCase(tag, flowTag));
+}
+
+export function isCrudFlow(flowTag) {
+    return includesFlowTag(CRUD_FLOW_TAGS, flowTag);
+}
+
+export function isRbacFlow(flowTag) {
+    return includesFlowTag(RBAC_FLOW_TAGS, flowTag);
+}
+
+export function isRelationshipFlow(flowTag) {
+    return includesFlowTag(REL_FLOW_TAGS, flowTag);
+}
+
+export function getFlowOutputSubDir(flowTag) {
+    if (isCrudFlow(flowTag)) return 'FlowEndpoints';
+    if (isRbacFlow(flowTag)) return 'FlowRbac';
+    if (isRelationshipFlow(flowTag)) return 'FlowRelationshipEndpoints';
+    return 'FlowSchemas';
+}

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

@@ -0,0 +1,102 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { EVENT_HANDLERS } from '../events/registry.js';
+import { STATUS_HANDLERS } from './registry.js';
+import { getFlowOutputSubDir, isRbacFlow, isRelationshipFlow } from './flowClassifier.js';
+import { normalizeEvents } from './eventTypes.js';
+import { processMainFileName, upperFirst } from './flowNaming.js';
+import { getFlowsForGeneration, getGeneratedCodeConfigs } from './flowSelection.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateFlowEntryPoint(allSchemas, options) {
+    console.log('  [FlowEntryPointGenerator] Generating Flow Entry Points...');
+    const baseOutputDir = path.join(options.outputPath, 'app', 'src', 'generatedCode');
+
+    const templates = {
+        sqs: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrSqs.ejs'), 'utf-8'),
+        api: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrApi.ejs'), 'utf-8'),
+        inv: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrInv.ejs'), 'utf-8'),
+        endpointMain: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'endpoint', 'FlowEndpoint_Main.ejs'), 'utf-8'),
+        wbsMain: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'endpoint', 'FlowMain_Wbs.ejs'), 'utf-8'),
+        endpointHdrWbs: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'endpoint', 'FlowEndpoint_HdrWbs.ejs'), 'utf-8')
+    };
+
+    let generatedCount = 0;
+
+    const flows = getFlowsForGeneration(allSchemas);
+    for (const flow of flows) {
+        const flowTag = flow.flowTag;
+
+        // Skip relationship flows (they are handled by RelationshipFlowGenerator)
+        if (isRelationshipFlow(flowTag)) continue;
+        
+        const subDir = getFlowOutputSubDir(flowTag);
+
+        const upperCaseFlowTag = upperFirst(flowTag);
+        const flowOutputDir = path.join(baseOutputDir, subDir, upperCaseFlowTag, 'source');
+        await fs.mkdir(flowOutputDir, { recursive: true });
+
+        // NOTE: Changed to Process${upperCaseFlowTag}_Main to match legacy.
+        const mainFileName = processMainFileName(flowTag);
+        // 2. Generate Handlers based on event array using Registry
+        const events = normalizeEvents(flow.event, ['ownTopic']);
+        
+        // Use invocationType from generatedCodeConfig if available
+        if (flow.generatedCodeConfig && flow.generatedCodeConfig.invocationType) {
+            if (!events.includes(flow.generatedCodeConfig.invocationType)) {
+                events.push(flow.generatedCodeConfig.invocationType);
+            }
+        }
+        
+        for (const ev of events) {
+            const generateCode = getGeneratedCodeConfigs(flows, flowTag);
+
+            const handlerGenerator = EVENT_HANDLERS[ev];
+            if (handlerGenerator) {
+                // Pass generateCode as 6th param
+                await handlerGenerator(flow, '', flowOutputDir, mainFileName, templates, generateCode);
+                generatedCount++;
+
+                // Generate BeforeLogical HdrSqs if there are any beforeLogical configs
+                const beforeLogicalConfigs = generateCode.filter(c => c.codeHookTag === 'beforeLogical');
+                if (beforeLogicalConfigs.length > 0) {
+                    const beforeLogicalVars = {
+                        flowTag: flowTag,
+                        flowStepName: '',
+                        mainFileName: `${upperCaseFlowTag}BeforeLogical_Main`,
+                        functionName: `${flowTag}BeforeLogicalMain`,
+                        queueName: `${flowTag}BeforeLogicalHdrSqs`
+                    };
+                    const sqsContent = ejs.render(templates.sqs, beforeLogicalVars);
+                    await fs.writeFile(path.join(flowOutputDir, `${upperCaseFlowTag}BeforeLogical_HdrSqs.js`), sqsContent, 'utf-8');
+                    generatedCount++;
+                }
+
+            } else {
+                console.warn(`  [FlowEntryPointGenerator] Unsupported event: ${ev} in flow: ${flowTag}`);
+            }
+        }
+
+        // 3. Process statusType
+        const statusType = flow.statusType;
+        if (statusType === 'statusField' && !isRbacFlow(flowTag) && events.includes('ownTopic') && events.includes('extTopic')) {
+            const statusHandler = STATUS_HANDLERS[statusType];
+            if (statusHandler) {
+                await statusHandler(flow, '', options.outputPath);
+                generatedCount++;
+            }
+        } else if (statusType && statusType !== 'none' && statusType !== 'storedCache' && statusType !== 'statusField') {
+            const statusHandler = STATUS_HANDLERS[statusType];
+            if (statusHandler) {
+                await statusHandler(flow, '', options.outputPath);
+                generatedCount++;
+            }
+        }
+    }
+
+    console.log(`  [FlowEntryPointGenerator] Generated ${generatedCount} files for Flow Entry Points.`);
+}

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

@@ -0,0 +1,160 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { getFlowOutputSubDir, isCrudFlow, isRbacFlow, isRelationshipFlow } from './flowClassifier.js';
+import { processMainFileName, upperFirst } from './flowNaming.js';
+import { getFlowsForGeneration, getGeneratedCodeConfigs } from './flowSelection.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateFlowMainFunction(allSchemas, options) {
+  console.log(
+    '  [FlowMainFunctionGenerator] Generating Flow Main Functions...'
+  );
+  const baseOutputDir = path.join(
+    options.outputPath,
+    'app',
+    'src',
+    'generatedCode'
+  );
+
+  let generatedCount = 0;
+
+  const flows = getFlowsForGeneration(allSchemas);
+  for (const flow of flows) {
+    const flowTag = flow.flowTag;
+
+    // Skip custom flows, they are handled completely by their own Generators
+    if (isRbacFlow(flowTag) || isRelationshipFlow(flowTag))
+      continue;
+
+    // Skip S3 flows to match legacy behavior where S3 flows bypass the Main function
+    if (flow.event && flow.event.includes('s3'))
+      continue;
+
+    const isCrud = isCrudFlow(flowTag);
+    const subDir = getFlowOutputSubDir(flowTag);
+
+    const upperCaseFlowTag = upperFirst(flowTag);
+    const flowOutputDir = path.join(baseOutputDir, subDir, upperCaseFlowTag, 'source');
+    await fs.mkdir(flowOutputDir, { recursive: true });
+
+    // For ownTopic flows the SNS-publish file is <FlowTag>_Main.js; others stay Process<FlowTag>_Main.js
+    const isOwnTopic = !isCrud && flow.event && flow.event.includes('ownTopic');
+    const mainFileName = isOwnTopic
+      ? `${upperCaseFlowTag}_Main`
+      : processMainFileName(flowTag);
+    const topicArn = `${upperCaseFlowTag}_In`;
+
+    const generateCode = getGeneratedCodeConfigs(flows, flowTag, { includeFlowTag: true });
+
+    let templateName = 'FlowEndpoint_Main.ejs';
+    if (['Create', 'Update', 'Delete', 'Get'].includes(flowTag)) {
+      templateName = `${flowTag}Endpoint_Main.ejs`;
+    } else if (isOwnTopic) {
+      // Non-CRUD flow with ownTopic: WebSocket entry that fetches flowSchema and publishes to SNS In topic
+      templateName = 'FlowMain_Wbs.ejs';
+    }
+
+    // crud templates live under FlowEndpoints (the only output child that uses them);
+    // shared endpoint templates (FlowEndpoint_Main, FlowMain_Wbs) live under _internal/_shared/endpoint
+    const templateBaseDir = templateName.startsWith('crud/') || ['CreateEndpoint_Main.ejs', 'UpdateEndpoint_Main.ejs', 'DeleteEndpoint_Main.ejs', 'GetEndpoint_Main.ejs'].includes(templateName)
+        ? path.join(__dirname, '..', '..', 'FlowEndpoints', 'templates', 'crud')
+        : path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'endpoint');
+    const mainTemplateStr = await fs.readFile(
+      path.join(templateBaseDir, templateName),
+      'utf-8'
+    );
+
+    const inTagStep = flow.flowSteps && flow.flowSteps.find(
+      s => s.stepName === 'InTag'
+    );
+    let inTagConfig = inTagStep ? { ...inTagStep } : null;
+
+    if (inTagConfig) {
+      if (inTagConfig.properties && Array.isArray(inTagConfig.properties)) {
+        inTagConfig.properties = inTagConfig.properties.map(p => {
+          if (typeof p === 'string') {
+            return (flow.stepProperties && flow.stepProperties[p]) ? flow.stepProperties[p] : { propertyName: p, type: 'string' };
+          }
+          return p;
+        });
+      }
+      if (inTagConfig.messageAttributes && Array.isArray(inTagConfig.messageAttributes)) {
+        inTagConfig.messageAttributes = inTagConfig.messageAttributes.map(p => {
+          if (typeof p === 'string') {
+            return (flow.stepMessageAttributes && flow.stepMessageAttributes[p]) ? flow.stepMessageAttributes[p] : { propertyName: p, type: 'string' };
+          }
+          return p;
+        });
+      }
+    }
+
+    const mainContent = ejs.render(mainTemplateStr, {
+      flowTag: flowTag,
+      upperCaseFlowTag: upperCaseFlowTag,
+      topicArn: topicArn,
+      generateCode: generateCode,
+      flow: flow,
+      inTagConfig: inTagConfig
+    });
+    await fs.writeFile(
+      path.join(flowOutputDir, `${mainFileName}.js`),
+      mainContent,
+      'utf-8'
+    );
+
+    // For ownTopic flows: also generate Process${FlowTag}_Main.js (simple endpoint, triggered from SQS)
+    if (isOwnTopic) {
+      const processMainTemplateStr = await fs.readFile(
+        path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'endpoint', 'FlowEndpoint_Main.ejs'),
+        'utf-8'
+      );
+      const processMainContent = ejs.render(processMainTemplateStr, {
+        flowTag: flowTag,
+        upperCaseFlowTag: upperCaseFlowTag,
+        generateCode: generateCode,
+        flow: flow,
+        inTagConfig: inTagConfig
+      });
+      await fs.writeFile(
+        path.join(flowOutputDir, `${processMainFileName(flowTag)}.js`),
+        processMainContent,
+        'utf-8'
+      );
+    }
+
+    // 2. Generate BeforeLogical Main Logic File if needed (CRUD flows only)
+    const beforeLogicalConfigs = generateCode.filter(c => c.codeHookTag === 'beforeLogical');
+    if (isCrud && beforeLogicalConfigs.length > 0) {
+      const beforeLogicalTemplateStr = await fs.readFile(
+        path.join(__dirname, '..', '..', 'FlowEndpoints', 'templates', 'FlowEndpointBeforeLogical_Main.ejs'),
+        'utf-8'
+      );
+      
+      const beforeLogicalFileName = `${upperCaseFlowTag}BeforeLogical_Main`;
+      const beforeLogicalContent = ejs.render(beforeLogicalTemplateStr, {
+        flowTag: flowTag,
+        upperCaseFlowTag: upperCaseFlowTag,
+        generateCode: generateCode,
+        flow: flow,
+        inTagConfig: inTagConfig
+      });
+      
+      await fs.writeFile(
+        path.join(flowOutputDir, `${beforeLogicalFileName}.js`),
+        beforeLogicalContent,
+        'utf-8'
+      );
+      generatedCount++;
+    }
+
+    generatedCount++;
+  }
+
+  console.log(
+    `  [FlowMainFunctionGenerator] Generated ${generatedCount} files for Flow Main Functions.`
+  );
+}

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

@@ -0,0 +1,21 @@
+export function upperFirst(str) {
+    if (!str) return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function lowerFirst(str) {
+    if (!str) return str;
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+export function processMainFileName(flowTag) {
+    return `Process${upperFirst(flowTag)}_Main`;
+}
+
+export function processFunctionName(flowTag) {
+    return `Process${upperFirst(flowTag)}`;
+}
+
+export function flowSourceLocation(subDir, flowTag) {
+    return `src/generatedCode/${subDir}/${upperFirst(flowTag)}/source/`;
+}

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

@@ -0,0 +1,20 @@
+export function getFlowsForGeneration(allSchemas) {
+    return allSchemas.flowsForGeneration || allSchemas.flows || [];
+}
+
+export function getGeneratedCodeConfigs(flows, flowTag, options = {}) {
+    return flows
+        .filter(flow => {
+            const config = flow.generatedCodeConfig;
+            return config?.generatedCodeTag &&
+                config.generatedCodeTag.toLowerCase() === flowTag.toLowerCase();
+        })
+        .map(flow => {
+            if (!options.includeFlowTag) return flow.generatedCodeConfig;
+
+            return {
+                ...flow.generatedCodeConfig,
+                flowTag: flow.flowTag
+            };
+        });
+}

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

@@ -0,0 +1,229 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { getFlowOutputSubDir, isRbacFlow, isRelationshipFlow } from './flowClassifier.js';
+import { getStepEventHandlerConfig, normalizeEvents } from './eventTypes.js';
+import { normalizeFlowSteps } from './flowStepNormalizer.js';
+import { getFlowsForGeneration } from './flowSelection.js';
+import { upperFirst } from './flowNaming.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateFlowSteps(allSchemas, options) {
+    console.log('  [FlowStepGenerator] Generating Custom FlowSteps...');
+    const baseOutputDir = path.join(options.outputPath, 'app', 'src', 'generatedCode');
+
+    // Read templates
+    const templates = {
+        main: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'FlowStep_Main.ejs'), 'utf-8'),
+        complete: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'FlowEndpointComplete_Main.ejs'), 'utf-8'),
+        sqs: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrSqs.ejs'), 'utf-8'),
+        api: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrApi.ejs'), 'utf-8'),
+        inv: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrInv.ejs'), 'utf-8'),
+
+        // Advanced Custom Flow Logic Templates
+        pluginMain: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'plugIns', 'FlowStep_PlugIn_Main.ejs'), 'utf-8').catch(() => ''),
+        recievePluginMain: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'plugIns', 'FlowStep_RecievePlugIn_Main.ejs'), 'utf-8').catch(() => ''),
+        byConfigAwaitingMain: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'plugIns', 'FlowStep_ByConfig_Awaiting_Main.ejs'), 'utf-8').catch(() => ''),
+        byConfigPaginatedMain: await fs.readFile(path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'plugIns', 'FlowStep_ByConfig_Paginated_Main.ejs'), 'utf-8').catch(() => ''),
+        templateAwaitingStep: path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'plugIns', 'templateAwaitingStep.ejs'),
+        templateSendPlugin: path.join(__dirname, '..', '..', 'FlowSchemas', 'templates', 'step', 'plugIns', 'templateSendPlugin.ejs')
+    };
+    
+    let generatedCount = 0;
+
+    const flows = getFlowsForGeneration(allSchemas);
+    for (const flow of flows) {
+        const flowTag = flow.flowTag;
+
+        // Skip custom flows (case-insensitive to prevent duplicate generation)
+        if (isRbacFlow(flowTag) || isRelationshipFlow(flowTag)) continue;
+
+        if (!flow.flowSteps) continue;
+
+        const subDir = getFlowOutputSubDir(flowTag);
+
+        // Result-Driven: Group by FlowTag/source
+        const upperCaseFlowTag = upperFirst(flowTag);
+        const flowOutputDir = path.join(baseOutputDir, subDir, upperCaseFlowTag, 'source');
+
+        let createdDir = false;
+
+        for (const stepConfig of normalizeFlowSteps(flow.flowSteps)) {
+            const stepName = stepConfig.stepName;
+            if (['In', 'InTag', 'Out', 'beforeLogical'].includes(stepName)) continue;
+
+            if (!createdDir) {
+                await fs.mkdir(flowOutputDir, { recursive: true });
+                createdDir = true;
+            }
+            const mainFileName = `${upperCaseFlowTag}${stepName}_Main`;
+
+            // Advanced Config Parsing
+            const hasPlugInHooks = stepConfig.plugInHooks && stepConfig.plugInHooks.length > 0;
+            const handleLogic = stepConfig.settings?.handleLogic || 'none';
+            const childFlow = stepConfig.settings?.flowType || '';
+
+            // 1. Generate Main Logic File
+            let templateToUse = templates.main;
+            let renderData = {
+                flowTag: flowTag,
+                upperCaseFlowTag: upperCaseFlowTag,
+                upperFlowTag: upperCaseFlowTag,
+                flowStepName: stepName,
+                upperFlowStepName: upperFirst(stepName),
+                upperHandleLogic: upperFirst(handleLogic),
+                functionName: `${flowTag}${stepName}`,
+            };
+
+            const isCompleteStep = stepName === 'Complete';
+            // Base Step Generation
+            if (isCompleteStep) {
+                templateToUse = templates.complete;
+            } else if (hasPlugInHooks) {
+                templateToUse = templates.pluginMain;
+                
+                const firstHook = stepConfig.plugInHooks[0];
+                let targetPlugIn = null;
+                const objSchema = allSchemas.objects ? allSchemas.objects.find(o => o.objectType === firstHook.objType?.objectType) : null;
+                if (objSchema && objSchema.plugIns) {
+                    for (const plugInConfig of Object.values(objSchema.plugIns)) {
+                        if (plugInConfig.plugInHooks) {
+                            targetPlugIn = plugInConfig.plugInHooks.find(h => h.plugInHookTagType?.plugInHookTag === firstHook.plugInHookTag);
+                            if (targetPlugIn) break;
+                        }
+                    }
+                }
+                
+                let targetUrl = targetPlugIn ? targetPlugIn.plugInHookTagType?.targetUrl : '';
+                let invokeType = targetPlugIn ? targetPlugIn.invocationType : 'sync';
+                if (invokeType === 'sync' && targetUrl) {
+                    targetUrl += '/recievePlugInRequestSync';
+                }
+
+                Object.assign(renderData, {
+                    havePlugIn: !!targetPlugIn,
+                    invokeType: invokeType,
+                    targetUrl: targetUrl,
+                    handleLogic: handleLogic,
+                    childFlow: childFlow,
+                    mainObjType: firstHook.objType?.objectType || firstHook.objType,
+                    templateAwaitingStep: templates.templateAwaitingStep,
+                    templateSendPlugin: templates.templateSendPlugin
+                });
+            }
+
+            const mainContent = ejs.render(templateToUse, renderData);
+            await fs.writeFile(path.join(flowOutputDir, `${mainFileName}.js`), mainContent, 'utf-8');
+            generatedCount++;
+
+            // HandleLogic Extra Step Generation
+            if (handleLogic && handleLogic !== 'none') {
+                let logicTemplate = null;
+                let logicSuffix = '';
+                if (handleLogic === 'awaitingMultipleSteps') {
+                    logicTemplate = templates.byConfigAwaitingMain;
+                    logicSuffix = 'AwaitingMultipleSteps';
+                } else if (handleLogic === 'paginated') {
+                    logicTemplate = templates.byConfigPaginatedMain;
+                    logicSuffix = 'Paginated';
+                }
+
+                if (logicTemplate) {
+                    const logicRenderData = { ...renderData, handleLogic, childFlow, mainObjType: '' };
+                    const logicMainContent = ejs.render(logicTemplate, logicRenderData);
+                    const logicMainFileName = `${upperCaseFlowTag}${upperFirst(stepName)}${logicSuffix}_Main`;
+                    await fs.writeFile(path.join(flowOutputDir, `${logicMainFileName}.js`), logicMainContent, 'utf-8');
+                    generatedCount++;
+                }
+            }
+
+            // 1.5 Generate RecievePlugIn Hooks (if any)
+            if (hasPlugInHooks && allSchemas.objects) {
+                // To avoid duplicate generation, we only generate these if they don't exist yet for the flow
+                const generatedRecieves = new Set();
+                for (const obj of allSchemas.objects) {
+                    if (obj.recievePlugInHookTag) {
+                        for (const recieveConfig of Object.values(obj.recievePlugInHookTag)) {
+                            const recieveType = recieveConfig.flowType ? 'async' : 'sync';
+                            const rFuncName = `recievePlugInHook${upperFirst(recieveType)}`;
+                            if (generatedRecieves.has(rFuncName)) continue;
+                            generatedRecieves.add(rFuncName);
+                            
+                            const rMainContent = ejs.render(templates.recievePluginMain, {
+                                functionName: rFuncName,
+                                recieveType: recieveType,
+                                flowTag: flowTag,
+                                serviceTag: options.serviceTag || 'ServiceTag'
+                            });
+                            await fs.writeFile(path.join(flowOutputDir, `${rFuncName}_Main.js`), rMainContent, 'utf-8');
+                            generatedCount++;
+
+                            // Generate corresponding handler
+                            const rHdrSuffix = recieveType === 'async' ? 'HdrWbs' : 'HdrApi'; // wbs for async, api for sync
+                            const rHdrTemplate = recieveType === 'async' ? templates.sqs : templates.api; // Fallback to SQS/API structure
+                            const rHdrContent = ejs.render(rHdrTemplate, {
+                                flowTag: flowTag,
+                                flowStepName: stepName,
+                                mainFileName: `${rFuncName}_Main`,
+                                functionName: rFuncName,
+                                queueName: `${upperCaseFlowTag}${upperFirst(stepName)}Hdr${upperFirst(recieveType === 'async' ? 'Sqs' : 'Api')}`
+                            });
+                            await fs.writeFile(path.join(flowOutputDir, `${rFuncName}_${rHdrSuffix}.js`), rHdrContent, 'utf-8');
+                            generatedCount++;
+                        }
+                    }
+                }
+            }
+
+            // 2. Generate Handlers based on stepConfig.event
+            const events = normalizeEvents(stepConfig.event, ['sqs']); // Default to sqs if missing
+            for (const ev of events) {
+                if (ev === 'sns') continue;
+                const handlerConfig = getStepEventHandlerConfig(ev);
+                const suffix = handlerConfig.suffix;
+                const targetTemplateStr = templates[handlerConfig.template] || templates.sqs;
+
+                const handlerFileName = `${upperCaseFlowTag}${stepName}_${suffix}`;
+                const handlerContent = ejs.render(targetTemplateStr, {
+                    flowTag: flowTag,
+                    flowStepName: stepName,
+                    mainFileName: mainFileName,
+                    functionName: `${flowTag}${stepName}`,
+                    queueName: `${flowTag}${stepName}${suffix}`
+                });
+                await fs.writeFile(path.join(flowOutputDir, `${handlerFileName}.js`), handlerContent, 'utf-8');
+                generatedCount++;
+
+                // If handleLogic exists, also generate the extra handler for it
+                if (handleLogic && handleLogic !== 'none') {
+                    let logicSuffix = '';
+                    let logicTargetTemplateStr = templates.sqs;
+                    if (handleLogic === 'awaitingMultipleSteps') {
+                        logicSuffix = 'AwaitingMultipleStepsHdrSqs';
+                    } else if (handleLogic === 'paginated') {
+                        logicSuffix = 'PaginatedHdrDsq';
+                    }
+
+                    if (logicSuffix) {
+                        const logicHandlerFileName = `${upperCaseFlowTag}${upperFirst(stepName)}${logicSuffix}`;
+                        const logicMainFileName = `${upperCaseFlowTag}${upperFirst(stepName)}${logicSuffix.replace(/Hdr.*$/, '')}_Main`;
+                        const logicHandlerContent = ejs.render(logicTargetTemplateStr, {
+                            flowTag: flowTag,
+                            flowStepName: stepName,
+                            mainFileName: logicMainFileName,
+                            functionName: `${stepName.toLowerCase()}Main`,
+                            queueName: `${upperCaseFlowTag}${upperFirst(stepName)}${upperFirst(handleLogic)}`
+                        });
+                        await fs.writeFile(path.join(flowOutputDir, `${logicHandlerFileName}.js`), logicHandlerContent, 'utf-8');
+                        generatedCount++;
+                    }
+                }
+            }
+        }
+    }
+
+    console.log(`  [FlowGenerator] Generated ${generatedCount} files for Custom FlowSteps.`);
+}

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

@@ -0,0 +1,28 @@
+export function normalizeFlowSteps(flowSteps) {
+    if (!flowSteps) return [];
+
+    if (Array.isArray(flowSteps)) {
+        return flowSteps
+            .filter(Boolean)
+            .map(step => ({ ...step, stepName: step.stepName || inferStepName(step) }))
+            .filter(step => step.stepName);
+    }
+
+    return Object.entries(flowSteps).map(([stepName, stepConfig]) => ({
+        ...(stepConfig || {}),
+        stepName
+    }));
+}
+
+export function hasFlowStep(flowSteps, stepName) {
+    return normalizeFlowSteps(flowSteps).some(step => step.stepName === stepName);
+}
+
+function inferStepName(step) {
+    const reservedKeys = new Set([
+        'event', 'settings', 'plugInHooks', 'properties', 'messageAttributes',
+        'returnValues', 'inTag', 'stepName'
+    ]);
+    const key = Object.keys(step).find(item => !reservedKeys.has(item));
+    return typeof step[key] === 'string' ? step[key] : key;
+}