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

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

@@ -0,0 +1,52 @@
+import ejs from 'ejs';
+import fs from 'fs/promises';
+import path from 'path';
+
+export default async function generate(flow, stepName, flowOutputDir, mainFileName, templates) {
+    const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+    const flowTag = flow.flowTag;
+
+    const suffix = 'HdrApi';
+    const handlerFileName = stepName ? `${flowTag}${stepName}_${suffix}` : `Process${upperCase(flowTag)}_${suffix}`;
+    // Queue name: ${flowTag}${flowStepName}${HandlerType}
+    const queueName = stepName ? `${flowTag}${stepName}${suffix}` : `${flowTag}${suffix}`;
+    // Function name matches default export of the referenced _Main.js
+    const functionName = stepName ? `${flowTag}${stepName}` : `Process${upperCase(flowTag)}`;
+
+    let inTagConfig = null;
+    if (!stepName && flow.flowSteps) {
+        const inTagStep = flow.flowSteps.find(s => s.stepName === 'InTag');
+        if (inTagStep) {
+            inTagConfig = { ...inTagStep };
+            // Map properties
+            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;
+                });
+            }
+            // Map messageAttributes
+            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 handlerContent = ejs.render(templates.api, {
+        flowTag: flowTag,
+        flowStepName: stepName || '',
+        mainFileName: mainFileName,
+        functionName: functionName,
+        queueName: queueName,
+        inTagConfig: inTagConfig
+    });
+
+    await fs.writeFile(path.join(flowOutputDir, `${handlerFileName}.js`), handlerContent, 'utf-8');
+}

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

@@ -0,0 +1,52 @@
+import ejs from 'ejs';
+import fs from 'fs/promises';
+import path from 'path';
+
+export default async function generate(flow, stepName, flowOutputDir, mainFileName, templates) {
+    const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+    const flowTag = flow.flowTag;
+
+    const suffix = 'HdrInv';
+    const handlerFileName = stepName ? `${flowTag}${stepName}_${suffix}` : `Process${upperCase(flowTag)}_${suffix}`;
+    // Queue name: ${flowTag}${flowStepName}${HandlerType}
+    const queueName = stepName ? `${flowTag}${stepName}${suffix}` : `${flowTag}${suffix}`;
+    // Function name matches default export of the referenced _Main.js
+    const functionName = stepName ? `${flowTag}${stepName}` : `Process${upperCase(flowTag)}`;
+
+    let inTagConfig = null;
+    if (!stepName && flow.flowSteps) {
+        const inTagStep = flow.flowSteps.find(s => s.stepName === 'InTag');
+        if (inTagStep) {
+            inTagConfig = { ...inTagStep };
+            // Map properties
+            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;
+                });
+            }
+            // Map messageAttributes
+            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 handlerContent = ejs.render(templates.inv, {
+        flowTag: flowTag,
+        flowStepName: stepName || '',
+        mainFileName: mainFileName,
+        functionName: functionName,
+        queueName: queueName,
+        inTagConfig: inTagConfig
+    });
+
+    await fs.writeFile(path.join(flowOutputDir, `${handlerFileName}.js`), handlerContent, 'utf-8');
+}

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

@@ -0,0 +1,42 @@
+import { generateSqsHandler } from './BaseSqsHandler.js';
+import ejs from 'ejs';
+import fs from 'fs/promises';
+import path from 'path';
+
+export default async function generate(flow, stepName, flowOutputDir, mainFileName, templates, generateCode = []) {
+    const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+    // --- PROCESS ONLY (1-Step Architecture) ---
+    // The Process Main Logic File is already generated by FlowMainFunctionGenerator (Process{FlowTag}_Main.js)
+
+    // Generate Process Handler File (HdrSqs)
+    await generateSqsHandler(flow, stepName, 'HdrSqs', flowOutputDir, mainFileName, templates);
+
+    // ownTopic flows ALWAYS generate the WebSocket entry + SNS-publish main file,
+    // regardless of initiateBy (legacy behavior: WebSocket is the universal entry point).
+    if (!stepName) {
+        const handlerFileName = `${upperCase(flow.flowTag)}_HdrWbs`;
+        const functionName = `${flow.flowTag}Main`;
+        const entryPointFileName = `${upperCase(flow.flowTag)}_Main`;
+
+        // 1. Render HdrWbs.js
+        const handlerContent = ejs.render(templates.endpointHdrWbs, {
+            flowTag: flow.flowTag,
+            upperCaseFlowTag: upperCase(flow.flowTag),
+            flowStepName: '',
+            mainFileName: entryPointFileName,
+            functionName: functionName,
+            route: flow.flowTag
+        });
+        await fs.writeFile(path.join(flowOutputDir, `${handlerFileName}.js`), handlerContent, 'utf-8');
+
+        // 2. Render _Main.js (SNS publish version for ownTopic flows)
+        const mainContent = ejs.render(templates.wbsMain, {
+            flowTag: flow.flowTag,
+            upperCaseFlowTag: upperCase(flow.flowTag),
+            topicArn: `${upperCase(flow.flowTag)}_In`,
+            generateCode: generateCode
+        });
+        await fs.writeFile(path.join(flowOutputDir, `${entryPointFileName}.js`), mainContent, 'utf-8');
+    }
+}

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

@@ -0,0 +1,15 @@
+import ownTopic from './ownTopic.js';
+import extTopic from './extTopic.js';
+import lambdaSyncInv from './lambdaSyncInv.js';
+import lambdaSyncApi from './lambdaSyncApi.js';
+import eventBridge from './eventBridge.js';
+import s3 from './s3.js';
+
+export const EVENT_HANDLERS = {
+    ownTopic,
+    extTopic,
+    lambdaSyncInv,
+    lambdaSyncApi,
+    eventBridge,
+    s3
+};

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

@@ -0,0 +1,56 @@
+/*
+Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import ejs from 'ejs';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+import generateCreateObject from './s3Components/CreateObjectGenerator.js';
+import generateReservedLimit from './s3Components/ReservedLimitGenerator.js';
+import generateCreatePreSignUrl from './s3Components/CreatePreSignUrlGenerator.js';
+import generateProcessAfterUploadS3 from './s3Components/ProcessAfterUploadS3Generator.js';
+import generateConfirmAfterUploadS3 from './s3Components/ConfirmAfterUploadS3Generator.js';
+
+export default async function generate(
+    flow,
+    stepName,
+    flowOutputDir,
+    mainFileName,
+    templates,
+    generateCode = []
+) {
+    if (stepName) return;
+
+    const flowTag = flow.flowTag;
+    if (!flowTag) {
+        console.warn('  [s3.js] flow is missing flowTag — skipping');
+        return;
+    }
+
+    // Call the ported legacy subgenerators to reconstruct the fully separated S3 event flow
+    await generateCreateObject(flow, flowOutputDir);
+    await generateReservedLimit(flow, flowOutputDir);
+    await generateCreatePreSignUrl(flow, flowOutputDir);
+    await generateProcessAfterUploadS3(flow, flowOutputDir);
+    await generateConfirmAfterUploadS3(flow, flowOutputDir);
+}

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/events/s3Components/ConfirmAfterUploadS3Generator.js

@@ -0,0 +1,46 @@
+import ejs from 'ejs';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default async function generateConfirmAfterUploadS3(flow, flowOutputDir) {
+    const functionName = `${flow.flowTag}ConfirmAfterUpload`;
+    const handlerType = `HdrSqs`;
+    
+    const mainFileName = `${functionName}_Main`;
+    const handlerFileName = `${functionName}_${handlerType}`;
+
+    const mainTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'ConfirmReserved_Main.ejs'
+    );
+    const handlerTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'ConfirmReserved_HdrSqs.ejs'
+    );
+
+    let mainTemplateStr, handlerTemplateStr;
+    try {
+        mainTemplateStr = await fs.readFile(mainTemplatePath, 'utf-8');
+        handlerTemplateStr = await fs.readFile(handlerTemplatePath, 'utf-8');
+    } catch (err) {
+        throw new Error(`[ConfirmAfterUploadS3Generator] Failed to load template: ${err.message}`);
+    }
+
+    const mainContent = ejs.render(mainTemplateStr, {
+        functionName: functionName
+    });
+
+    const handlerContent = ejs.render(handlerTemplateStr, {
+        functionName,
+        handlerType
+    });
+
+    const targetMainPath = path.join(flowOutputDir, `${mainFileName}.js`);
+    await fs.writeFile(targetMainPath, mainContent, 'utf-8');
+
+    const targetHandlerPath = path.join(flowOutputDir, `${handlerFileName}.js`);
+    await fs.writeFile(targetHandlerPath, handlerContent, 'utf-8');
+}

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/events/s3Components/CreateObjectGenerator.js

@@ -0,0 +1,50 @@
+import ejs from 'ejs';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default async function generateCreateObject(flow, flowOutputDir) {
+    const upperCaseFlowTag = upperCase(flow.flowTag);
+    const functionName = `${flow.flowTag}CreateObject`;
+    const handlerType = `HdrWbs`;
+    
+    const mainFileName = `${functionName}_Main`;
+    const handlerFileName = `${functionName}_${handlerType}`;
+
+    const mainTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'CreateObject_Main.ejs'
+    );
+    const handlerTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'CreateObject_HdrWbs.ejs'
+    );
+
+    let mainTemplateStr, handlerTemplateStr;
+    try {
+        mainTemplateStr = await fs.readFile(mainTemplatePath, 'utf-8');
+        handlerTemplateStr = await fs.readFile(handlerTemplatePath, 'utf-8');
+    } catch (err) {
+        throw new Error(`[CreateObjectGenerator] Failed to load template: ${err.message}`);
+    }
+
+    const mainContent = ejs.render(mainTemplateStr, {
+        flowTag: flow.flowTag,
+        objectType: flow.objType.objectType,
+        functionName: functionName
+    });
+
+    const handlerContent = ejs.render(handlerTemplateStr, {
+        functionName,
+        handlerType,
+        route: flow.flowTag
+    });
+
+    const targetMainPath = path.join(flowOutputDir, `${mainFileName}.js`);
+    await fs.writeFile(targetMainPath, mainContent, 'utf-8');
+
+    const targetHandlerPath = path.join(flowOutputDir, `${handlerFileName}.js`);
+    await fs.writeFile(targetHandlerPath, handlerContent, 'utf-8');
+}

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/events/s3Components/CreatePreSignUrlGenerator.js

@@ -0,0 +1,48 @@
+import ejs from 'ejs';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default async function generateCreatePreSignUrl(flow, flowOutputDir) {
+    const functionName = `${flow.flowTag}CreatePreSignUrl`;
+    const handlerType = `HdrSqs`;
+    
+    const mainFileName = `${functionName}_Main`;
+    const handlerFileName = `${functionName}_${handlerType}`;
+
+    const mainTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'CreatePreSignUrl_Main.ejs'
+    );
+    const handlerTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'CreatePreSignUrl_HdrSqs.ejs'
+    );
+
+    let mainTemplateStr, handlerTemplateStr;
+    try {
+        mainTemplateStr = await fs.readFile(mainTemplatePath, 'utf-8');
+        handlerTemplateStr = await fs.readFile(handlerTemplatePath, 'utf-8');
+    } catch (err) {
+        throw new Error(`[CreatePreSignUrlGenerator] Failed to load template: ${err.message}`);
+    }
+
+    const mainContent = ejs.render(mainTemplateStr, {
+        bucketName: flow.bucketName,
+        flowTag: flow.flowTag,
+        functionName: functionName
+    });
+
+    const handlerContent = ejs.render(handlerTemplateStr, {
+        functionName,
+        handlerType
+    });
+
+    const targetMainPath = path.join(flowOutputDir, `${mainFileName}.js`);
+    await fs.writeFile(targetMainPath, mainContent, 'utf-8');
+
+    const targetHandlerPath = path.join(flowOutputDir, `${handlerFileName}.js`);
+    await fs.writeFile(targetHandlerPath, handlerContent, 'utf-8');
+}

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/events/s3Components/ProcessAfterUploadS3Generator.js

@@ -0,0 +1,49 @@
+import ejs from 'ejs';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default async function generateProcessAfterUploadS3(flow, flowOutputDir) {
+    const functionName = `${flow.flowTag}ProcessAfterUpload`;
+    const handlerType = `HdrS3`;
+    
+    const mainFileName = `${functionName}_Main`;
+    const handlerFileName = `${functionName}_${handlerType}`;
+
+    const mainTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'ProcessS3File_Main.ejs'
+    );
+    const handlerTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'FlowHandler_HdrS3.ejs'
+    );
+
+    let mainTemplateStr, handlerTemplateStr;
+    try {
+        mainTemplateStr = await fs.readFile(mainTemplatePath, 'utf-8');
+        handlerTemplateStr = await fs.readFile(handlerTemplatePath, 'utf-8');
+    } catch (err) {
+        throw new Error(`[ProcessAfterUploadS3Generator] Failed to load template: ${err.message}`);
+    }
+
+    const mainContent = ejs.render(mainTemplateStr, {
+        flowTag: flow.flowTag,
+        functionName: functionName
+    });
+
+    const handlerContent = ejs.render(handlerTemplateStr, {
+        flowTag: flow.flowTag,
+        functionName: functionName,
+        mainFileName,
+        s3Bucket: flow.bucketName || ''
+    });
+
+    const targetMainPath = path.join(flowOutputDir, `${mainFileName}.js`);
+    await fs.writeFile(targetMainPath, mainContent, 'utf-8');
+
+    const targetHandlerPath = path.join(flowOutputDir, `${handlerFileName}.js`);
+    await fs.writeFile(targetHandlerPath, handlerContent, 'utf-8');
+}

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/events/s3Components/ReservedLimitGenerator.js

@@ -0,0 +1,47 @@
+import ejs from 'ejs';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const upperCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+
+export default async function generateReservedLimit(flow, flowOutputDir) {
+    const functionName = `${flow.flowTag}ReservedLimit`;
+    const handlerType = `HdrSqs`;
+    
+    const mainFileName = `${functionName}_Main`;
+    const handlerFileName = `${functionName}_${handlerType}`;
+
+    const mainTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'ReservedLimit_Main.ejs'
+    );
+    const handlerTemplatePath = path.join(
+        __dirname, '..', '..', '..', 'FlowSchemas', 'templates', 's3', 'ReservedLimit_HdrSqs.ejs'
+    );
+
+    let mainTemplateStr, handlerTemplateStr;
+    try {
+        mainTemplateStr = await fs.readFile(mainTemplatePath, 'utf-8');
+        handlerTemplateStr = await fs.readFile(handlerTemplatePath, 'utf-8');
+    } catch (err) {
+        throw new Error(`[ReservedLimitGenerator] Failed to load template: ${err.message}`);
+    }
+
+    const mainContent = ejs.render(mainTemplateStr, {
+        flowTag: flow.flowTag,
+        functionName: functionName
+    });
+
+    const handlerContent = ejs.render(handlerTemplateStr, {
+        functionName,
+        handlerType
+    });
+
+    const targetMainPath = path.join(flowOutputDir, `${mainFileName}.js`);
+    await fs.writeFile(targetMainPath, mainContent, 'utf-8');
+
+    const targetHandlerPath = path.join(flowOutputDir, `${handlerFileName}.js`);
+    await fs.writeFile(targetHandlerPath, handlerContent, 'utf-8');
+}

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/handlers/FlowHandler_HdrApi.ejs

@@ -0,0 +1,51 @@
+import { middlewareHandler as middleware, response } from "@izara_project/izara-middleware";
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+
+import <%= functionName %> from './<%= mainFileName %>.js';
+
+const validatorSchema = {
+    //(<validatorSchema>)
+<% if (typeof inTagConfig !== 'undefined' && inTagConfig !== null && inTagConfig.properties && inTagConfig.properties.length > 0) { -%>
+    type: 'object',
+    properties: {
+    <% inTagConfig.properties.forEach(prop => { -%>
+        <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' },
+    <% }) -%>
+    },
+    required: [ <%- inTagConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %> ]
+<% } -%>
+    //(</validatorSchema>)
+};
+
+middleware.setValidatorSchema(validatorSchema, { noAuthorizer: true });
+
+/**
+ * GENERATED HANDLER: <%= flowStepName %> (Flow: <%= flowTag %>)
+ * Triggered by: API Gateway
+ */
+export const main = middleware.wrap(async (event, context) => {
+    event._izContext?.logger?.debug(`[${context.awsRequestId}] Received API request in <%= flowStepName %>`);
+
+    try {
+        const passOnProperties = [
+            event.body,
+            //(<additionalParams>)
+            //(</additionalParams>)
+            callingFlowSharedLib.addCallingFlowToPassOnProperties(event)
+        ];
+
+        const lambdaFunctionResponse = await <%= functionName %>(
+            event._izContext,
+            ...passOnProperties
+        );
+
+        if (lambdaFunctionResponse instanceof Error) {
+            return response.failure(lambdaFunctionResponse);
+        }
+
+        return response.success(lambdaFunctionResponse);
+    } catch (err) {
+        event._izContext?.logger?.error('Unhandled Error in <%= flowStepName %> API:', err);
+        return response.failure(err);
+    }
+});

package/src/codeGenerators/app/src/generatedCode/Flow/_shared/handlers/FlowHandler_HdrInv.ejs

@@ -0,0 +1,45 @@
+import { middlewareHandler as middleware } from "@izara_project/izara-middleware";
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+
+import <%= functionName %> from './<%= mainFileName %>.js';
+
+const validatorSchema = {
+    //(<validatorSchema>)
+<% if (typeof inTagConfig !== 'undefined' && inTagConfig !== null && inTagConfig.properties && inTagConfig.properties.length > 0) { -%>
+    type: 'object',
+    properties: {
+    <% inTagConfig.properties.forEach(prop => { -%>
+        <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' },
+    <% }) -%>
+    },
+    required: [ <%- inTagConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %> ]
+<% } -%>
+    //(</validatorSchema>)
+};
+
+middleware.setValidatorSchema(validatorSchema);
+
+/**
+ * GENERATED HANDLER: <%= flowStepName %> (Flow: <%= flowTag %>)
+ * Triggered by: Lambda Invocation
+ */
+export const main = middleware.wrap(async (event, context) => {
+    event._izContext?.logger?.debug(`[${context.awsRequestId}] Received Invocation in <%= flowStepName %>`);
+
+    try {
+        const passOnProperties = [
+            event,
+            //(<additionalParams>)
+            //(</additionalParams>)
+            callingFlowSharedLib.addCallingFlowToPassOnProperties(event)
+        ];
+
+        return await <%= functionName %>(
+            event._izContext,
+            ...passOnProperties
+        );
+    } catch (err) {
+        event._izContext?.logger?.error('Unhandled Error in <%= flowStepName %> Invocation:', err);
+        throw err;
+    }
+});

package/src/{generators/fromPlugIn/firstFlowStep/handler/templateSqs.ejs → codeGenerators/app/src/generatedCode/Flow/_shared/handlers/FlowHandler_HdrSqs.ejs}

@@ -15,19 +15,40 @@ You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-
 import { middlewareHandler as middleware } from "@izara_project/izara-middleware";
 import { recordHandlerSharedLib } from "@izara_project/izara-core-library-record-handler";
 import Logger from '@izara_project/izara-core-library-logger';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
-import <%- functionName %> from './<%- functionName %>_Main.js';
+import <%= functionName %> from './<%= mainFileName %>.js';
 
 // validate event properties in body.Message of sqs event
 let perRecordsValidatorSchema = {
   //(<validatorSchema>)
+<% if (typeof inTagConfig !== 'undefined' && inTagConfig !== null && inTagConfig.properties && inTagConfig.properties.length > 0) { -%>
+  type: 'object',
+  properties: {
+  <% inTagConfig.properties.forEach(prop => { -%>
+    <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' },
+  <% }) -%>
+  },
+  required: [ <%- inTagConfig.properties.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %> ]
+<% } -%>
   //(</validatorSchema>)
-}
+};
+
+<% if (typeof inTagConfig !== 'undefined' && inTagConfig !== null && inTagConfig.messageAttributes && inTagConfig.messageAttributes.length > 0) { -%>
+let messageAttributeValidatorSchema = {
+  type: 'object',
+  properties: {
+  <% inTagConfig.messageAttributes.forEach(prop => { -%>
+    <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' },
+  <% }) -%>
+  },
+  required: [ <%- inTagConfig.messageAttributes.filter(p => p.required !== false).map(p => `'${p.propertyName}'`).join(', ') %> ]
+};
+<% } else { -%>
+let messageAttributeValidatorSchema = null;
+<% } -%>
 middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
 
 export const main = middleware.wrap(async (event, context) => {
@@ -45,9 +66,9 @@ export const main = middleware.wrap(async (event, context) => {
       //validate message (and MessageAttributes)
       await recordHandlerSharedLib.validateRecord(
         record, // one record will send to mainFunction
-        "<%- queueName %>", // queue name that need to retry or send to dlq
+        "<%= queueName %>", // queue name that need to retry or send to dlq
         perRecordsValidatorSchema, // schema for record.Message
-        // messageAttributeValidatorSchema   // ----- for msgAttr default is null -> do not send this parameter if not want to validate msgAtt
+        messageAttributeValidatorSchema
       );
 
       // add argument (to invoke lambda) to passOnProperties[]
@@ -60,8 +81,8 @@ export const main = middleware.wrap(async (event, context) => {
       // call recordHandlerSharedLib.recordHandler with 3 parameters and return promise(resolve)
       let recordPromise = recordHandlerSharedLib.recordHandler(
         record, // one record will send to mainFunction
-        <%- functionName %>, // mainFunction that need to invoke.
-        "<%- queueName %>", // queue name that need to retry or send to dlq
+        <%= functionName %>, // mainFunction that need to invoke.
+        "<%= queueName %>", // queue name that need to retry or send to dlq
         passOnProperties, // all parameters that mainFunction needed.
       );
       record._izContext.logger.debug('after recordPromise in handler');
@@ -84,4 +105,4 @@ export const main = middleware.wrap(async (event, context) => {
     Logger.error('Unhandled Error, LambdaFunctionHdrSqs: ', err);
     throw (err);
   }
-});
+});

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

@@ -0,0 +1,23 @@
+export const STEP_EVENT_HANDLER_CONFIG = {
+    sqs: { suffix: 'HdrSqs', template: 'sqs' },
+    ownTopic: { suffix: 'HdrSqs', template: 'sqs' },
+    extTopic: { suffix: 'HdrSqs', template: 'sqs' },
+    dsq: { suffix: 'HdrDsq', template: 'sqs' },
+    lambdaSyncInv: { suffix: 'HdrInv', template: 'inv' },
+    lambdaSyncApi: { suffix: 'HdrApi', template: 'api' }
+};
+
+export function getStepEventHandlerConfig(eventType) {
+    const config = STEP_EVENT_HANDLER_CONFIG[eventType];
+    if (config) return config;
+
+    return {
+        suffix: `Hdr${eventType.charAt(0).toUpperCase() + eventType.slice(1)}`,
+        template: 'sqs'
+    };
+}
+
+export function normalizeEvents(events, fallback = ['sqs']) {
+    if (!events) return [...fallback];
+    return Array.isArray(events) ? [...events] : [events];
+}