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

package/src/codeGenerators/app/src/generatedCode/Flow/FlowRelationshipEndpoints/RelationshipFlowGenerator.js

@@ -0,0 +1,131 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { processFunctionName, processMainFileName, upperFirst } from '../_shared/shared/flowNaming.js';
+
+const RELATIONSHIP_ACTIONS = [
+  'CreateRelationship',
+  'UpdateRelationship',
+  'DeleteRelationship',
+  'GetRelationship',
+  'ChangeRelationship',
+  'MoveRelationship'
+];
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function generateRelationshipFlows(allSchemas, options) {
+    console.log('  [RelationshipFlowGenerator] Generating Custom Relationship Flows...');
+    const baseOutputDir = path.join(options.outputPath, 'app', 'src', 'generatedCode');
+    // Local templates/ folder (4-way shared handlers via symlink + relationship/ specific templates)
+    const templateDir = path.join(__dirname, 'templates');
+
+    // Read standard handler templates for reuse
+    const templates = {
+        sqs: await fs.readFile(path.join(templateDir, '..', '..', '_shared', 'handlers', 'FlowHandler_HdrSqs.ejs'), 'utf-8'),
+        api: await fs.readFile(path.join(templateDir, '..', '..', '_shared', 'handlers', 'FlowHandler_HdrApi.ejs'), 'utf-8'),
+        inv: await fs.readFile(path.join(templateDir, '..', '..', '_shared', 'handlers', 'FlowHandler_HdrInv.ejs'), 'utf-8')
+    };
+
+    let generatedCount = 0;
+
+    if (!allSchemas.relationships || allSchemas.relationships.length === 0) return;
+
+    for (const flowTag of RELATIONSHIP_ACTIONS) {
+        const upperFlowTag = upperFirst(flowTag);
+        const processFunction = processFunctionName(flowTag);
+
+        const flowOutputDir = path.join(baseOutputDir, 'FlowRelationshipEndpoints', upperFlowTag, 'source');
+        await fs.mkdir(flowOutputDir, { recursive: true });
+
+        // 1. Generate Action Step (In) Main Function
+        const actionFileName = processMainFileName(flowTag);
+        const actionTemplatePath = path.join(templateDir, 'relationship', `${actionFileName}.ejs`);
+        
+        try {
+            const actionTemplateStr = await fs.readFile(actionTemplatePath, 'utf-8');
+            const actionContent = ejs.render(actionTemplateStr, {
+                functionName: processFunction, 
+                upperFunctionName: processFunction
+            });
+            await fs.writeFile(path.join(flowOutputDir, `${actionFileName}.js`), actionContent, 'utf-8');
+            generatedCount++;
+        } catch (err) {
+            console.warn(`  [RelationshipFlowGenerator] Warning: Action template not found for ${flowTag}. Skipping.`);
+        }
+
+        // 2. Generate Action Step Handlers (based on fixed event ['ownTopic'])
+        const events = ['ownTopic'];
+        for (const event of events) {
+            let handlerFileName, handlerContent, handlerFunctionName;
+            if (event === 'ownTopic' || event === 'extTopic') {
+                handlerFunctionName = `${processFunction}_HdrSqs`;
+                handlerContent = ejs.render(templates.sqs, {
+                    flowTag: flowTag,
+                    flowStepName: '', 
+                    mainFileName: actionFileName,
+                    functionName: processFunction,
+                    queueName: `${processFunction}HdrSqs`
+                });
+                await fs.writeFile(path.join(flowOutputDir, `${handlerFunctionName}.js`), handlerContent, 'utf-8');
+                generatedCount++;
+            } else if (event === 'lambdaSyncApi') {
+                handlerFunctionName = `${processFunction}_HdrApi`;
+                handlerContent = ejs.render(templates.api, {
+                    flowTag: flowTag,
+                    flowStepName: '',
+                    mainFileName: actionFileName,
+                    functionName: processFunction
+                });
+                await fs.writeFile(path.join(flowOutputDir, `${handlerFunctionName}.js`), handlerContent, 'utf-8');
+                generatedCount++;
+            } else if (event === 'lambdaSyncInv') {
+                handlerFunctionName = `${processFunction}_HdrInv`;
+                handlerContent = ejs.render(templates.inv, {
+                    flowTag: flowTag,
+                    flowStepName: '',
+                    mainFileName: actionFileName,
+                    functionName: processFunction
+                });
+                await fs.writeFile(path.join(flowOutputDir, `${handlerFunctionName}.js`), handlerContent, 'utf-8');
+                generatedCount++;
+            }
+        }
+
+        // 3. Generate Complete Step (Always generated for Relationship flows)
+        if (true) {
+            const completeFunction = `${processFunction}Complete`;
+            const completeFileName = `${completeFunction}_Main`;
+            const completeTemplatePath = path.join(templateDir, 'relationship', `${completeFileName}.ejs`);
+            
+            try {
+                const completeTemplateStr = await fs.readFile(completeTemplatePath, 'utf-8');
+                const completeContent = ejs.render(completeTemplateStr, {
+                    functionName: completeFunction,
+                    upperFunctionName: completeFunction
+                });
+                await fs.writeFile(path.join(flowOutputDir, `${completeFileName}.js`), completeContent, 'utf-8');
+                generatedCount++;
+
+                // Complete Handler is always SQS typically in Izara
+                const completeHandlerName = `${completeFunction}_HdrSqs`;
+                const completeHandlerContent = ejs.render(templates.sqs, {
+                    flowTag: flowTag,
+                    flowStepName: 'Complete', 
+                    mainFileName: completeFileName,
+                    functionName: completeFunction,
+                    queueName: `${completeFunction}HdrSqs`
+                });
+                await fs.writeFile(path.join(flowOutputDir, `${completeHandlerName}.js`), completeHandlerContent, 'utf-8');
+                generatedCount++;
+
+            } catch (err) {
+                console.warn(`  [RelationshipFlowGenerator] Warning: Complete template not found for ${flowTag}. Skipping.`);
+            }
+        }
+    }
+
+    console.log(`  [RelationshipFlowGenerator] Generated ${generatedCount} files for Relationship Flows.`);
+}

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

@@ -0,0 +1,116 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function upperCase(str) {
+    if (!str) return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function lowerCase(str) {
+    if (!str) return str;
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+function shortNameHandler(handlerType) {
+    // Basic mapping for short names
+    const map = {
+        'HdrSqs': 'Sqs',
+        'HdrApi': 'Api',
+        'HdrWbs': 'Wbs',
+        'HdrDsq': 'Dsq'
+    };
+    return map[handlerType] || handlerType;
+}
+
+export async function generateStatusField(flowSchema, appPath, outputBaseDir) {
+    const flowTag = flowSchema.flowTag;
+    const upperFlowTag = upperCase(flowTag);
+    const functionName = 'CompleteStatusField' + upperFlowTag;
+    const handlerType = upperCase('hdrSqs'); // default in old system
+    const queueName = functionName + handlerType;
+
+    // Load templates
+    const templatesDir = path.join(__dirname, 'templates', 'statusField');
+    const mainTpl = await fs.readFile(path.join(templatesDir, 'CompleteStatusField_Main.ejs'), 'utf-8');
+    const handlerTpl = await fs.readFile(path.join(templatesDir, 'CompleteStatusField_HdrSqs.ejs'), 'utf-8');
+    const yamlTpl = await fs.readFile(path.join(__dirname, '..', '_shared', 'yaml', 'SharedFunctionSqs_Yaml.ejs'), 'utf-8');
+    const snsTpl = await fs.readFile(path.join(templatesDir, 'CompleteStatusFieldSns_Yaml.ejs'), 'utf-8');
+
+    // Shared variables
+    const upperFunctionName = upperCase(functionName);
+    const upperHandlerType = upperCase(handlerType);
+    const upperQueueName = upperCase(queueName);
+    const roleName = upperFlowTag;
+    const upperRoleName = upperCase(roleName);
+    const functionNameConfig = upperFunctionName + upperCase(shortNameHandler(handlerType));
+    const upperFunctionNameConfig = upperCase(functionNameConfig);
+    const resourceLocation = `src/generatedCode/FlowSchemas/${upperFlowTag}/source/`;
+    const handlerPath = path.join(resourceLocation, `${functionName}_${upperHandlerType}.main`);
+    const handlerPathUpperFunctionName = path.join(resourceLocation, `${upperFunctionName}_${upperHandlerType}.main`);
+    
+    // Placeholder for IAM permissions (simulating old defaultIamRolePerAction)
+    const additionalResourcePermission = []; 
+
+    // 1. Output Main
+    const flowOutputDir = path.join(outputBaseDir, 'app', 'src', 'generatedCode', 'FlowSchemas', upperFlowTag, 'source');
+    await fs.mkdir(flowOutputDir, { recursive: true });
+    
+    const mainContent = ejs.render(mainTpl, {
+        functionName,
+        flowType: flowTag,
+        upperFunctionName
+    });
+    await fs.writeFile(path.join(flowOutputDir, `${functionName}_Main.js`), mainContent, 'utf-8');
+
+    // 2. Output Handler
+    const handlerContent = ejs.render(handlerTpl, {
+        functionName,
+        handlerType,
+        queueName,
+        upperFunctionName,
+        upperHandlerType,
+        upperQueueName
+    });
+    await fs.writeFile(path.join(flowOutputDir, `${functionName}_${handlerType}.js`), handlerContent, 'utf-8');
+
+    // 3. Output Yaml
+    const slsYamlDir = path.join(outputBaseDir, 'app', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(slsYamlDir, { recursive: true });
+
+    const yamlContent = ejs.render(yamlTpl, {
+        resourceLocation,
+        functionName,
+        handlerType,
+        additionalResourcePermission,
+        functionNameConfig,
+        roleName,
+        queueName,
+        upperFunctionName,
+        upperHandlerType,
+        upperFunctionNameConfig,
+        upperRoleName,
+        upperQueueName,
+        handlerPath,
+        handlerPathUpperFunctionName
+    });
+    // Append to flow-schema.yml (creating if not exist)
+    const flowSchemaYamlPath = path.join(slsYamlDir, 'flow-schema.yml');
+    await fs.appendFile(flowSchemaYamlPath, '\n' + yamlContent, 'utf-8');
+
+    // 4. Output SNS
+    const snsResourceDir = path.join(outputBaseDir, 'resource', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(snsResourceDir, { recursive: true });
+    
+    const snsContent = ejs.render(snsTpl, {
+        queueName: 'CompleteStatusField' + upperFlowTag
+    });
+    const snsYamlPath = path.join(snsResourceDir, 'generated-sns-in-sqs.yml');
+    await fs.appendFile(snsYamlPath, '\n' + snsContent, 'utf-8');
+
+    console.log(`  [StatusFieldGenerator] Generated statusField files for flow: ${flowTag}`);
+}

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

@@ -0,0 +1,124 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function upperCase(str) {
+    if (!str) return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function shortNameHandler(handlerType) {
+    const map = {
+        'HdrSqs': 'Sqs',
+        'HdrApi': 'Api',
+        'HdrWbs': 'Wbs',
+        'HdrDsq': 'Dsq'
+    };
+    return map[handlerType] || handlerType;
+}
+
+export async function generateWebSocket(allLocalFlowSchemas, appPath, outputBaseDir) {
+    const hasOwnTopic = allLocalFlowSchemas.some(flow => flow.event && flow.event.includes('ownTopic'));
+    if (!hasOwnTopic) {
+        console.log('  [WebSocketGenerator] No flows use ownTopic. Skipping WebSocket generation.');
+        return;
+    }
+
+    console.log('  [WebSocketGenerator] Generated WebSocket files with ProcessWebSocketMain_Main convention.');
+    const templatesDir = path.join(__dirname, 'templates', 'webSocket');
+    const wsDir = path.join(outputBaseDir, 'app', 'src', 'generatedCode', 'SystemFlowSchemas', 'WebSocketMain', 'source');
+    await fs.mkdir(wsDir, { recursive: true });
+
+    const slsYamlDir = path.join(outputBaseDir, 'app', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(slsYamlDir, { recursive: true });
+
+    const resourceYamlDir = path.join(outputBaseDir, 'resource', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(resourceYamlDir, { recursive: true });
+
+    // Helper to render and write
+    async function renderAndWrite(tplName, outPath, data) {
+        const tpl = await fs.readFile(path.join(templatesDir, tplName), 'utf-8');
+        const content = ejs.render(tpl, data);
+        await fs.writeFile(outPath, content, 'utf-8');
+    }
+
+    async function renderAndAppend(tplName, outPath, data) {
+        const tpl = await fs.readFile(path.join(templatesDir, tplName), 'utf-8');
+        const content = ejs.render(tpl, data);
+        await fs.appendFile(outPath, '\n' + content, 'utf-8');
+    }
+
+    // 1. DynamoDB Tables
+    const webSocketTaskTable = {
+        tableName: 'WebSocketTask',
+        resourceName: 'WebSocketTask',
+        ttl: true,
+        ttlAttributeName: 'expirationTime',
+        attributes: [
+            { keyType: 'partitionKey', AttributeName: 'taskKey', AttributeType: 'S' },
+            { keyType: 'sortKey', AttributeName: 'connectionId', AttributeType: 'S' }
+        ]
+    };
+    const userUploadRecordsTable = {
+        tableName: 'UserUploadRecords',
+        resourceName: 'UserUploadRecords',
+        attributes: [
+            { keyType: 'partitionKey', AttributeName: 'connectionId', AttributeType: 'S' }
+        ]
+    };
+
+    await renderAndAppend('WebSocketDynamoDb_Yaml.ejs', path.join(resourceYamlDir, 'generated-dynamoDB-table.yml'), webSocketTaskTable);
+    await renderAndAppend('WebSocketDynamoDb_Yaml.ejs', path.join(resourceYamlDir, 'generated-dynamoDB-table.yml'), userUploadRecordsTable);
+
+    // 2. WebSocketConnect
+    const wsConnectName = 'WebSocketConnect';
+    await renderAndWrite('WebSocketConnect_Main.ejs', path.join(wsDir, `${wsConnectName}.js`), {});
+    
+    await renderAndAppend('WebSocketConnect_Yaml.ejs', path.join(slsYamlDir, 'flow-schema.yml'), {
+        functionName: wsConnectName,
+        handlerFilePath: `src/generatedCode/SystemFlowSchemas/WebSocketMain/source/${wsConnectName}`,
+        roleName: 'WebSocketMain',
+        upperFunctionName: upperCase(wsConnectName)
+    });
+
+    // 3. ProcessWebSocketMain
+    const processFunctionName = 'ProcessWebSocketMain';
+    const processHandlerType = 'HdrSqs';
+    const queueName = processFunctionName + shortNameHandler(processHandlerType);
+    
+    const processData = {
+        functionName: processFunctionName,
+        handlerType: processHandlerType,
+        queueName: queueName,
+        handlerFilePath: `src/generatedCode/SystemFlowSchemas/WebSocketMain/source/${upperCase(processFunctionName)}_${upperCase(processHandlerType)}`,
+        roleName: 'WebSocketMain',
+        upperFunctionName: upperCase(processFunctionName),
+        upperHandlerType: upperCase(processHandlerType),
+        upperQueueName: upperCase(queueName),
+        functionNameConfig: upperCase(processFunctionName) + upperCase(shortNameHandler(processHandlerType))
+    };
+
+    await renderAndWrite('ProcessWebSocket_Main.ejs', path.join(wsDir, `${processFunctionName}_Main.js`), processData);
+    await renderAndWrite('ProcessWebSocket_HdrSqs.ejs', path.join(wsDir, `${processFunctionName}_${processHandlerType}.js`), processData);
+    await renderAndAppend('ProcessWebSocketFlow_Yaml.ejs', path.join(slsYamlDir, 'flow-schema.yml'), processData);
+    
+    // 4. SQS and SNS Subscriptions
+    await renderAndAppend('ProcessWebSocket_Yaml.ejs', path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'), processData);
+
+    for (const flowSchema of allLocalFlowSchemas) {
+        if (flowSchema.outputTopic) {
+            const topicOut = upperCase(flowSchema.flowTag);
+            await renderAndAppend('ProcessWebSocketSub_Yaml.ejs', path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'), {
+                subscribeTo: topicOut,
+                queueName: queueName,
+                upperQueueName: upperCase(queueName)
+            });
+        }
+    }
+
+    console.log(`  [WebSocketGenerator] Generated WebSocket files with ProcessWebSocketMain_Main convention.`);
+}

package/src/{generators/fromFlowSchema/events/ownTopic/flowSchema/handler/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/endpoint/FlowEndpoint_HdrWbs.ejs}

@@ -27,7 +27,7 @@ const { createFlowTypeConcat } = utils;
 import { webSocket } from '@izara_project/izara-core-library-external-request';
 const { postToConnection } = webSocket;
 
-import <%- functionName %> from './<%- functionName %>_Main.js';
+import <%- upperCaseFlowTag %> from './<%- upperCaseFlowTag %>_Main.js';
 
 export const main = middleware.wrap(async (event, context) => {
 
@@ -44,7 +44,7 @@ export const main = middleware.wrap(async (event, context) => {
         case '$default':
           console.log('Received unknown route:', route);
           break
-        case '<%- route %>':
+        case '<%- flowTag %>':
           console.log("event in route webSocket", event);
           let eventParams = JSON.parse(event.body)
 
@@ -55,7 +55,7 @@ export const main = middleware.wrap(async (event, context) => {
           let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(
             event._izContext,
             {
-              flowTag: "<%- route %>",
+              flowTag: "<%- flowTag %>",
               serviceTag: process.env.iz_serviceTag
             }
           )
@@ -64,7 +64,7 @@ export const main = middleware.wrap(async (event, context) => {
             await dynamodbSharedLib.putItem(event._izContext,
               await dynamodbSharedLib.tableName(event._izContext, "WebSocketTask"),
               {
-                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: "<%- route %>", serviceTag: process.env.iz_serviceTag })}${identifiers}`,
+                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: "<%- flowTag %>", serviceTag: process.env.iz_serviceTag })}${identifiers}`,
                 connectionId: connectionId,
                 ttl: 600
               }
@@ -75,14 +75,14 @@ export const main = middleware.wrap(async (event, context) => {
               event._izContext,
               await dynamodbSharedLib.tableName(event._izContext, "WebSocketTask"),
               {
-                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: "<%- route %>", serviceTag: process.env.iz_serviceTag })}${correlationId}`,
+                taskKey: `${createFlowTypeConcat(event._izContext, { flowTag: "<%- flowTag %>", serviceTag: process.env.iz_serviceTag })}${correlationId}`,
                 connectionId: connectionId,
               }
             )
           }
 
           let callingFlow = eventParams?.callingFlow ? eventParams.callingFlow : {};
-          await <%- functionName %>(
+          await <%- upperCaseFlowTag %>(
             event._izContext,
             eventParams,
             //(<additionalParams>)

package/src/{generators/fromFlowSchema/flowSchemaMainFunction/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/endpoint/FlowEndpoint_Main.ejs}

@@ -36,13 +36,6 @@ import { utils } from '@izara_project/izara-core-library-service-schemas';
 const { createFlowTypeConcat } = utils;
 //(</optionalImport>)
 
-<% if (statusType === "triggerCache") { -%>
-import { triggeredCacheSharedLibV2 } from '@izara_project/izara-core-library-trigger-cache';
-<% } else if (statusType === "statusField") { -%>
-import statusFieldSharedLib from '@izara_project/izara-core-library-status-field';
-<% } else if (statusType === "storedCache") { -%>
-import storedCacheSharedLib from '@izara_project/izara-core-library-stored-cache';
-<% } -%>
 
 /**
  *
@@ -59,7 +52,7 @@ import storedCacheSharedLib from '@izara_project/izara-core-library-stored-cache
  * @returns {object} description of return value
  */
 
-export default async function <%- functionName %> (
+export default async function Process<%- upperCaseFlowTag %>(
   _izContext,
   requestParams,
   callingFlowConfig = {},
@@ -68,23 +61,36 @@ export default async function <%- functionName %> (
 ) {
 
   try {
-    _izContext.logger.debug("<%- functionName %> _izContext", _izContext)
-    _izContext.logger.debug("<%- functionName %> requestParams", requestParams)
-    _izContext.logger.debug("<%- functionName %> callingFlowConfig", callingFlowConfig)
-
-    <% if (statusType === "statusField") { %>
-      <%- include(statusFieldTemplate, { tableName:tableName, flowTag: flowTag }) %>
-    <% } else if (statusType === "storedCache") { %>
-      <%- include(storedCacheTemplate, { tableName:tableName, flowSchemaComplete:flowSchemaComplete, flowTag }) %>
-    <% } else if (statusType === "triggerCache") { %>
-      <%- include(triggerCacheTemplate, {
-        tableName: tableName,
-        flowSchemaComplete: flowSchemaComplete,
-        triggerType: triggerType,
-        flowTag,
-        queueName
-      }) %>
-    <% } %>
+    _izContext.logger.debug("Process<%- upperCaseFlowTag %> _izContext", _izContext)
+    _izContext.logger.debug("Process<%- upperCaseFlowTag %> requestParams", requestParams)
+    _izContext.logger.debug("Process<%- upperCaseFlowTag %> callingFlowConfig", callingFlowConfig)
+
+<% if (typeof flow !== 'undefined' && flow.isRbac) { %>
+    const { checkRbacPermission } = await import('@izara_project/izara-authorization');
+
+    //(<additionalParams_parameterGroups>)
+    const parameterGroups = {};
+    //(</additionalParams_parameterGroups>)
+
+    const resultPermissionCheck = await checkRbacPermission(_izContext, { flowTag: '<%- flow.flowTag %>', serviceTag: '<%- flow.serviceTag || (flow.objType ? flow.objType.serviceTag : "") %>' }, parameterGroups);
+
+    _izContext.logger.debug('[lib:auth:checkRbacPermission] resultPermissionCheck:', resultPermissionCheck);
+
+    if (resultPermissionCheck.permission === false) {
+
+      //(<messageOutPutPermissionCheckFailed>)
+      const message = {
+
+      }
+      //(</messageOutPutPermissionCheckFailed>)
+
+      return await sns.publishAsync(_izContext, {
+        Message: JSON.stringify(message),
+        TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, '<%- flow.flowTag %>_Out')
+      });
+    }
+
+<% } %>
 
     //(<endpointHook>)
     //(</endpointHook>)

package/src/codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/endpoint/FlowEntryPoint_Main.ejs

@@ -0,0 +1,38 @@
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+//(<helperFunctions>)
+//(</helperFunctions>)
+
+/**
+ * GENERATED MAIN LOGIC: <%= flowTag %> (Entry Point / In Step)
+ */
+export default async function <%= flowTag %>(
+    _izContext, 
+    requestParams, 
+    //(<additionalParams>)
+    //(</additionalParams>)
+    callingFlowConfig = {}
+) {
+    _izContext?.logger?.debug("[<%= flowTag %>] _izContext", _izContext);
+    _izContext?.logger?.debug("[<%= flowTag %>] requestParams", requestParams);
+    _izContext?.logger?.debug("[<%= flowTag %>] callingFlowConfig", callingFlowConfig);
+
+    try {
+        //(<hookCode>)
+        // TODO: Implement the initial validation, parsing, or preparation for this Flow
+        //(</hookCode>)
+
+        return {
+            success: true,
+            processedData: requestParams
+        };
+    } catch (err) {
+        _izContext?.logger?.error('error <%= flowTag %> ActionEndpoint:', err);
+
+        //(<errorHandling>)
+        //(</errorHandling>)
+
+        throw err;
+    }
+}

package/src/{generators/fromFlowSchema/events/ownTopic/flowSchema/mainFunction/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/endpoint/FlowMain_Wbs.ejs}

@@ -48,7 +48,7 @@ const { postToConnection } = webSocket;
  * @returns {object} description of return value
  */
 
-export default async function <%- functionName %> (
+export default async function <%- upperCaseFlowTag %>(
   _izContext,
   requestParams,
   //(<additionalParams>)
@@ -57,9 +57,9 @@ export default async function <%- functionName %> (
 ) {
 
   try {
-    _izContext.logger.debug("<%- functionName %> _izContext", _izContext)
-    _izContext.logger.debug("<%- functionName %> requestParams", requestParams)
-    _izContext.logger.debug("<%- functionName %> callingFlowConfig", callingFlowConfig)
+    _izContext.logger.debug("<%- upperCaseFlowTag %> _izContext", _izContext)
+    _izContext.logger.debug("<%- upperCaseFlowTag %> requestParams", requestParams)
+    _izContext.logger.debug("<%- upperCaseFlowTag %> callingFlowConfig", callingFlowConfig)
 
     let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, {
       flowTag: "<%- flowTag %>",
@@ -79,29 +79,29 @@ export default async function <%- functionName %> (
         message: {
           error: `flowTag not found ${requestParams.action}`
         }
-      },connectionId)
+      }, connectionId)
       throw new NoRetryError(`flowTag not found ${requestParams.action}`);
     }
 
-      let messageObject = requestParams
+    let messageObject = requestParams
 
-      // create callingFlow
-      messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-        messageObject,
-        callingFlowSharedLib.addParentCallingFlowConfig(
-          callingFlowConfig,
-          callingFlowSharedLib.createCallingFlowConfig(
-            await lambdaSharedLib.lambdaFunctionName(_izContext, "WebSocketComplete"), {}
-          )
+    // create callingFlow
+    messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+      messageObject,
+      callingFlowSharedLib.addParentCallingFlowConfig(
+        callingFlowConfig,
+        callingFlowSharedLib.createCallingFlowConfig(
+          await lambdaSharedLib.lambdaFunctionName(_izContext, "WebSocketComplete"), {}
         )
       )
+    )
 
-      let sendMessageToEndpoint = {
-        Message: JSON.stringify(messageObject),
-        TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, "<%- topicArn %>")
-      }
-      _izContext.logger.debug("sendMessageToEndpoint", sendMessageToEndpoint);
-      await sns.publishAsync(_izContext, sendMessageToEndpoint);
+    let sendMessageToEndpoint = {
+      Message: JSON.stringify(messageObject),
+      TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, "<%- upperCaseFlowTag %>_In")
+    }
+    _izContext.logger.debug("sendMessageToEndpoint", sendMessageToEndpoint);
+    await sns.publishAsync(_izContext, sendMessageToEndpoint);
 
   } catch (err) {
     _izContext.logger.error('error WebSocketInvoke: ', err)

package/src/{generators/fromFlowSchema/events/s3/upload/confirmReserved/handler/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3/ConfirmReserved_HdrSqs.ejs}

@@ -22,7 +22,7 @@ import { recordHandlerSharedLib } from "@izara_project/izara-core-library-record
 import Logger from '@izara_project/izara-core-library-logger';
 import callingFlowSharedLib from "@izara_project/izara-core-library-calling-flow";
 
-import confirmNewReserved from './ConfirmNewReserved_Main.js'
+import <%= functionName %> from './<%= functionName %>_Main.js'
 
 // validate event properties in body.Message of sqs event
 middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
@@ -79,7 +79,7 @@ export const main = middleware.wrap(async (event, context) => {
       // validate message (and MessageAttributes)
       await recordHandlerSharedLib.validateRecord(
         record,                             // one record will send to mainFunction
-        "ConfirmNewReservedHdrSqs",         // queue name that need to retry or send to dlq
+        "<%= functionName %><%= handlerType %>",         // 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
       );
@@ -96,8 +96,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
-        confirmNewReserved,  // mainFunction that need to invoke.
-        "ConfirmNewReservedHdrSqs",             // queue name that need to retry or send to dlq
+        <%= functionName %>,  // mainFunction that need to invoke.
+        "<%= functionName %><%= handlerType %>",             // queue name that need to retry or send to dlq
         passOnProperties,                       // all parameters that mainFunction needed.
       );
       record._izContext.logger.debug('after recordPromise in handler');
@@ -117,7 +117,7 @@ export const main = middleware.wrap(async (event, context) => {
     Logger.debug('after Promise.all(recordPromises) in handler');
 
   } catch (err) {
-    Logger.error('Unhandled Error, ConfirmNewReservedHdrSqs: ', err);
+    Logger.error('Unhandled Error, <%= functionName %><%= handlerType %>: ', err);
     throw (err);
   }
 });

package/src/{generators/fromFlowSchema/events/s3/upload/createObject/handler/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3/CreateObject_HdrWbs.ejs}

@@ -25,7 +25,7 @@ const { postToConnection } = webSocket;
 import { utils } from "@izara_project/izara-core-library-service-schemas";
 const { createFlowTypeConcat } = utils
 
-import createObject from './CreateObjectS3_Main.js';
+import <%= functionName %> from './<%= functionName %>_Main.js';
 
 export const main = middleware.wrap(async (event, context) => {
 
@@ -56,7 +56,7 @@ export const main = middleware.wrap(async (event, context) => {
           )
 
           let callingFlow = eventParams?.callingFlow ? eventParams.callingFlow : {};
-          await createObject(
+          await <%= functionName %>(
             event._izContext,
             eventParams,
             callingFlowSharedLib.addCallingFlowToPassOnProperties(callingFlow)