@izara_project/izara-core-generate-service-code 1.0.64 → 1.0.66

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

@@ -1,235 +0,0 @@
-import path from 'path';
-import fs from 'fs/promises';
-import { fileURLToPath } from 'url';
-import ejs from 'ejs';
-import { getFlowOutputSubDir, isRbacFlow, isRelationshipFlow, isCrudFlow } 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, '..', '..', 'FlowObjects', 'templates', 'step', 'FlowEndpointComplete_Main.ejs'), 'utf-8'),
-        sqs: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrSqs.ejs'), 'utf-8'),
-        dsq: await fs.readFile(path.join(__dirname, '..', 'handlers', 'FlowHandler_HdrDsq.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;
-
-        const normalizedSteps = normalizeFlowSteps(flow.flowSteps);
-        for (let index = 0; index < normalizedSteps.length; index++) {
-            const stepConfig = normalizedSteps[index];
-            const stepName = stepConfig.stepName;
-            
-            // Skip the first step (which is the entry point, handled by flowMainFunctionBase)
-            // Also skip traditional skipped steps by name for backward compatibility
-            if (index === 0 || ['in', 'start', 'out', 'beforelogical'].includes(stepName?.toLowerCase())) 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' && isCrudFlow(flowTag);
-            // 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, ['extTopic']); // Default to extTopic 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

@@ -1,75 +0,0 @@
-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', 'startStep', 'stepName'
-    ]);
-    const key = Object.keys(step).find(item => !reservedKeys.has(item));
-    return typeof step[key] === 'string' ? step[key] : key;
-}
-
-export function normalizeUnifiedFlows(rawFlows) {
-    return rawFlows.map(flow => {
-        if (!flow.flowSteps) return flow;
-        
-        // Handle both array and object empty cases
-        if (Array.isArray(flow.flowSteps) && flow.flowSteps.length === 0) return flow;
-        if (!Array.isArray(flow.flowSteps) && Object.keys(flow.flowSteps).length === 0) return flow;
-
-        const normalizedSteps = normalizeFlowSteps(flow.flowSteps);
-        
-        // Ensure flowSteps is always an Array for the rest of the generation process
-        flow.flowSteps = normalizedSteps;
-        
-        // ponytail: root-level event is standard, flowStep[0] has no event.
-        if (flow.event) {
-            const firstStep = flow.flowSteps[0];
-            const needsStartStep = !firstStep || firstStep.event;
-            
-            if (needsStartStep) {
-                flow.flowSteps.unshift({
-                    stepName: 'Start',
-                    properties: flow.properties || [],
-                    messageAttributes: flow.messageAttributes || []
-                });
-            }
-        }
-        // Validate flowStep events
-        flow.flowSteps.forEach((step, index) => {
-            if (index === 0) {
-                if (step.event) {
-                    throw new Error(`[Schema Error] Flow '${flow.flowTag || 'Unknown'}' -> stepName '${step.stepName}' (Index 0) must not have an 'event'. Set it at the flow root instead.`);
-                }
-            } else {
-                if (step.event) {
-                    const validStepEvents = ['extTopic', 'lambdaSyncInv', 'dsq'];
-                    const invalidEvents = step.event.filter(e => !validStepEvents.includes(e));
-                    if (invalidEvents.length > 0) {
-                        throw new Error(`[Schema Error] Flow '${flow.flowTag || 'Unknown'}' -> stepName '${step.stepName}' has invalid event: ${invalidEvents.join(', ')}. Allowed: ${validStepEvents.join(', ')}`);
-                    }
-                }
-            }
-        });
-
-        return flow;
-    });
-}

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

@@ -1,236 +0,0 @@
-import { TYPE_MAP } from './propertyNormalizer.js';
-
-const ALLOWED_EVENTS = ['ownTopic', 'extTopic', 'lambdaSyncInv', 'lambdaSyncApi', 'eventBridge', 's3', 'dsq'];
-const MAIN_ASYNC_EVENTS = ['ownTopic', 'extTopic', 's3'];
-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.`);
-    }
-  }
-}
-
-function validateStepPropertyTypes(flowTag, propDefs, label, errors) {
-  if (!propDefs || typeof propDefs !== 'object') return;
-  const ALLOWED_TYPES = Object.keys(TYPE_MAP);
-  for (const [key, def] of Object.entries(propDefs)) {
-    if (!def || typeof def !== 'object') continue;
-    if (!def.type) {
-      errors.push(`Flow '${flowTag}' ${label} '${key}' is missing required field 'type'.`);
-      continue;
-    }
-    if (!ALLOWED_TYPES.includes(def.type)) {
-      errors.push(
-        `Flow '${flowTag}' ${label} '${key}' has unsupported type '${def.type}'. Allowed types are: ${ALLOWED_TYPES.join(', ')}.`
-      );
-      continue;
-    }
-    // enum: must supply enumValues array
-    if (def.type === 'enum') {
-      if (!Array.isArray(def.enumValues) || def.enumValues.length === 0) {
-        errors.push(
-          `Flow '${flowTag}' ${label} '${key}' has type 'enum' but is missing a non-empty 'enumValues' array.`
-        );
-      }
-    }
-    // default: must match resolved primitive type
-    // 'mixed' type accepts any value, so skip the type check
-    if (def.default !== undefined && def.type !== 'mixed') {
-      const resolvedPrimitive = TYPE_MAP[def.type];
-      const actualType = Array.isArray(def.default) ? 'array' : typeof def.default;
-      const expectedType = resolvedPrimitive === 'array' ? 'array' : resolvedPrimitive;
-      if (expectedType && actualType !== expectedType) {
-        errors.push(
-          `Flow '${flowTag}' ${label} '${key}' has a 'default' value of type '${actualType}' but expected '${expectedType}' (from schema type '${def.type}').`
-        );
-      }
-    }
-  }
-}
-
-/**
- * Warn about stepProperties / stepMessageAttributes keys that are declared
- * but never referenced in any step's properties or messageAttributes arrays.
- */
-function validateUnusedStepProperties(flowTag, flow, errors) {
-  const stepProps = flow.stepProperties;
-  const stepMsgAttrs = flow.stepMessageAttributes;
-  if (!stepProps && !stepMsgAttrs) return;
-
-  const usedProps = new Set();
-  const usedAttrs = new Set();
-
-  for (const step of Array.isArray(flow.flowSteps) ? flow.flowSteps : []) {
-    for (const ref of Array.isArray(step.properties) ? step.properties : []) {
-      if (typeof ref === 'string') usedProps.add(ref);
-    }
-    for (const ref of Array.isArray(step.messageAttributes) ? step.messageAttributes : []) {
-      if (typeof ref === 'string') usedAttrs.add(ref);
-    }
-  }
-
-  if (stepProps && typeof stepProps === 'object') {
-    for (const key of Object.keys(stepProps)) {
-      if (!usedProps.has(key)) {
-        errors.push(
-          `Flow '${flowTag}' stepProperties key '${key}' is declared but never referenced in any step's 'properties'.`
-        );
-      }
-    }
-  }
-
-  if (stepMsgAttrs && typeof stepMsgAttrs === 'object') {
-    for (const key of Object.keys(stepMsgAttrs)) {
-      if (!usedAttrs.has(key)) {
-        errors.push(
-          `Flow '${flowTag}' stepMessageAttributes key '${key}' is declared but never referenced in any step's 'messageAttributes'.`
-        );
-      }
-    }
-  }
-}
-
-/**
- * Detect keys that appear in both stepProperties and stepMessageAttributes
- * to prevent ambiguous naming.
- */
-function validateDuplicateStepPropertyKeys(flowTag, flow, errors) {
-  const stepProps = flow.stepProperties;
-  const stepMsgAttrs = flow.stepMessageAttributes;
-  if (!stepProps || !stepMsgAttrs) return;
-
-  const propKeys = new Set(Object.keys(stepProps));
-  for (const key of Object.keys(stepMsgAttrs)) {
-    if (propKeys.has(key)) {
-      errors.push(
-        `Flow '${flowTag}' key '${key}' is declared in both 'stepProperties' and 'stepMessageAttributes'. Keys must be unique across both groups.`
-      );
-    }
-  }
-}
-
-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_EVENTS.includes(event));
-    if (invalidMainEvents.length > 0) {
-      errors.push(`Flow '${flowTag}' uses unsupported main events: ${invalidMainEvents.join(', ')}. Allowed are: ${ALLOWED_EVENTS.join(', ')}.`);
-    }
-
-    const mainAsyncEvents = events.filter(event => MAIN_ASYNC_EVENTS.includes(event));
-    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;
-
-    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 (step.plugInHooks && step.plugInHooks.length > 0) {
-        anyStepHasPlugInHooks = true;
-      }
-
-      const stepEvents = asArray(step.event);
-      const invalidStepEvents = stepEvents.filter(event => !ALLOWED_EVENTS.includes(event));
-      if (invalidStepEvents.length > 0) {
-        errors.push(`Flow '${flowTag}' step '${stepName}' uses unsupported step events: ${invalidStepEvents.join(', ')}. Allowed are: ${ALLOWED_EVENTS.join(', ')}.`);
-      }
-
-      validateNamedRefs(flowTag, stepName, step.properties, flow.stepProperties, 'properties', errors);
-      validateNamedRefs(flowTag, stepName, step.messageAttributes, flow.stepMessageAttributes, 'messageAttributes', errors);
-    }
-
-    validateStepPropertyTypes(flowTag, flow.stepProperties, 'stepProperties', errors);
-    validateStepPropertyTypes(flowTag, flow.stepMessageAttributes, 'stepMessageAttributes', errors);
-    validateDuplicateStepPropertyKeys(flowTag, flow, errors);
-    validateUnusedStepProperties(flowTag, flow, errors);
-
-    // ponytail: relaxed anyStepHasPlugInHooks requirement 
-    // since unified entry points (step 0) can now handle plugins directly without start.
-
-    if (anyStepHasPlugInHooks) {
-      const forbiddenEvents = ['lambdaSyncInv', 'lambdaSyncApi', 's3', 'eventBridge'];
-      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/_shared/shared/propertyNormalizer.js

@@ -1,15 +0,0 @@
-import { consts } from '@izara_project/izara-shared-service-schemas';
-
-export const TYPE_MAP = consts.FIELDNAME_TYPE_MAPPING;
-
-export function normalizePropertyType(p, lookupSource) {
-    let prop = typeof p === 'string'
-        ? ((lookupSource && lookupSource[p]) ? lookupSource[p] : { propertyName: p, type: 'string' })
-        : p;
-
-    if (prop && prop.type) {
-        prop = { ...prop, type: TYPE_MAP[prop.type] || prop.type };
-    }
-
-    return prop;
-}

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

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

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

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