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

package/src/codeGenerators/app/src/generatedCode/Flow/_internal/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, '..', '_shared', '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, '..', '_shared', '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, '..', '_shared', 'endpoint', '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/_internal/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/_internal/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/_internal/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, '..', '_shared', 'step', 'FlowStep_Main.ejs'), 'utf-8'),
+        complete: await fs.readFile(path.join(__dirname, '..', '_shared', 'step', 'FlowEndpointComplete_Main.ejs'), 'utf-8'),
+        sqs: await fs.readFile(path.join(__dirname, '..', '_shared', 'handlers', 'FlowHandler_HdrSqs.ejs'), 'utf-8'),
+        api: await fs.readFile(path.join(__dirname, '..', '_shared', 'handlers', 'FlowHandler_HdrApi.ejs'), 'utf-8'),
+        inv: await fs.readFile(path.join(__dirname, '..', '_shared', 'handlers', 'FlowHandler_HdrInv.ejs'), 'utf-8'),
+
+        // Advanced Custom Flow Logic Templates
+        pluginMain: await fs.readFile(path.join(__dirname, '..', '_shared', 'step', 'plugIns', 'FlowStep_PlugIn_Main.ejs'), 'utf-8').catch(() => ''),
+        recievePluginMain: await fs.readFile(path.join(__dirname, '..', '_shared', 'step', 'plugIns', 'FlowStep_RecievePlugIn_Main.ejs'), 'utf-8').catch(() => ''),
+        byConfigAwaitingMain: await fs.readFile(path.join(__dirname, '..', '_shared', 'step', 'plugIns', 'FlowStep_ByConfig_Awaiting_Main.ejs'), 'utf-8').catch(() => ''),
+        byConfigPaginatedMain: await fs.readFile(path.join(__dirname, '..', '_shared', 'step', 'plugIns', 'FlowStep_ByConfig_Paginated_Main.ejs'), 'utf-8').catch(() => ''),
+        templateAwaitingStep: path.join(__dirname, '..', '_shared', 'step', 'plugIns', 'templateAwaitingStep.ejs'),
+        templateSendPlugin: path.join(__dirname, '..', '_shared', '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/_internal/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;
+}

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

@@ -0,0 +1,144 @@
+const ALLOWED_MAIN_EVENTS = ['ownTopic', 'extTopic', 'lambdaSyncInv', 'lambdaSyncApi', 'eventBridge', 's3'];
+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',
+  'Delete',
+  'Get',
+  'CreateTargetRole',
+  'ListTargetRole',
+  'DeleteTargetRole',
+  'CreateRolePermissions',
+  'ListRolePermissions',
+  'DeleteRolePermissions',
+  'CreateUserRole',
+  'ListUserInRoles',
+  'DeleteUserFromRole',
+  'CreateRelationship',
+  'UpdateRelationship',
+  'DeleteRelationship',
+  'GetRelationship',
+  'ChangeRelationship',
+  'MoveRelationship'
+]);
+
+function asArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function validateNamedRefs(flowTag, stepName, refs, defs, label, errors) {
+  if (refs === undefined) return;
+  if (!Array.isArray(refs)) {
+    errors.push(`Flow '${flowTag}' step '${stepName}' ${label} must be an array.`);
+    return;
+  }
+
+  for (const ref of refs) {
+    if (typeof ref === 'string') {
+      if (!defs || !defs[ref]) {
+        errors.push(`Flow '${flowTag}' step '${stepName}' references missing ${label} key '${ref}'.`);
+      }
+      continue;
+    }
+
+    if (!ref || typeof ref !== 'object') {
+      errors.push(`Flow '${flowTag}' step '${stepName}' ${label} entries must be string keys or schema objects.`);
+    }
+  }
+}
+
+export function validateFlowsForGeneration(flows) {
+  const errors = [];
+  const seenCustomFlowTags = new Set();
+
+  for (const flow of flows) {
+    const flowTag = flow?.flowTag;
+    if (!flowTag) {
+      errors.push('Flow is missing flowTag.');
+      continue;
+    }
+
+    const isSystemFlow = flow.initiateBy === 'system';
+    if (!isSystemFlow) {
+      if (seenCustomFlowTags.has(flowTag)) {
+        errors.push(`Flow '${flowTag}' is defined more than once.`);
+      }
+      seenCustomFlowTags.add(flowTag);
+
+      if (RESERVED_SYSTEM_FLOW_TAGS.has(flowTag)) {
+        errors.push(`Flow '${flowTag}' is reserved by a system flow. Please use a different flowTag.`);
+      }
+    }
+
+    const events = asArray(flow.event);
+    const invalidMainEvents = events.filter(event => !ALLOWED_MAIN_EVENTS.includes(event));
+    if (invalidMainEvents.length > 0) {
+      errors.push(`Flow '${flowTag}' uses unsupported main events: ${invalidMainEvents.join(', ')}. Allowed are: ${ALLOWED_MAIN_EVENTS.join(', ')}.`);
+    }
+
+    const mainAsyncEvents = events.filter(event => MAIN_ASYNC_EVENTS.includes(event));
+    if (mainAsyncEvents.length > 1) {
+      errors.push(`Flow '${flowTag}' multiple main async triggers: ${mainAsyncEvents.join(', ')}. Only one is allowed.`);
+    }
+
+    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;
+      if (!stepName) {
+        errors.push(`Flow '${flowTag}' has a step without stepName.`);
+        continue;
+      }
+
+      if (seenStepNames.has(stepName)) {
+        errors.push(`Flow '${flowTag}' has duplicate stepName '${stepName}'.`);
+      }
+      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));
+      if (invalidStepEvents.length > 0) {
+        errors.push(`Flow '${flowTag}' step '${stepName}' uses unsupported step events: ${invalidStepEvents.join(', ')}. Allowed are: ${ALLOWED_STEP_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.`);
+    }
+
+    if (anyStepHasPlugInHooks) {
+      const forbiddenEvents = ['lambdaSyncInv', 'lambdaSyncApi', 's3', 'eventBridge'];
+      const usedForbiddenEvents = events.filter(event => forbiddenEvents.includes(event));
+      if (usedForbiddenEvents.length > 0) {
+        errors.push(`Flow '${flowTag}' uses plugInHooks with unsupported main events: ${usedForbiddenEvents.join(', ')}. plugInHooks are allowed only for async/event-driven flows.`);
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    throw new Error('Flow Validation Failed:\n' + errors.map(error => `- ${error}`).join('\n'));
+  }
+}

package/src/codeGenerators/app/src/generatedCode/Flow/_internal/shared/registry.js

@@ -0,0 +1,7 @@
+import { generateStatusField } from '../../FlowSchemas/StatusFieldGenerator.js';
+import { generateTriggerCache } from './triggerCacheBase.js';
+
+export const STATUS_HANDLERS = {
+    statusField: generateStatusField,
+    triggerCache: generateTriggerCache
+};