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

package/src/emit/custom/emitCustomFlowApplicationArtifacts.js

@@ -0,0 +1,308 @@
+import ejs from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+import {
+  renderApiFunctionYaml,
+  renderEventBridgeFunctionYaml,
+  renderInvFunctionYaml,
+  renderSqsFunctionYaml,
+  renderWbsFunctionYaml
+} from '../function/functionYamlArtifact.js';
+import { customFlowRoleName, flowExtTopicSteps, generatedOwnTopicFlows, supportedCustomFlows, triggerCacheFlows, triggerCacheQueueNames, upperFirst } from './customFlows.js';
+
+const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-schema.yml';
+const TEMPLATE_URL = new URL('../crud/templates/', import.meta.url);
+const CUSTOM_TEMPLATE_URL = new URL('./templates/', import.meta.url);
+const DSQ_TEMPLATE_URL = new URL('../relationship/templates/', import.meta.url);
+
+export async function emitCustomFlowApplicationArtifacts(flows, { systemFunctions = [], objects = [] } = {}) {
+  const customFlows = supportedCustomFlows(flows);
+  const generatedRoots = generatedOwnTopicFlows(flows);
+  const steps = flowExtTopicSteps(flows);
+  const triggerCache = triggerCacheFlows(flows);
+  if (customFlows.length === 0 && generatedRoots.length === 0 && steps.length === 0 && triggerCache.length === 0 && systemFunctions.length === 0) return [];
+
+  const emitted = await Promise.all(customFlows.map(flow => emitFlow(flow, objects)));
+  const roots = await Promise.all(generatedRoots.map(flow => emitOwnTopicRoot(flow, objects)));
+  const stepResults = await Promise.all(steps.map(emitExtTopicStep));
+  const triggerCacheResults = await Promise.all(triggerCache.map(emitTriggerCacheFlow));
+  return [
+    ...emitted.flatMap(result => result.artifacts),
+    ...roots.flatMap(result => result.artifacts),
+    ...stepResults.flatMap(result => result.artifacts),
+    ...triggerCacheResults.flatMap(result => result.artifacts),
+    { path: YAML_PATH, content: [...systemFunctions, ...emitted.flatMap(result => result.functions), ...roots.flatMap(result => result.functions), ...stepResults.map(result => result.function), ...triggerCacheResults.flatMap(result => result.functions)].join('\n') }
+  ];
+}
+
+export function customFlowApplicationManagedPaths(flows, { includeYaml = false } = {}) {
+  return [
+    ...supportedCustomFlows(flows).flatMap(flow => flowPaths(flow)),
+    ...generatedOwnTopicFlows(flows).flatMap(ownTopicRootPaths),
+    ...flowExtTopicSteps(flows).flatMap(({ flowTag, stepName }) => {
+      const source = `app/src/generatedCode/FlowSchemas/${flowTag}/source`;
+      return [`${source}/${flowTag}${stepName}_Main.js`, `${source}/${flowTag}${stepName}_HdrSqs.js`];
+    }),
+    ...triggerCacheFlows(flows).flatMap(triggerCachePaths),
+    ...(supportedCustomFlows(flows).length > 0 || generatedOwnTopicFlows(flows).length > 0 || flowExtTopicSteps(flows).length > 0 || triggerCacheFlows(flows).length > 0 || includeYaml ? [YAML_PATH] : [])
+  ];
+}
+
+async function emitTriggerCacheFlow(flow) {
+  const tag = upperFirst(flow.flowTag);
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  const handlerRoot = `src/generatedCode/FlowSchemas/${tag}/source`;
+  const roleName = customFlowRoleName(flow.flowTag);
+  const [processQueue, checkQueue, completeSqsQueue, completeDsqQueue] = triggerCacheQueueNames(flow);
+  const process = `TriggerCache${tag}`;
+  const check = `CheckTriggerCache${tag}Complete`;
+  const complete = `TriggerCache${tag}Complete`;
+  const handler = (functionName, handlerType) => `${handlerRoot}/${functionName}_${handlerType}.main`;
+
+  return {
+    artifacts: [
+      { path: `${source}/${process}_Main.js`, content: await renderCustom('triggerCache/TriggerCache_Main.ejs', { functionName: process }) },
+      { path: `${source}/${process}_HdrDsq.js`, content: await renderDsq('FlowHandler_HdrDsq.ejs', { functionName: process, mainFileName: `${process}_Main`, queueName: processQueue, startConfig: null }) },
+      { path: `${source}/${check}_Main.js`, content: await renderCustom('triggerCache/CheckTriggerCache_Main.ejs', { functionName: check, flowTag: flow.flowTag }) },
+      { path: `${source}/${check}_HdrSqs.js`, content: await renderCustom('triggerCache/CheckTriggerCache_HdrSqs.ejs', { functionName: check, queueName: checkQueue }) },
+      { path: `${source}/${complete}_Main.js`, content: await renderCustom('triggerCache/TriggerCacheComplete_Main.ejs', { functionName: complete, flowTag: flow.flowTag }) },
+      { path: `${source}/${complete}_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { functionName: complete, mainFileName: `${complete}_Main`, queueName: completeSqsQueue, startConfig: null, usePassBack: false }) },
+      { path: `${source}/${complete}_HdrDsq.js`, content: await renderDsq('FlowHandler_HdrDsq.ejs', { functionName: complete, mainFileName: `${complete}_Main`, queueName: completeDsqQueue, startConfig: null, usePassBack: false }) }
+    ],
+    functions: [
+      renderSqsFunctionYaml({ functionName: `${process}HdrDsq`, handlerPath: handler(process, 'HdrDsq'), roleName, queueName: processQueue }),
+      renderSqsFunctionYaml({ functionName: `${check}HdrSqs`, handlerPath: handler(check, 'HdrSqs'), roleName, queueName: checkQueue }),
+      renderSqsFunctionYaml({ functionName: `${complete}HdrSqs`, handlerPath: handler(complete, 'HdrSqs'), roleName, queueName: completeSqsQueue }),
+      renderSqsFunctionYaml({ functionName: `${complete}HdrDsq`, handlerPath: handler(complete, 'HdrDsq'), roleName, queueName: completeDsqQueue })
+    ]
+  };
+}
+
+function triggerCachePaths(flow) {
+  const tag = upperFirst(flow.flowTag);
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  const process = `TriggerCache${tag}`;
+  const check = `CheckTriggerCache${tag}Complete`;
+  const complete = `TriggerCache${tag}Complete`;
+  return [
+    `${source}/${process}_Main.js`,
+    `${source}/${process}_HdrDsq.js`,
+    `${source}/${check}_Main.js`,
+    `${source}/${check}_HdrSqs.js`,
+    `${source}/${complete}_Main.js`,
+    `${source}/${complete}_HdrSqs.js`,
+    `${source}/${complete}_HdrDsq.js`
+  ];
+}
+
+async function emitFlow(flow, objects) {
+  const tag = upperFirst(flow.flowTag);
+  const process = `Process${tag}`;
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  const handlerRoot = `src/generatedCode/FlowSchemas/${tag}/source`;
+  const shared = { flowTag: flow.flowTag, flowStepName: '', mainFileName: `${process}_Main`, functionName: process, startConfig: startConfig(flow) };
+  const artifacts = needsProcessMain(flow)
+    ? [{ path: `${source}/${process}_Main.js`, content: await renderEndpointMain(flow, process, objects) }]
+    : [];
+  const functions = [];
+
+  if (flow.event.includes('extTopic')) {
+    artifacts.push({ path: `${source}/${process}_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { ...shared, queueName: `${process}HdrSqs` }) });
+    functions.push(renderSqsFunctionYaml({ functionName: `${process}HdrSqs`, handlerPath: `${handlerRoot}/${process}_HdrSqs.main`, roleName: customFlowRoleName(flow.flowTag), queueName: `${process}HdrSqs` }));
+  }
+  if (flow.event.includes('lambdaSyncInv')) {
+    artifacts.push({ path: `${source}/${process}_HdrInv.js`, content: await render('FlowHandler_HdrInv.ejs', shared) });
+    functions.push(renderInvFunctionYaml({ functionName: `${process}HdrInv`, handlerPath: `${handlerRoot}/${process}_HdrInv.main`, roleName: customFlowRoleName(flow.flowTag) }));
+  }
+  if (flow.event.includes('lambdaSyncApi')) {
+    artifacts.push({ path: `${source}/${process}_HdrApi.js`, content: await render('FlowHandler_HdrApi.ejs', shared) });
+    functions.push(renderApiFunctionYaml({ functionName: `${process}HdrApi`, handlerPath: `${handlerRoot}/${process}_HdrApi.main`, roleName: customFlowRoleName(flow.flowTag) }));
+  }
+  if (flow.event.includes('eventBridge')) {
+    artifacts.push({ path: `${source}/${process}_HdrInv.js`, content: await render('FlowHandler_HdrInv.ejs', shared) });
+    functions.push(renderEventBridgeFunctionYaml({ functionName: `${process}HdrInv`, handlerPath: `${handlerRoot}/${process}_HdrInv.main`, roleName: customFlowRoleName(flow.flowTag), flowTag: tag, schedules: flow.schedules ?? [] }));
+  }
+  if (flow.event.includes('ownTopic')) {
+    const root = await emitOwnTopicRoot(flow, objects);
+    artifacts.push(...root.artifacts);
+    functions.push(...root.functions);
+  }
+  if (flow.event.includes('s3')) {
+    const s3Artifacts = await emitS3Flow(flow, source, handlerRoot);
+    artifacts.push(...s3Artifacts.artifacts);
+    functions.push(...s3Artifacts.functions);
+  }
+  return { artifacts, functions };
+}
+
+function flowPaths(flow) {
+  const tag = upperFirst(flow.flowTag);
+  const process = `Process${tag}`;
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  const paths = needsProcessMain(flow) ? [`${source}/${process}_Main.js`] : [];
+  if (flow.event.includes('extTopic')) paths.push(`${source}/${process}_HdrSqs.js`);
+  if (flow.event.includes('lambdaSyncInv') || flow.event.includes('eventBridge')) paths.push(`${source}/${process}_HdrInv.js`);
+  if (flow.event.includes('lambdaSyncApi')) paths.push(`${source}/${process}_HdrApi.js`);
+  if (flow.event.includes('ownTopic')) paths.push(...ownTopicRootPaths(flow));
+  if (flow.event.includes('s3')) {
+    ['ConfirmAfterUpload', 'CreateObject', 'CreatePreSignUrl', 'ProcessAfterUpload', 'ReservedLimit'].forEach(action => {
+      const handler = action === 'CreateObject' ? 'HdrWbs' : action === 'ProcessAfterUpload' ? 'HdrS3' : 'HdrSqs';
+      paths.push(`${source}/${tag}${action}_Main.js`, `${source}/${tag}${action}_${handler}.js`);
+    });
+  }
+  return paths;
+}
+
+async function emitExtTopicStep({ flow, step, flowTag, stepName }) {
+  const source = `app/src/generatedCode/FlowSchemas/${flowTag}/source`;
+  const handlerRoot = `src/generatedCode/FlowSchemas/${flowTag}/source`;
+  const functionName = `${flowTag}${stepName}`;
+  const mainFileName = `${functionName}_Main`;
+  const queueName = `${functionName}HdrSqs`;
+  const startConfig = stepConfig(flow, step);
+  return {
+    artifacts: [
+      { path: `${source}/${mainFileName}.js`, content: await renderStepMain(functionName) },
+      { path: `${source}/${functionName}_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { flowTag: flow.flowTag, flowStepName: step.stepName, functionName, mainFileName, startConfig, queueName }) }
+    ],
+    function: renderSqsFunctionYaml({ functionName: queueName, handlerPath: `${handlerRoot}/${functionName}_HdrSqs.main`, roleName: customFlowRoleName(flow.flowTag), queueName })
+  };
+}
+
+async function emitOwnTopicRoot(flow, objects) {
+  const tag = upperFirst(flow.flowTag);
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  const handlerRoot = `src/generatedCode/FlowSchemas/${tag}/source`;
+  const mainFileName = `${tag}_Main`;
+  const wbsMainFileName = `${tag}_WbsMain`;
+  const shared = { flowTag: flow.flowTag, flowStepName: '', upperCaseFlowTag: tag, startConfig: startConfig(flow) };
+  return {
+    artifacts: [
+      { path: `${source}/${mainFileName}.js`, content: await renderEndpointMain(flow, mainFileName, objects) },
+      { path: `${source}/${tag}_HdrSqs.js`, content: await render('FlowHandler_HdrSqs.ejs', { ...shared, functionName: mainFileName, mainFileName, queueName: `${tag}HdrSqs` }) },
+      { path: `${source}/${wbsMainFileName}.js`, content: await render('FlowMain_Wbs.ejs', { ...shared, functionName: wbsMainFileName }) },
+      { path: `${source}/${tag}_HdrWbs.js`, content: await render('FlowEndpoint_HdrWbs.ejs', { ...shared, functionName: tag, mainFileName: wbsMainFileName, route: tag }) }
+    ],
+    functions: [
+      renderWbsFunctionYaml({ functionName: `${tag}HdrWbs`, handlerPath: `${handlerRoot}/${tag}_HdrWbs.main`, roleName: customFlowRoleName(flow.flowTag), routeName: tag }),
+      renderSqsFunctionYaml({ functionName: `${tag}HdrSqs`, handlerPath: `${handlerRoot}/${tag}_HdrSqs.main`, roleName: customFlowRoleName(flow.flowTag), queueName: `${tag}HdrSqs` })
+    ]
+  };
+}
+
+function ownTopicRootPaths(flow) {
+  const tag = upperFirst(flow.flowTag);
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  return [`${source}/${tag}_Main.js`, `${source}/${tag}_HdrSqs.js`, `${source}/${tag}_WbsMain.js`, `${source}/${tag}_HdrWbs.js`];
+}
+
+function needsProcessMain(flow) {
+  return !isS3Only(flow) && flow.event.some(event => event !== 'ownTopic' && event !== 's3');
+}
+
+async function emitS3Flow(flow, source, handlerRoot) {
+  const tag = upperFirst(flow.flowTag);
+  const roleName = customFlowRoleName(flow.flowTag);
+  const parts = [
+    { action: 'CreateObject', handler: 'HdrWbs', type: 'wbs', mainTemplate: 'CreateObject_Main.ejs', handlerTemplate: 'CreateObject_HdrWbs.ejs' },
+    { action: 'ReservedLimit', handler: 'HdrSqs', type: 'sqs', mainTemplate: 'ReservedLimit_Main.ejs', handlerTemplate: 'ReservedLimit_HdrSqs.ejs' },
+    { action: 'CreatePreSignUrl', handler: 'HdrSqs', type: 'sqs', mainTemplate: 'CreatePreSignUrl_Main.ejs', handlerTemplate: 'CreatePreSignUrl_HdrSqs.ejs' },
+    { action: 'ProcessAfterUpload', handler: 'HdrS3', type: 'inv', mainTemplate: 'ProcessS3File_Main.ejs', handlerTemplate: 'FlowHandler_HdrS3.ejs' },
+    { action: 'ConfirmAfterUpload', handler: 'HdrSqs', type: 'sqs', mainTemplate: 'ConfirmReserved_Main.ejs', handlerTemplate: 'ConfirmReserved_HdrSqs.ejs' }
+  ];
+  const emitted = await Promise.all(parts.map(async ({ action, handler, type, mainTemplate, handlerTemplate }) => {
+    const functionName = `${tag}${action}`;
+    const mainFileName = `${functionName}_Main`;
+    const handlerFileName = `${functionName}_${handler}`;
+    const mainContent = await renderCustom(`s3/${mainTemplate}`, s3TemplateData({ action, flow, functionName }));
+    const handlerContent = await renderCustom(`s3/${handlerTemplate}`, s3HandlerData({ action, flow, functionName, mainFileName, handler }));
+    const descriptor = { functionName: `${functionName}${handler}`, handlerPath: `${handlerRoot}/${handlerFileName}.main`, roleName };
+    const functionYaml = type === 'wbs'
+      ? renderWbsFunctionYaml({ ...descriptor, routeName: tag })
+      : type === 'sqs'
+        ? renderSqsFunctionYaml({ ...descriptor, queueName: handlerFileName })
+        : renderInvFunctionYaml(descriptor);
+    return {
+      artifacts: [
+        { path: `${source}/${mainFileName}.js`, content: mainContent },
+        { path: `${source}/${handlerFileName}.js`, content: handlerContent }
+      ],
+      functionYaml
+    };
+  }));
+  return { artifacts: emitted.flatMap(item => item.artifacts), functions: emitted.map(item => item.functionYaml) };
+}
+
+function s3TemplateData({ action, flow, functionName }) {
+  return action === 'CreateObject'
+    ? { flowTag: flow.flowTag, objectType: flow.objType?.objectType, functionName }
+    : action === 'CreatePreSignUrl'
+      ? { flowTag: flow.flowTag }
+      : { flowTag: flow.flowTag, functionName };
+}
+
+function s3HandlerData({ action, flow, functionName, mainFileName, handler }) {
+  if (action === 'CreateObject') return { functionName, handlerType: handler, route: flow.flowTag };
+  if (action === 'ProcessAfterUpload') return { flowTag: flow.flowTag, functionName, mainFileName, s3Bucket: flow.bucketName ?? '' };
+  return { functionName, handlerType: handler };
+}
+
+function startConfig(flow) {
+  const start = flow.flowSteps?.find(step => step.stepName?.toLowerCase() === 'start');
+  return start ? stepConfig(flow, start) : null;
+}
+
+function stepConfig(flow, step) {
+  return {
+    ...step,
+    properties: mapFields(step.properties, flow.stepProperties),
+    messageAttributes: mapFields(step.messageAttributes, flow.stepMessageAttributes)
+  };
+}
+
+function mapFields(names = [], definitions = {}) {
+  return names.map(name => ({ propertyName: name, ...(definitions?.[name] ?? {}) }));
+}
+
+function isS3Only(flow) {
+  return flow.event.length === 1 && flow.event[0] === 's3';
+}
+
+async function renderEndpointMain(flow, functionName, objects) {
+  return renderCustom('FlowEndpoint_Main.ejs', {
+    flow,
+    flowTag: flow.flowTag,
+    upperCaseFlowTag: upperFirst(flow.flowTag),
+    functionName,
+    tableName: storedCacheTableName(flow, objects)
+  });
+}
+
+function storedCacheTableName(flow, objects) {
+  if (flow.statusType !== 'storedCache') return null;
+  const candidates = objects.filter(object => object.objectType === flow.objType?.objectType);
+  const object = flow.objType?.serviceTag
+    ? candidates.find(object => object.serviceTag === flow.objType.serviceTag) ?? candidates.find(object => object.serviceTag === undefined)
+    : candidates[0];
+  return Object.values(object?.storageResources ?? {}).find(resource => resource?.storageType === 'dynamoDB')?.tableName ?? null;
+}
+
+async function renderStepMain(functionName) {
+  return renderCustom('FlowStep_Main.ejs', { functionName });
+}
+
+function renderMain(functionName) {
+  return `export default async function ${functionName}(_izContext, requestParams, callingFlowConfig = {}) {\n  try {\n    _izContext?.logger?.debug('${functionName} requestParams', requestParams);\n    //(<endpointHook>)\n    //(</endpointHook>)\n  } catch (error) {\n    _izContext?.logger?.error('${functionName} failed', error);\n    throw error;\n  }\n}\n`;
+}
+
+async function render(templateName, data) {
+  return ejs.render(await readFile(new URL(templateName, TEMPLATE_URL), 'utf8'), data);
+}
+
+async function renderDsq(templateName, data) {
+  return ejs.render(await readFile(new URL(templateName, DSQ_TEMPLATE_URL), 'utf8'), data);
+}
+
+async function renderCustom(templateName, data) {
+  return ejs.render(await readFile(new URL(templateName, CUSTOM_TEMPLATE_URL), 'utf8'), data).replace(/\n$/, '');
+}

package/src/emit/custom/generateCustomFlowApplicationArtifacts.js

@@ -0,0 +1,22 @@
+import { buildGenerationPlan } from '../../plan/buildGenerationPlan.js';
+import { commitArtifacts } from '../../output/commitArtifacts.js';
+import { compileProject } from '../../compile/compileProject.js';
+import { loadLocalSchemaDirectory } from '../../compile/loadSchemas.js';
+import { customFlowApplicationManagedPaths, emitCustomFlowApplicationArtifacts } from './emitCustomFlowApplicationArtifacts.js';
+import { emitSystemWebSocketArtifacts, hasSystemWebSocket, systemWebSocketManagedPaths } from '../system/emitSystemWebSocketArtifacts.js';
+
+export async function generateCustomFlowApplicationArtifacts(rootPath, options = {}) {
+  const project = compileProject({ ...options, rootPath });
+  const [flows, objects] = await Promise.all([
+    loadLocalSchemaDirectory(project, 'FlowSchemas'),
+    loadLocalSchemaDirectory(project, 'ObjectSchemas')
+  ]);
+  const system = await emitSystemWebSocketArtifacts(flows);
+  const custom = await emitCustomFlowApplicationArtifacts(flows, { systemFunctions: system.functions, objects });
+  const artifacts = [...system.artifacts, ...custom];
+  const files = await commitArtifacts(buildGenerationPlan(project, artifacts, {
+    managedPaths: [...systemWebSocketManagedPaths(), ...customFlowApplicationManagedPaths(flows, { includeYaml: hasSystemWebSocket(flows) })],
+    managedScope: 'custom-flow-application'
+  }));
+  return { project, files };
+}

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

@@ -136,4 +136,4 @@ export default async function <%- typeof functionName !== 'undefined' ? function
     _izContext.logger.error('error WebSocketInvoke: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/step → emit/custom/templates}/FlowStep_Main.ejs

@@ -57,4 +57,4 @@ export default async function <%= functionName %>(
     _izContext.logger.error('error <%= functionName %>Main: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas → emit/custom}/templates/s3/ConfirmReserved_Main.ejs

@@ -20,8 +20,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 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 as generateCodeConsts } from '@izara_project/izara-core-generate-service-code';
-import { getNestObject } from '../../../../libs/source/GenerateCodeLibs.js';
+import { consts as schemaConsts } from '@izara_project/izara-core-library-service-schemas';
+import { getNestObject } from '../../../libs/source/GenerateCodeLibs.js';
 
 //(<optionalRequired>)
 //(</optionalRequired>)
@@ -73,14 +73,14 @@ export default async function confirmNewReserved(
     let confirmUsageMessage = {
       userId: userId,
       //(<optionalLimitTag>)
-      limitTag: consts.LIMIT_TAG.uploadData,
+      limitTag: schemaConsts.LIMIT_TAG.uploadData,
       //(</optionalLimitTag>)
       uniqueIdentify: uniqueIdentify,
     }
 
     let sendMessageToConfirmUsage = {
       Message: JSON.stringify(confirmUsageMessage),
-      TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, 'ConfirmUsage_In', consts.EXTERNAL_SERVICE_NAME.accountLimits)
+      TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, 'ConfirmUsage_In', schemaConsts.EXTERNAL_SERVICE_NAME.accountLimits)
     };
     _izContext.logger.debug("sendMessageToConfirmUsage", sendMessageToConfirmUsage);
     await sns.publishAsync(_izContext, sendMessageToConfirmUsage);
@@ -126,4 +126,4 @@ export default async function confirmNewReserved(
     _izContext.logger.debug('error ConfirmNewReservedMain: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas → emit/custom}/templates/s3/CreateObject_HdrWbs.ejs

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

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas → emit/custom}/templates/s3/CreateObject_Main.ejs

@@ -29,8 +29,8 @@ import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
 import { sns } from '@izara_project/izara-core-library-external-request';
 
 import { NoRetryError } from '@izara_project/izara-core-library-core';
-import { consts as generateCodeConsts } from '@izara_project/izara-core-generate-service-code';
-const { TOPIC_NAME_GENERATE_CODE } = generateCodeConsts;
+import { consts as schemaConsts } from '@izara_project/izara-core-library-service-schemas';
+const { TOPIC_NAME_GENERATE_CODE } = schemaConsts;
 
 //(<optionalRequired>)
 //(</optionalRequired>)
@@ -128,4 +128,4 @@ export default async function createObject(
     _izContext.logger.error('error WebSocketInvoke: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas → emit/custom}/templates/s3/CreatePreSignUrl_Main.ejs

@@ -29,11 +29,10 @@ import { createPresignedPost } from '@aws-sdk/s3-presigned-post';
 const client = new S3Client({ region: process.env.AWS_REGION });
 import { consts } from '@izara_project/izara-middleware';
 
-import { postToConnection, getNestObject } from '../../../../libs/source/GenerateCodeLibs.js'
+import { postToConnection, getNestObject } from '../../../libs/source/GenerateCodeLibs.js'
 import { consts as coreConsts } from '@izara_project/izara-core-library-core';
-import { consts as generateCodeConsts } from '@izara_project/izara-core-generate-service-code';
-const { EXTERNAL_SERVICE_NAME } = generateCodeConsts;
-import { utils } from "@izara_project/izara-core-library-service-schemas"
+import { consts as schemaConsts, utils } from "@izara_project/izara-core-library-service-schemas"
+const { EXTERNAL_SERVICE_NAME } = schemaConsts;
 const { createFlowTypeConcat } = utils
 //(<optionalRequired>)
 //(</optionalRequired>)
@@ -259,4 +258,4 @@ export default async function createPreSignUrl (
     _izContext.logger.error('error createPreSignUrl: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas → emit/custom}/templates/s3/FlowHandler_HdrS3.ejs

@@ -41,16 +41,10 @@ export const main = middleware.wrap(async (event, context) => {
 
     const s3Record = event.Records[0].s3;
 
-    // Pack the S3 trigger payload into requestParams so the main function
-    // can decide what to do (download file, publish to SNS, invoke Lambda, etc.)
-    const requestParams = {
-      bucket: s3Record.bucket,
-      object: s3Record.object,
-    };
-
     const result = await <%- functionName %>(
       event._izContext,
-      requestParams,
+      s3Record.bucket,
+      s3Record.object,
       //(<additionalParams>)
       //(</additionalParams>)
     );

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas → emit/custom}/templates/s3/ProcessS3File_Main.ejs

@@ -63,4 +63,4 @@ export default async function processAfterUpload (
     _izContext.logger.error('error ProcessImageAfterUploadMain: ', err)
     throw (err)
   }
-}
+}

package/src/{codeGenerators/app/src/generatedCode/Flow/FlowSchemas → emit/custom}/templates/s3/ReservedLimit_Main.ejs

@@ -22,12 +22,11 @@ import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
 import snsSharedLib from '@izara_project/izara-core-library-sns';
 import asyncFlowSharedLib from "@izara_project/izara-core-library-asynchronous-flow";
 import { sns, webSocket } from '@izara_project/izara-core-library-external-request';
-import { consts as generateCodeConsts } from '@izara_project/izara-core-generate-service-code';
 import { consts as coreConsts } from '@izara_project/izara-middleware';
 import { objectHash as hash } from '@izara_project/izara-shared-core';
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
-import { processStaticLimit } from '../../../../libs/source/GenerateCodeLibs.js';
-import { utils } from "@izara_project/izara-core-library-service-schemas";
+import { processStaticLimit } from '../../../libs/source/GenerateCodeLibs.js';
+import { consts as schemaConsts, utils } from "@izara_project/izara-core-library-service-schemas";
 const { createFlowTypeConcat } = utils
 const { postToConnection } = webSocket;
 
@@ -77,7 +76,7 @@ export default async function reservedLimit(
     }
 
     let res = await processStaticLimit(_izContext,
-      await lambdaSharedLib.lambdaFunctionName(_izContext, "StaticLimitProcessHdrInv", consts.EXTERNAL_SERVICE_NAME.accountLimits),
+      await lambdaSharedLib.lambdaFunctionName(_izContext, "StaticLimitProcessHdrInv", schemaConsts.EXTERNAL_SERVICE_NAME.accountLimits),
       payloadBeforeInvokeStaticLimit
     )
 
@@ -157,7 +156,7 @@ export default async function reservedLimit(
 
     let sendMessageToReservedDynamic = {
       Message: JSON.stringify(sendMsgReservedDynamic),
-      TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, "ReservedDynamicUsage_In", consts.EXTERNAL_SERVICE_NAME.accountLimits)
+      TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, "ReservedDynamicUsage_In", schemaConsts.EXTERNAL_SERVICE_NAME.accountLimits)
     };
     _izContext.logger.debug("sendMessageToReservedDynamic", sendMessageToReservedDynamic);
     await sns.publishAsync(_izContext, sendMessageToReservedDynamic);
@@ -170,4 +169,4 @@ export default async function reservedLimit(
     _izContext.logger.error('error GetSignedUrlAccountLimit: ', err);
     throw (err)
   }
-}
+}

package/src/emit/custom/templates/triggerCache/CheckTriggerCache_HdrSqs.ejs

@@ -0,0 +1,32 @@
+import { middlewareHandler as middleware } from '@izara_project/izara-middleware';
+import Logger from '@izara_project/izara-core-library-logger';
+import { recordHandlerSharedLib } from '@izara_project/izara-core-library-record-handler';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+
+import <%- functionName %> from './<%- functionName %>_Main.js';
+
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+
+export const main = middleware.wrap(async event => {
+  try {
+    const recordPromises = [];
+    await Promise.all(event.Records.map(async record => {
+      await recordHandlerSharedLib.validateRecord(record, '<%- queueName %>', {}, null);
+      recordPromises.push(recordHandlerSharedLib.recordHandler(
+        record,
+        <%- functionName %>,
+        '<%- queueName %>',
+        [
+          record.body.Message.identifiers,
+          record.body.TopicArn,
+          callingFlowSharedLib.addCallingFlowToPassOnProperties(record.body.Message)
+        ]
+      ));
+    }));
+    await Promise.all(recordPromises);
+    return event.Records;
+  } catch (error) {
+    Logger.error('Unhandled Error, CheckTriggerCache_HdrSqs: ', error);
+    throw error;
+  }
+});

package/src/emit/custom/templates/triggerCache/CheckTriggerCache_Main.ejs

@@ -0,0 +1,63 @@
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import { triggeredCacheSharedLibV2 } from '@izara_project/izara-core-library-trigger-cache';
+
+export default async function <%- functionName %>(
+  _izContext,
+  requestParams,
+  topicArn,
+  callingFlowConfig = {}
+) {
+  try {
+    _izContext.logger.debug(
+      '<%- functionName %> requestParams',
+      requestParams
+    );
+    _izContext.logger.debug(
+      '<%- functionName %> topicArn',
+      topicArn
+    );
+    _izContext.logger.debug(
+      '<%- functionName %> callingFlowConfig',
+      callingFlowConfig
+    );
+
+    const topicName = topicArn.split(':')[5].split('_');
+    const flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(
+      _izContext,
+      {
+        flowTag: topicName[2],
+        serviceTag: topicName[0]
+      }
+    );
+
+    //(<checkTriggerCacheIdentifiers>)
+    let identifiers;
+    //(</checkTriggerCacheIdentifiers>)
+
+    const checkTriggerCache =
+      await triggeredCacheSharedLibV2.checkTriggerFlowCompleteAwaitingStepV2(
+        _izContext,
+        { serviceTag: topicName[0], flowTag: topicName[2] },
+        identifiers,
+        { flowTag: '<%- flowTag %>', serviceTag: process.env.iz_serviceTag }
+      );
+
+    _izContext.logger.debug(
+      '<%- functionName %> flowSchema',
+      flowSchema
+    );
+    _izContext.logger.debug(
+      '<%- functionName %> checkTriggerCache',
+      checkTriggerCache
+    );
+
+    //(<endpointHook>)
+    //(</endpointHook>)
+  } catch (error) {
+    _izContext.logger.error(
+      '<%- functionName %> failed',
+      error
+    );
+    throw error;
+  }
+}

package/src/emit/custom/templates/triggerCache/TriggerCacheComplete_Main.ejs

@@ -0,0 +1,35 @@
+import { triggeredCacheSharedLibV2 } from '@izara_project/izara-core-library-trigger-cache';
+
+export default async function <%- functionName %>(
+  _izContext,
+  requestParams,
+  callingFlowConfig = {}
+) {
+  try {
+    _izContext.logger.debug('<%- functionName %> requestParams', requestParams);
+    _izContext.logger.debug('<%- functionName %> callingFlowConfig', callingFlowConfig);
+
+    //(<beforeCheckTriggeredCache>)
+    //(</beforeCheckTriggeredCache>)
+
+    const checkTriggerResetedV2 = await triggeredCacheSharedLibV2.checkTriggerResetedV2(
+      _izContext,
+      { serviceTag: process.env.iz_serviceTag, flowTag: '<%- flowTag %>' },
+      //(<identifiers>)
+      {},
+      //(</identifiers>)
+      //(<uniqueRequestId>)
+      //(</uniqueRequestId>)
+      //(<settings>)
+      //(</settings>)
+    );
+
+    _izContext.logger.debug('<%- functionName %> checkTriggerResetedV2', checkTriggerResetedV2);
+
+    //(<endpointHook>)
+    //(</endpointHook>)
+  } catch (error) {
+    _izContext.logger.error('<%- functionName %> failed', error);
+    throw error;
+  }
+}

package/src/emit/custom/templates/triggerCache/TriggerCache_Main.ejs

@@ -0,0 +1,16 @@
+export default async function <%- functionName %>(
+  _izContext,
+  requestParams,
+  callingFlowConfig = {}
+) {
+  try {
+    _izContext.logger.debug('<%- functionName %> requestParams', requestParams);
+    _izContext.logger.debug('<%- functionName %> callingFlowConfig', callingFlowConfig);
+
+    //(<endpointHook>)
+    //(</endpointHook>)
+  } catch (error) {
+    _izContext.logger.error('<%- functionName %> failed', error);
+    throw error;
+  }
+}