@izara_project/izara-core-generate-service-code 1.0.90 → 1.0.92

package/src/emit/custom/customFlowS3.js

@@ -0,0 +1,156 @@
+import { renderCustom } from './customFlowTemplates.js';
+import { customFlowRoleName, upperFirst } from './customFlows.js';
+import {
+  renderInvFunctionYaml,
+  renderS3FunctionYaml,
+  renderSqsFunctionYaml,
+  renderWbsFunctionYaml
+} from '../function/functionYamlArtifact.js';
+
+export 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: 's3',
+      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
+        };
+        let functionYaml;
+        if (type === 'wbs') {
+          functionYaml = renderWbsFunctionYaml({
+            ...descriptor,
+            routeName: tag,
+            flowTag: flow.flowTag,
+            flowStepName: ''
+          });
+        } else if (type === 'sqs') {
+          let filterPatternFunctionName = descriptor.functionName;
+          if (action === 'CreatePreSignUrl') {
+            filterPatternFunctionName = 'CreatePresignUrlHdrSqs';
+          }
+          functionYaml = renderSqsFunctionYaml({
+            ...descriptor,
+            queueName: descriptor.functionName,
+            flowTag: flow.flowTag,
+            flowStepName: '',
+            filterPatternFunctionName
+          });
+        } else if (type === 's3') {
+          let bucketName = '';
+          if (flow.bucketName) {
+            bucketName = flow.bucketName;
+          }
+          functionYaml = renderS3FunctionYaml({
+            ...descriptor,
+            bucketName,
+            flowTag: flow.flowTag,
+            flowStepName: ''
+          });
+        } else {
+          functionYaml = renderInvFunctionYaml({
+            ...descriptor,
+            flowTag: flow.flowTag,
+            flowStepName: ''
+          });
+        }
+        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 }) {
+  if (action === 'CreateObject') {
+    return {
+      flowTag: flow.flowTag,
+      objectType: flow.objType?.objectType,
+      functionName
+    };
+  }
+  if (action === 'CreatePreSignUrl') {
+    return { flowTag: flow.flowTag };
+  }
+  return { flowTag: flow.flowTag, functionName };
+}
+
+function _s3HandlerData({ action, flow, functionName, mainFileName, handler }) {
+  if (action === 'CreateObject') {
+    return { functionName, handlerType: handler, route: flow.flowTag };
+  }
+  if (action === 'ProcessAfterUpload') {
+    let bucketName = '';
+    if (flow.bucketName) {
+      bucketName = flow.bucketName;
+    }
+    return {
+      flowTag: flow.flowTag,
+      functionName,
+      mainFileName,
+      s3Bucket: bucketName
+    };
+  }
+  return { functionName, handlerType: handler };
+}

package/src/emit/custom/customFlowSteps.js

@@ -0,0 +1,385 @@
+import {
+  renderCrudTemplate,
+  renderCustom,
+  renderDsq,
+  renderShared
+} from './customFlowTemplates.js';
+import { customFlowRoleName, upperFirst, flowHasRbac } from './customFlows.js';
+import {
+  renderSqsFunctionYaml,
+  renderWbsFunctionYaml
+} from '../function/functionYamlArtifact.js';
+
+export async function emitExtTopicStep({ flow, step, flowTag, stepName }) {
+  const source = `app/src/generatedCode/FlowSchemas/${flowTag}/source`;
+  const handlerRoot = `src/generatedCode/FlowSchemas/${flowTag}/source`;
+  let functionName = `${flowTag}${stepName}`;
+  if (stepName.startsWith(flowTag)) {
+    functionName = stepName;
+  }
+  const mainFileName = `${functionName}_Main`;
+  const startConfig = stepConfig(flow, step);
+
+  const hasTriggerFlowTypes =
+    Array.isArray(flow.triggerFlowTypes) && flow.triggerFlowTypes.length > 0;
+  const isCheckStep = stepName.toLowerCase().includes('checktrigger');
+
+  if (isCheckStep && hasTriggerFlowTypes) {
+    const queueName = `${functionName}HdrSqs`;
+    return {
+      artifacts: [
+        {
+          path: `${source}/${mainFileName}.js`,
+          content: await renderCustom(
+            'triggerCache/CheckTriggerCache_Main.ejs',
+            { functionName, flowTag }
+          )
+        },
+        {
+          path: `${source}/${functionName}_HdrSqs.js`,
+          content: await renderCustom(
+            'triggerCache/CheckTriggerCache_HdrSqs.ejs',
+            { functionName, queueName, startConfig }
+          )
+        }
+      ],
+      functions: [
+        renderSqsFunctionYaml({
+          functionName: queueName,
+          handlerPath: `${handlerRoot}/${functionName}_HdrSqs.main`,
+          roleName: customFlowRoleName(flow.flowTag),
+          queueName,
+          flowTag,
+          flowStepName: step.stepName
+        })
+      ]
+    };
+  }
+
+  const artifacts = [
+    {
+      path: `${source}/${mainFileName}.js`,
+      content: await renderStepMain(functionName, _startConfig(flow))
+    }
+  ];
+  const functions = [];
+
+  let stepEvents = [];
+  if (Array.isArray(step.event)) {
+    stepEvents = step.event;
+  }
+  const hasSqs = stepEvents.includes('extTopic') || stepEvents.includes('sqs');
+
+  if (hasSqs) {
+    const queueName = `${functionName}HdrSqs`;
+    artifacts.push({
+      path: `${source}/${functionName}_HdrSqs.js`,
+      content: await renderShared('FlowHandler_HdrSqs.ejs', {
+        flowTag: flow.flowTag,
+        flowStepName: step.stepName,
+        functionName,
+        mainFileName,
+        startConfig,
+        queueName
+      })
+    });
+    functions.push(
+      renderSqsFunctionYaml({
+        functionName: queueName,
+        handlerPath: `${handlerRoot}/${functionName}_HdrSqs.main`,
+        roleName: customFlowRoleName(flow.flowTag),
+        queueName,
+        flowTag,
+        flowStepName: step.stepName
+      })
+    );
+  }
+
+  return { artifacts, functions };
+}
+
+export async function emitDsqStep({ 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 startConfig = stepConfig(flow, step);
+
+  let stepEvents = [];
+  if (Array.isArray(step.event)) {
+    stepEvents = step.event;
+  }
+  const artifacts = [];
+  if (!stepEvents.includes('extTopic')) {
+    artifacts.push({
+      path: `${source}/${mainFileName}.js`,
+      content: await renderStepMain(functionName, startConfig)
+    });
+  }
+  const functions = [];
+
+  const hasDsq = stepEvents.includes('dsq');
+
+  if (hasDsq) {
+    const queueName = `${functionName}HdrDsq`;
+    artifacts.push({
+      path: `${source}/${functionName}_HdrDsq.js`,
+      content: await renderDsq('FlowHandler_HdrDsq.ejs', {
+        flowTag: flow.flowTag,
+        flowStepName: step.stepName,
+        functionName,
+        mainFileName,
+        startConfig,
+        queueName
+      })
+    });
+    functions.push(
+      renderSqsFunctionYaml({
+        functionName: queueName,
+        handlerPath: `${handlerRoot}/${functionName}_HdrDsq.main`,
+        roleName: customFlowRoleName(flow.flowTag),
+        queueName,
+        flowTag,
+        flowStepName: step.stepName
+      })
+    );
+  }
+
+  return { artifacts, functions };
+}
+
+export 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)
+  };
+  const isRbac = flowHasRbac(flow, objects);
+  const ownArtifacts = [
+    {
+      path: `${source}/${mainFileName}.js`,
+      content: await renderEndpointMain(flow, mainFileName, objects)
+    },
+    {
+      path: `${source}/${tag}_HdrSqs.js`,
+      content: await renderShared('FlowHandler_HdrSqs.ejs', {
+        ...shared,
+        functionName: mainFileName,
+        mainFileName,
+        queueName: `${tag}HdrSqs`
+      })
+    },
+    {
+      path: `${source}/${wbsMainFileName}.js`,
+      content: await renderCrudTemplate('FlowMain_Wbs.ejs', {
+        ...shared,
+        functionName: wbsMainFileName
+      })
+    },
+    {
+      path: `${source}/${tag}_HdrWbs.js`,
+      content: await renderCrudTemplate('FlowEndpoint_HdrWbs.ejs', {
+        ...shared,
+        functionName: tag,
+        mainFileName: wbsMainFileName,
+        route: tag
+      })
+    }
+  ];
+
+  const ownFunctions = [
+    renderWbsFunctionYaml({
+      functionName: `${tag}HdrWbs`,
+      handlerPath: `${handlerRoot}/${tag}_HdrWbs.main`,
+      roleName: customFlowRoleName(flow.flowTag),
+      routeName: tag,
+      flowTag: flow.flowTag,
+      flowStepName: ''
+    }),
+    renderSqsFunctionYaml({
+      functionName: `${tag}HdrSqs`,
+      handlerPath: `${handlerRoot}/${tag}_HdrSqs.main`,
+      roleName: customFlowRoleName(flow.flowTag),
+      queueName: `${tag}HdrSqs`,
+      flowTag: flow.flowTag,
+      flowStepName: ''
+    })
+  ];
+
+  if (isRbac) {
+    const rbacStep = (flow.flowSteps || []).find(
+      (s) =>
+        typeof s?.stepName === 'string' &&
+        s.stepName.toLowerCase() === 'rbaccallback'
+    );
+    const rbacConfig = rbacStep ? stepConfig(flow, rbacStep) : null;
+    ownArtifacts.push(
+      {
+        path: `${source}/${tag}RbacCallback_Main.js`,
+        content: await renderCustom('FlowEndpointRbacCallback_Main.ejs', {
+          flowTag: flow.flowTag,
+          upperCaseFlowTag: tag,
+          functionName: `${tag}RbacCallbackMain`
+        })
+      },
+      {
+        path: `${source}/${tag}RbacCallback_HdrSqs.js`,
+        content: await renderShared('FlowHandler_HdrSqs.ejs', {
+          flowTag: flow.flowTag,
+          flowStepName: 'RbacCallback',
+          mainFileName: `${tag}RbacCallback_Main`,
+          functionName: `${tag}RbacCallbackMain`,
+          queueName: `${tag}RbacCallbackHdrSqs`,
+          startConfig: rbacConfig
+        })
+      }
+    );
+    ownFunctions.push(
+      renderSqsFunctionYaml({
+        functionName: `${tag}RbacCallbackHdrSqs`,
+        handlerPath: `${handlerRoot}/${tag}RbacCallback_HdrSqs.main`,
+        roleName: customFlowRoleName(flow.flowTag),
+        queueName: `${tag}RbacCallbackHdrSqs`,
+        flowTag: flow.flowTag,
+        flowStepName: 'RbacCallback'
+      })
+    );
+  }
+
+  return {
+    artifacts: ownArtifacts,
+    functions: ownFunctions
+  };
+}
+
+export function _startConfig(flow) {
+  const steps = flow.flowSteps ?? [];
+  const start =
+    steps.find(
+      (s) =>
+        typeof s?.stepName === 'string' &&
+        s.stepName.toLowerCase() === 'inprocess'
+    ) ??
+    steps.find(
+      (s) =>
+        typeof s?.stepName === 'string' && s.stepName.toLowerCase() === 'start'
+    ) ??
+    steps[0];
+  if (start) {
+    return stepConfig(flow, start);
+  }
+  return null;
+}
+
+export function stepConfig(flow, step) {
+  return {
+    ...step,
+    properties: mapFields(step.properties, flow.stepProperties),
+    messageAttributes: mapFields(
+      step.messageAttributes,
+      flow.stepMessageAttributes
+    )
+  };
+}
+
+export function mapFields(items = [], definitions = {}) {
+  return items.map((item) => {
+    if (typeof item === 'string') {
+      const def = definitions?.[item] ?? {};
+      return {
+        propertyName: item,
+        required: def.required ?? false,
+        ...def
+      };
+    }
+    if (typeof item === 'object' && item !== null) {
+      const name = item.key ?? item.propertyName;
+      const def = definitions?.[name] ?? {};
+      return {
+        propertyName: name,
+        required: item.required ?? def.required ?? false,
+        ...def,
+        ...item
+      };
+    }
+    return item;
+  });
+}
+
+export async function renderEndpointMain(flow, functionName, objects = []) {
+  const isRbac = flowHasRbac(flow, objects);
+  const matchedObject = objects.find(
+    (o) => o.objectType === flow.objType?.objectType
+  );
+  let rbacServiceTag = null;
+  if (matchedObject) {
+    const belongTo = matchedObject.belongTo;
+    if (belongTo) {
+      if (Array.isArray(belongTo)) {
+        rbacServiceTag = belongTo[0]?.serviceTag;
+      } else {
+        rbacServiceTag = belongTo?.serviceTag;
+      }
+    }
+  }
+  if (!rbacServiceTag) {
+    rbacServiceTag = flow.objType?.serviceTag || flow.serviceTag || 'Rbac';
+  }
+
+  const enrichedFlow = {
+    ...flow,
+    isRbac
+  };
+
+  return renderCustom('FlowEndpoint_Main.ejs', {
+    flow: enrichedFlow,
+    flowTag: flow.flowTag,
+    upperCaseFlowTag: upperFirst(flow.flowTag),
+    functionName,
+    rbacServiceTag,
+    tableName: storedCacheTableName(flow, objects),
+    startConfig: _startConfig(flow)
+  });
+}
+
+export function storedCacheTableName(flow, objects) {
+  if (flow.statusType !== 'storedCache') {
+    return null;
+  }
+  const candidates = objects.filter(
+    (object) => object.objectType === flow.objType?.objectType
+  );
+  let object;
+  if (flow.objType?.serviceTag) {
+    object =
+      candidates.find(
+        (candidate) => candidate.serviceTag === flow.objType.serviceTag
+      ) ?? candidates.find((candidate) => candidate.serviceTag === undefined);
+  } else {
+    object = candidates[0];
+  }
+  const targetResource = Object.values(object?.storageResources ?? {}).find(
+    (resource) =>
+      resource?.storageType === 'dynamo' ||
+      resource?.storageType === 'dynamoDB' ||
+      !resource?.storageType
+  );
+  if (targetResource?.tableName) {
+    return targetResource.tableName;
+  }
+  return null;
+}
+
+export async function renderStepMain(functionName, startConfig = null) {
+  return renderCustom('FlowStep_Main.ejs', { functionName, startConfig });
+}
+
+export 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`;
+}

package/src/emit/custom/customFlowTemplates.js

@@ -0,0 +1,28 @@
+import ejsLib from 'ejs';
+import { readFile } from 'node:fs/promises';
+
+const SHARED_TEMPLATE_URL = new URL('../shared/templates/', import.meta.url);
+const CRUD_TEMPLATE_URL = new URL('../crud/templates/', import.meta.url);
+const CUSTOM_TEMPLATE_URL = new URL('./templates/', import.meta.url);
+
+export async function renderShared(templateName, data) {
+  const templatePath = new URL(templateName, SHARED_TEMPLATE_URL);
+  const templateContent = await readFile(templatePath, 'utf8');
+  return ejsLib.render(templateContent, data);
+}
+
+export async function renderCrudTemplate(templateName, data) {
+  const templatePath = new URL(templateName, CRUD_TEMPLATE_URL);
+  const templateContent = await readFile(templatePath, 'utf8');
+  return ejsLib.render(templateContent, data);
+}
+
+export async function renderDsq(templateName, data) {
+  return renderShared(templateName, data);
+}
+
+export async function renderCustom(templateName, data) {
+  const templatePath = new URL(templateName, CUSTOM_TEMPLATE_URL);
+  const templateContent = await readFile(templatePath, 'utf8');
+  return ejsLib.render(templateContent, data).replace(/\n$/, '');
+}

package/src/emit/custom/customFlows.js

@@ -5,23 +5,51 @@ const SUPPORTED_EVENTS = new Set([
   'lambdaSyncApi',
   'ownTopic',
   's3',
-  'dsq'
+  'dsq',
+  'generateCode'
 ]);
 
 export function supportedCustomFlows(flows) {
   if (!Array.isArray(flows)) {
     throw new TypeError('flows must be an array');
   }
-  return flows.filter(
-    (flow) =>
-      typeof flow?.flowTag === 'string' &&
-      flow.flowTag !== '' &&
-      (!flow.generatedCodeConfig ||
-        (flow.generatedCodeConfig.codeHookTag &&
-          !flow.event.includes('ownTopic'))) &&
-      Array.isArray(flow.event) &&
-      flow.event.some((event) => SUPPORTED_EVENTS.has(event))
-  );
+  return flows.filter((flow) => {
+    if (typeof flow?.flowTag !== 'string' || flow.flowTag === '') {
+      return false;
+    }
+    if (!Array.isArray(flow.event)) {
+      return false;
+    }
+    const hasSupportedEvent = flow.event.some((e) => SUPPORTED_EVENTS.has(e));
+    if (!hasSupportedEvent) {
+      return false;
+    }
+    if (flow.generatedCodeConfig) {
+      if (flowHasOwnTopic(flow)) {
+        return false;
+      }
+      if (!flow.generatedCodeConfig.codeHookTag) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+
+export function flowHasOwnTopic(flow) {
+  if (!Array.isArray(flow?.event)) {
+    return false;
+  }
+  if (flow.event.includes('ownTopic')) {
+    return true;
+  }
+  if (
+    flow.event.includes('generateCode') &&
+    flow?.generatedCodeConfig?.invocationType === 'ownTopic'
+  ) {
+    return true;
+  }
+  return false;
 }
 
 export function customFlowRoleName(flowTag) {
@@ -116,14 +144,15 @@ export function generatedOwnTopicFlows(flows) {
   if (!Array.isArray(flows)) {
     throw new TypeError('flows must be an array');
   }
-  return flows.filter(
-    (flow) =>
-      typeof flow?.flowTag === 'string' &&
-      flow.flowTag !== '' &&
-      flow.generatedCodeConfig &&
-      Array.isArray(flow.event) &&
-      flow.event.includes('ownTopic')
-  );
+  return flows.filter((flow) => {
+    if (typeof flow?.flowTag !== 'string' || flow.flowTag === '') {
+      return false;
+    }
+    if (!flow.generatedCodeConfig) {
+      return false;
+    }
+    return flowHasOwnTopic(flow);
+  });
 }
 
 export function generatedDsqFlows(flows) {