@izara_project/izara-core-generate-service-code 1.0.65 → 1.0.67

package/src/emit/crud/emitCrudApplicationArtifacts.js

@@ -0,0 +1,161 @@
+import ejs from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+import {
+  renderApiFunctionYaml,
+  renderInvFunctionYaml,
+  renderSqsFunctionYaml,
+  renderWbsFunctionYaml
+} from '../function/functionYamlArtifact.js';
+
+const ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
+const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-objects.yml';
+const TEMPLATE_URL = new URL('./templates/', import.meta.url);
+
+export async function emitCrudApplicationArtifacts({ objects, flows = [], serviceTag }) {
+  if (!Array.isArray(objects) || !Array.isArray(flows)) {
+    throw new TypeError('objects and flows must be arrays');
+  }
+  if (!objects.some(isCrudObject)) return [];
+
+  const handlers = await Promise.all(ACTIONS.map(action => emitAction(action, objects, flows, serviceTag)));
+  return [
+    ...handlers.flatMap(handler => handler.artifacts),
+    {
+      path: YAML_PATH,
+      content: handlers.flatMap(handler => handler.functions).map(renderFunction).join('\n')
+    }
+  ];
+}
+
+export function crudApplicationManagedPaths() {
+  return [
+    ...ACTIONS.flatMap(action => {
+      const source = `app/src/generatedCode/FlowObjects/${action}/source`;
+      const paths = [`${source}/${action}_Main.js`];
+      if (action === 'Get') {
+        paths.push(`${source}/Get_HdrInv.js`, `${source}/Get_HdrApi.js`);
+        paths.push(`${source}/GetRange_Main.js`, `${source}/GetRange_HdrApi.js`);
+      } else {
+        paths.push(
+          `${source}/${action}_HdrSqs.js`,
+          `${source}/${action}_WbsMain.js`,
+          `${source}/${action}_HdrWbs.js`,
+          `${source}/${action}BeforeLogical_Main.js`,
+          `${source}/${action}BeforeLogical_HdrSqs.js`
+        );
+        paths.push(`${source}/${action}Complete_Main.js`, `${source}/${action}Complete_HdrSqs.js`);
+      }
+      return paths;
+    }),
+    YAML_PATH
+  ];
+}
+
+async function emitAction(action, objects, flows, serviceTag) {
+  const source = `app/src/generatedCode/FlowObjects/${action}/source`;
+  const handlerRoot = `src/generatedCode/FlowObjects/${action}/source`;
+  const generateCode = flows
+    .filter(flow => flow?.generatedCodeConfig?.generatedCodeTag?.toLowerCase() === action.toLowerCase())
+    .map(flow => ({ ...flow.generatedCodeConfig, flowTag: flow.flowTag }));
+  const mainFileName = `${action}_Main`;
+  const shared = {
+    flowTag: action,
+    upperCaseFlowTag: action,
+    topicArn: `${action}_In`,
+    generateCode,
+    flow: null,
+    flowStepName: '',
+    startConfig: null
+  };
+  const artifacts = [{
+    path: `${source}/${mainFileName}.js`,
+    content: await render(`${action}Endpoint_Main.ejs`, shared)
+  }];
+
+  if (action === 'Get') {
+    artifacts.push(
+      { path: `${source}/Get_HdrInv.js`, content: await render('FlowHandler_HdrInv.ejs', { ...shared, mainFileName, functionName: 'Get', queueName: 'GetHdrInv' }) },
+      { path: `${source}/Get_HdrApi.js`, content: await render('FlowHandler_HdrApi.ejs', { ...shared, mainFileName, functionName: 'Get', queueName: 'GetHdrApi' }) },
+      { path: `${source}/GetRange_Main.js`, content: await render('GetRangeEndpoint_Main.ejs', { ...shared, mainFileName: 'GetRange_Main', functionName: 'GetRange' }) },
+      { path: `${source}/GetRange_HdrApi.js`, content: await render('FlowHandler_HdrApi.ejs', { ...shared, mainFileName: 'GetRange_Main', functionName: 'GetRange', queueName: 'GetRangeHdrApi' }) }
+    );
+    return {
+      artifacts,
+      functions: [
+        { type: 'inv', functionName: 'GetHdrInv', handlerPath: `${handlerRoot}/Get_HdrInv.main`, roleName: 'FlowObjectsRole', flowTag: action, flowStepName: '' },
+        {
+          type: 'api',
+          functionName: 'GetHdrApi',
+          handlerPath: `${handlerRoot}/Get_HdrApi.main`,
+          roleName: 'FlowObjectsRole',
+          flowTag: action,
+          flowStepName: '',
+          routes: objects.filter(isCrudObject).map(object => ({
+            path: `/${serviceTag ?? '${self:custom.iz_serviceName}'}/${object.objectType}/get`,
+            upperName: upperFirst(object.objectType)
+          }))
+        },
+        {
+          type: 'api',
+          functionName: 'GetRangeHdrApi',
+          handlerPath: `${handlerRoot}/GetRange_HdrApi.main`,
+          roleName: 'FlowObjectsRole',
+          flowTag: 'GetRange',
+          flowStepName: '',
+          routes: objects.filter(isCrudObject)
+            .filter(object => object.identifiers && object.identifiers.some(i => i.type === 'sortKey'))
+            .map(object => ({
+            path: `/${serviceTag ?? '${self:custom.iz_serviceName}'}/${object.objectType}/getRange`,
+            upperName: upperFirst(object.objectType)
+          }))
+        }
+      ]
+    };
+  }
+
+  artifacts.push(
+    { path: `${source}/${action}_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { ...shared, mainFileName, functionName: action, queueName: `${action}HdrSqs` }) },
+    { path: `${source}/${action}_WbsMain.js`, content: await render('FlowMain_Wbs.ejs', { ...shared, functionName: action }) },
+    { path: `${source}/${action}_HdrWbs.js`, content: await render('FlowEndpoint_HdrWbs.ejs', { ...shared, mainFileName: `${action}_WbsMain`, functionName: action, route: action }) }
+  );
+  const functions = [
+    { type: 'wbs', functionName: `${action}HdrWbs`, handlerPath: `${handlerRoot}/${action}_HdrWbs.main`, roleName: 'FlowObjectsRole', routeName: action, flowTag: action, flowStepName: '' },
+    { type: 'sqs', functionName: `${action}HdrSqs`, handlerPath: `${handlerRoot}/${action}_HdrSqs.main`, roleName: 'FlowObjectsRole', queueName: `${action}HdrSqs`, flowTag: action, flowStepName: '' }
+  ];
+  const complete = `${action}Complete`;
+  artifacts.push(
+    { path: `${source}/${complete}_Main.js`, content: await render('FlowEndpointComplete_Main.ejs', { action }) },
+    { path: `${source}/${complete}_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { ...shared, mainFileName: `${complete}_Main`, functionName: complete, queueName: `${action}CompleteHdrSqs` }) }
+  );
+  functions.push({ type: 'sqs', functionName: `${action}CompleteHdrSqs`, handlerPath: `${handlerRoot}/${complete}_HdrSqs.main`, roleName: 'FlowObjectsRole', queueName: `${action}CompleteHdrSqs`, flowTag: action, flowStepName: 'Complete' });
+  if (generateCode.some(config => config.codeHookTag === 'beforeLogical')) {
+    const beforeMain = `${action}BeforeLogical_Main`;
+    artifacts.push(
+      { path: `${source}/${beforeMain}.js`, content: await render('FlowEndpointBeforeLogical_Main.ejs', shared) },
+      { path: `${source}/${action}BeforeLogical_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { ...shared, mainFileName: beforeMain, functionName: `${action}BeforeLogicalMain`, queueName: `${action}BeforeLogicalHdrSqs` }) }
+    );
+    functions.push({ type: 'sqs', functionName: `${action}BeforeLogicalHdrSqs`, handlerPath: `${handlerRoot}/${action}BeforeLogical_HdrSqs.main`, roleName: 'FlowObjectsRole', queueName: `${action}BeforeLogicalHdrSqs`, flowTag: action, flowStepName: 'BeforeLogical' });
+  }
+  return { artifacts, functions };
+}
+
+function isCrudObject(object) {
+  return object?.generatedBy === 'userGenerated' || object?.generatedBy === 'systemGenerated';
+}
+
+function upperFirst(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+async function render(templateName, data) {
+  const template = await readFile(new URL(templateName, TEMPLATE_URL), 'utf8');
+  return ejs.render(template, data);
+}
+
+function renderFunction(descriptor) {
+  if (descriptor.type === 'api') return renderApiFunctionYaml(descriptor);
+  if (descriptor.type === 'inv') return renderInvFunctionYaml(descriptor);
+  if (descriptor.type === 'wbs') return renderWbsFunctionYaml(descriptor);
+  return renderSqsFunctionYaml(descriptor);
+}

package/src/emit/crud/emitDynamicCrudFlowSchemas.js

@@ -0,0 +1,84 @@
+import { renderDynamicCrudFlowSchema } from './dynamicCrudFlowSchemaTemplate.js';
+
+const ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
+const MESSAGE_ATTRIBUTES = ['userId', 'correlationId'];
+
+export const dynamicCrudFlowSchemaPaths = ACTIONS.map(
+  action => `app/src/schemas/FlowSchemas/generateCode/${action}.js`
+);
+
+export function emitDynamicCrudFlowSchemas({ objects, flows = [] }) {
+  if (!Array.isArray(objects) || !Array.isArray(flows)) {
+    throw new TypeError('objects and flows must be arrays');
+  }
+  if (!objects.some(object => object?.generatedBy === 'userGenerated' || object?.generatedBy === 'systemGenerated')) {
+    return [];
+  }
+
+  return ACTIONS.map((action, index) => {
+    const flow = createDynamicFlow(action, hasBeforeLogicalStep(flows, action));
+    return {
+      path: dynamicCrudFlowSchemaPaths[index],
+      content: renderDynamicCrudFlowSchema(action, flow)
+    };
+  });
+}
+
+function createDynamicFlow(action, hasBeforeLogicalStep) {
+  const outputTopic = action !== 'Get';
+  const flowSteps = [
+    {
+      stepName: 'start',
+      properties: [],
+      messageAttributes: MESSAGE_ATTRIBUTES,
+      ...(outputTopic ? {
+        returnValues: {
+          properties: [],
+          messageAttributes: MESSAGE_ATTRIBUTES
+        }
+      } : {})
+    }
+  ];
+
+  if (hasBeforeLogicalStep) {
+    flowSteps.push({
+      stepName: 'BeforeLogical',
+      event: ['extTopic'],
+      properties: [],
+      messageAttributes: MESSAGE_ATTRIBUTES
+    });
+  }
+  if (action !== 'Get') {
+    flowSteps.push({
+      stepName: 'Complete',
+      event: ['extTopic'],
+      properties: [],
+      messageAttributes: MESSAGE_ATTRIBUTES
+    });
+  }
+
+  return {
+    flowTag: action,
+    isDynamicObjectType: true,
+    initiateBy: 'system',
+    handleObj: 'one',
+    statusType: 'none',
+    event: outputTopic ? ['ownTopic'] : ['lambdaSyncInv', 'lambdaSyncApi'],
+    outputTopic,
+    stepMessageAttributes: {
+      userId: { propertyName: 'x-correlation-base-user-id', type: 'string' },
+      correlationId: { propertyName: 'x-correlation-id', type: 'string' }
+    },
+    flowSteps
+  };
+}
+
+function hasBeforeLogicalStep(flows, action) {
+  return flows.some(flow => {
+    const config = flow?.generatedCodeConfig;
+    return config?.generatedCodeTag === action.toLowerCase()
+      && config.codeHookTag === 'beforeLogical'
+      && Array.isArray(flow.event)
+      && flow.event.includes(config.invocationType);
+  });
+}

package/src/emit/crud/generateCrudApplicationArtifacts.js

@@ -0,0 +1,16 @@
+import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../output/commitArtifacts.js';
+import { compileProject } from '../../compile/compileProject.js';
+import { loadLocalSchemaArrays } from './loadLocalSchemaArrays.js';
+import { crudApplicationManagedPaths, emitCrudApplicationArtifacts } from './emitCrudApplicationArtifacts.js';
+
+export async function generateCrudApplicationArtifacts(rootPath, options = {}) {
+  const project = compileProject({ ...options, rootPath });
+  const schemas = await loadLocalSchemaArrays(project);
+  const artifacts = await emitCrudApplicationArtifacts({ ...schemas, serviceTag: project.serviceTag });
+  const files = await commitArtifacts(buildGenerationPlan(project, artifacts, {
+    managedPaths: crudApplicationManagedPaths(),
+    managedScope: 'crud-application'
+  }));
+  return { project, files };
+}

package/src/emit/crud/generateDynamicCrudFlowSchemas.js

@@ -0,0 +1,21 @@
+import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../output/commitArtifacts.js';
+import { compileProject } from '../../compile/compileProject.js';
+import {
+  dynamicCrudFlowSchemaPaths,
+  emitDynamicCrudFlowSchemas
+} from './emitDynamicCrudFlowSchemas.js';
+import { loadLocalSchemaArrays } from './loadLocalSchemaArrays.js';
+
+export async function generateDynamicCrudFlowSchemas(rootPath, options = {}) {
+  const project = compileProject({ ...options, rootPath });
+  const schemaInputs = await loadLocalSchemaArrays(project);
+  const plan = buildGenerationPlan(
+    project,
+    emitDynamicCrudFlowSchemas(schemaInputs),
+    { managedPaths: dynamicCrudFlowSchemaPaths, managedScope: 'crud-flow-schemas' }
+  );
+  const files = await commitArtifacts(plan);
+
+  return { project, files };
+}

package/src/emit/crud/loadLocalSchemaArrays.js

@@ -0,0 +1,8 @@
+import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+
+export async function loadLocalSchemaArrays(project) {
+  return {
+    objects: await loadLocalSchemaDirectory(project, 'ObjectSchemas'),
+    flows: await loadLocalSchemaDirectory(project, 'FlowSchemas')
+  };
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowObjects/templates/crud → emit/crud/templates}/CreateEndpoint_Main.ejs

@@ -63,7 +63,7 @@ export async function <%- flowTag %>MainLogical(
   beforeLogicalResults = {}
 ) {
   try {
-    _izContext.logger.debug('createMainLogical:', {
+    _izContext.logger.debug('[<%- flowTag %>MainLogical] started', {
       requestParams,
       callingFlowConfig,
       beforeLogicalResults
@@ -406,7 +406,7 @@ export default async function <%- flowTag %>(
   //(</additionalParams>)
 ) {
   try {
-    _izContext.logger.debug('createMain:', { requestParams, callingFlowConfig });
+    _izContext.logger.debug('[<%- flowTag %>] createMain:', { requestParams, callingFlowConfig });
 
     const errorsFound = [];
     const objType = createObjType(requestParams.objectType);
@@ -606,13 +606,13 @@ export default async function <%- flowTag %>(
       }
       <%_ } _%>
 
-      await asyncFlowSharedLib.initAwaitingStepsWithAttrs(
+      await asyncFlowSharedLib.createAwaitingMultipleSteps(
         _izContext,
-        awaitingMultipleStepIds,
         asyncFlowSharedLib.createPendingStepId(
           _izContext.uniqueRequestId,
           'beforeLogical_<%= objectType %>'
-        )
+        ),
+        awaitingMultipleStepIds
       );
 
       //(<beforePublish_<%= objectType %>>)
@@ -670,4 +670,4 @@ export default async function <%- flowTag %>(
   } catch (err) {
     throw err;
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowObjects/templates/crud → emit/crud/templates}/DeleteEndpoint_Main.ejs

@@ -53,7 +53,7 @@ export async function <%- flowTag %>MainLogical(
   beforeLogicalResults = {}
 ) {
   try {
-    _izContext.logger.debug('deleteMainLogical:', { requestParams, callingFlowConfig, beforeLogicalResults });
+    _izContext.logger.debug('[<%- flowTag %>MainLogical] started', { requestParams, callingFlowConfig, beforeLogicalResults });
 
     //(<beforeDeleteMainLogical>)
     //(</beforeDeleteMainLogical>)
@@ -157,7 +157,7 @@ export default async function <%- flowTag %>(
   //(</additionalParams>)
 ) {
   try {
-    _izContext.logger.debug('deleteMain:', { requestParams, callingFlowConfig });
+    _izContext.logger.debug('[<%- flowTag %>]', { requestParams, callingFlowConfig });
 
     const errorsFound = [];
     const objType = createObjType(requestParams.objectType);
@@ -281,13 +281,13 @@ export default async function <%- flowTag %>(
         }
         <%_ } _%>
 
-        await asyncFlowSharedLib.initAwaitingStepsWithAttrs(
+        await asyncFlowSharedLib.createAwaitingMultipleSteps(
           _izContext,
-          awaitingMultipleStepIds,
           asyncFlowSharedLib.createPendingStepId(
             hash(identifiers),
             'beforeLogical_<%= objectType %>'
-          )
+          ),
+          awaitingMultipleStepIds
         );
 
         //(<beforePublish_<%= objectType %>>)
@@ -346,4 +346,4 @@ export default async function <%- flowTag %>(
   } catch (err) {
     throw err;
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowObjects/templates/step → emit/crud/templates}/FlowEndpointBeforeLogical_Main.ejs

@@ -67,7 +67,7 @@ export default async function <%- flowTag %>BeforeLogicalMain(
       }
     }
     _izContext.logger.debug('identifiers:::: ', identifiers);
-    
+
     // build parentFlowId
     <%_ if (flowTag === 'Create') { _%>
     const parentFlowId = identifierUuid();
@@ -155,4 +155,4 @@ export default async function <%- flowTag %>BeforeLogicalMain(
   } catch (err) {
     throw err;
   }
-}
+}

package/src/emit/crud/templates/FlowEndpointComplete_Main.ejs

@@ -0,0 +1,96 @@
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { sns } from '@izara_project/izara-core-library-external-request';
+import { consts } from '@izara_project/izara-core-library-service-schemas';
+import { NoRetryError } from '@izara_project/izara-core-library-core';
+
+const { TOPIC_NAME_GENERATE_CODE, PREFIX: _constPrefix } = consts;
+<%_ if (action === 'Create') { _%>
+const PREFIX = { ASYNC: _constPrefix.CREATE_OBJECT_ASYNC };
+<%_ } else if (action === 'Update') { _%>
+const PREFIX = { ASYNC: _constPrefix.updateNode };
+<%_ } else { _%>
+const PREFIX = { ASYNC: '<%- action %>AsyncEndpoint' };
+<%_ } _%>
+
+function empty(value) {
+  return value == null || (typeof value === 'object' && Object.keys(value).length === 0);
+}
+
+function validateInput(returnValue, status, graphServiceTag, errorsFound) {
+  if (!returnValue?.queryResult) errorsFound.push('message is not have property queryResult, should be not happen');
+  if (!returnValue?.requestParams?.objType) errorsFound.push('message is not have property objType, should be not happen');
+  if (!returnValue?.requestParams?.objInstanceFull) errorsFound.push('message is not have property objInstance, should be not objInstance');
+  if (status === 'error' && errorsFound.length === 0) errorsFound.push('[invalid]status is error not have errorsFound form graphService');
+  if (status === 'complete' && errorsFound.length > 0) errorsFound.push('[Invalid] status is complete should be not have errorsFound');
+  if (graphServiceTag == null) errorsFound.push('[Invalid] graphServerTag is not empty string');
+}
+
+export default async function <%- action %>Complete(_izContext, requestParams, passBackProperties) {
+  try {
+    _izContext.logger.debug('[<%- action %>Complete] started', { requestParams });
+    const { returnValue, status, errorsFound = [], graphServiceTag, parentFlowId } = requestParams;
+    if (empty(returnValue?.requestParams)) throw new NoRetryError('message not an object');
+    validateInput(returnValue, status, graphServiceTag, errorsFound);
+    if (errorsFound.length > 0) errorsFound.push(errorsFound.join(','));
+
+    const awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(parentFlowId, PREFIX.ASYNC);
+    const pending = await asyncFlowSharedLib.findPendingStepAwaitingMultipleSteps(_izContext, awaitingStepId);
+    _izContext.logger.debug('[<%- action %>Complete] awaiting step', {
+      awaitingStepId,
+      pending
+    });
+    if (!pending) {
+      _izContext.logger.warn(`No pending step found for awaitingStepId: ${awaitingStepId}`);
+      return { returnValue, status, errorsFound };
+    }
+    const result = await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
+      _izContext, pending.pendingStepId, awaitingStepId, errorsFound
+    );
+    _izContext.logger.debug('[<%- action %>Complete] all awaiting steps result', { isComplete: result.isComplete, awaitingStepId, pendingStepId: pending.pendingStepId });
+
+    if (result.isComplete) {
+      const nodeResultKey = `return<%- action %>dNode`;
+      const fallbackNodeResultKey = `return<%- action %>Node`;
+      const nodeResult = returnValue.queryResult[nodeResultKey] ?? returnValue.queryResult[fallbackNodeResultKey] ?? {};
+      const node = nodeResult[`<%- action.toLowerCase() %>NodeResult`] ?? nodeResult;
+      const existsNode = node.existsNode && Object.keys(node.existsNode).length
+        ? { objType: returnValue.requestParams.objType, objInstanceFull: node.existsNode.objInstanceFull }
+        : null;
+      if (status === 'complete') {
+        await Promise.all((pending.listOfRecords ?? []).flatMap(records => Object.values(records).map(async record =>
+          dynamodbSharedLib.putItem(_izContext, await dynamodbSharedLib.tableName(_izContext, record.tableName, record.serviceTag), {
+            ...record.objInstanceFull.identifiers,
+            ...record.objInstanceFull.fields
+          })
+        )));
+      }
+      const message = callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(passBackProperties, {
+        objType: returnValue.requestParams.objType,
+        objInstanceFull: node.objInstanceFull,
+        relationships: node.relationships,
+        parentFlowId: returnValue.parentFlowId,
+        existsNode,
+        status,
+        errorsFound
+      });
+      const messageAttributes = callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(passBackProperties, {});
+      const topicArn = await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.out<%- action %>NodeComplete);
+      _izContext.logger.debug('[<%- action %>Complete] publishing to SNS', { TopicArn: topicArn, message });
+      await sns.publishAsync(_izContext, {
+        Message: JSON.stringify(message),
+        MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+        TopicArn: topicArn
+      });
+      //(<afterSendMessage>)
+      //(</afterSendMessage>)
+    }
+    await asyncFlowSharedLib.removeAwaitingMultipleStep(_izContext, awaitingStepId, pending.pendingStepId, errorsFound);
+    return { returnValue, status, errorsFound };
+  } catch (error) {
+    _izContext.logger.error('[<%- action %>Complete] error:', error);
+    throw error;
+  }
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/endpoint → emit/crud/templates}/FlowEndpoint_HdrWbs.ejs

@@ -107,4 +107,4 @@ export const main = middleware.wrap(async (event, context) => {
     await postToConnection({ message: err.message }, connId);
     return (response.failure(err));
   }
-});
+});

package/src/emit/crud/templates/FlowHandler_HdrApi.ejs

@@ -0,0 +1,69 @@
+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 startConfig !== 'undefined' && startConfig !== null && startConfig.properties && startConfig.properties.length > 0) { -%>
+    type: 'object',
+    properties: {
+    <% startConfig.properties.forEach(prop => { -%>
+        <%- prop.propertyName %>: { type: '<%- prop.type || 'string' %>' },
+    <% }) -%>
+    },
+    required: [ <%- startConfig.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 {
+        let objectType;
+        if (event.routeKey) {
+            const path = event.routeKey.split(' ')[1];
+            if (path) {
+                const segments = path.split('/');
+                const serviceName = process.env.iz_serviceName;
+                const serviceIndex = segments.indexOf(serviceName);
+                if (serviceIndex !== -1 && segments.length > serviceIndex + 1) {
+                    objectType = segments[serviceIndex + 1];
+                }
+            }
+        }
+
+        if (objectType) {
+            event.body = event.body || {};
+            event.body.objectType = objectType;
+        }
+
+        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);
+    }
+});