@izara_project/izara-core-generate-service-code 1.0.91 → 1.0.93

package/src/emit/custom/customFlowPaths.js

@@ -0,0 +1,149 @@
+import {
+  flowDsqSteps,
+  flowExtTopicSteps,
+  generatedDsqFlows,
+  generatedOwnTopicFlows,
+  supportedCustomFlows,
+  upperFirst,
+  flowHasRbac
+} from './customFlows.js';
+
+export const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-schema.yml';
+
+export function isS3Only(flow) {
+  return flow.event.length === 1 && flow.event[0] === 's3';
+}
+
+export function needsProcessMain(flow) {
+  const isOwnTopicTransport =
+    flow.event.includes('ownTopic') ||
+    (flow.event.includes('generateCode') &&
+      flow.generatedCodeConfig?.invocationType === 'ownTopic');
+  return (
+    !isS3Only(flow) &&
+    !isOwnTopicTransport &&
+    flow.event.some((event) => event !== 'ownTopic' && event !== 's3')
+  );
+}
+
+export function ownTopicRootPaths(flow, objects = []) {
+  const tag = upperFirst(flow.flowTag);
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  const paths = [
+    `${source}/${tag}_Main.js`,
+    `${source}/${tag}_HdrSqs.js`,
+    `${source}/${tag}_WbsMain.js`,
+    `${source}/${tag}_HdrWbs.js`
+  ];
+  if (flowHasRbac(flow, objects)) {
+    paths.push(
+      `${source}/${tag}RbacCallback_Main.js`,
+      `${source}/${tag}RbacCallback_HdrSqs.js`
+    );
+  }
+  return paths;
+}
+
+export function flowPaths(flow, objects = []) {
+  const tag = upperFirst(flow.flowTag);
+  const process = tag;
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  const paths = [];
+  if (needsProcessMain(flow)) {
+    paths.push(`${source}/${process}_Main.js`);
+  }
+  if (flowHasRbac(flow, objects)) {
+    paths.push(
+      `${source}/${tag}RbacCallback_Main.js`,
+      `${source}/${tag}RbacCallback_HdrSqs.js`
+    );
+  }
+  if (flow.event.includes('extTopic') && !flow.event.includes('ownTopic')) {
+    paths.push(`${source}/${process}_HdrSqs.js`);
+  }
+  if (flow.event.includes('dsq')) {
+    paths.push(`${source}/${process}_HdrDsq.js`);
+  }
+  if (
+    flow.event.includes('lambdaSyncInv') ||
+    flow.event.includes('eventBridge') ||
+    (flow.event.includes('generateCode') &&
+      flow.generatedCodeConfig?.invocationType === 'lambdaSyncInv')
+  ) {
+    paths.push(`${source}/${process}_HdrInv.js`);
+  }
+  if (flow.event.includes('lambdaSyncApi')) {
+    paths.push(`${source}/${process}_HdrApi.js`);
+  }
+  if (
+    flow.event.includes('ownTopic') ||
+    (flow.event.includes('generateCode') &&
+      flow.generatedCodeConfig?.invocationType === 'ownTopic')
+  ) {
+    paths.push(...ownTopicRootPaths(flow, objects));
+  }
+  if (flow.event.includes('s3')) {
+    const s3Actions = [
+      'ConfirmAfterUpload',
+      'CreateObject',
+      'CreatePreSignUrl',
+      'ProcessAfterUpload',
+      'ReservedLimit'
+    ];
+    for (const action of s3Actions) {
+      let handler = 'HdrSqs';
+      if (action === 'CreateObject') {
+        handler = 'HdrWbs';
+      } else if (action === 'ProcessAfterUpload') {
+        handler = 'HdrS3';
+      }
+      paths.push(
+        `${source}/${tag}${action}_Main.js`,
+        `${source}/${tag}${action}_${handler}.js`
+      );
+    }
+  }
+  return paths;
+}
+
+export function customFlowApplicationManagedPaths(
+  flows,
+  { objects = [] } = {}
+) {
+  const customFlowList = supportedCustomFlows(flows);
+  const generatedRoots = generatedOwnTopicFlows(flows);
+  const generatedDsqs = generatedDsqFlows(flows);
+  const extSteps = flowExtTopicSteps(flows);
+  const dsqSteps = flowDsqSteps(flows);
+
+  return [
+    ...customFlowList.flatMap((flow) => flowPaths(flow, objects)),
+    ...generatedRoots.flatMap((flow) => ownTopicRootPaths(flow, objects)),
+    ...extSteps.flatMap(({ flowTag, stepName }) => {
+      const source = `app/src/generatedCode/FlowSchemas/${flowTag}/source`;
+      return [
+        `${source}/${flowTag}${stepName}_Main.js`,
+        `${source}/${flowTag}${stepName}_HdrSqs.js`
+      ];
+    }),
+    ...dsqSteps.flatMap(({ flowTag, stepName, step }) => {
+      const source = `app/src/generatedCode/FlowSchemas/${flowTag}/source`;
+      let stepEvents = [];
+      if (Array.isArray(step.event)) {
+        stepEvents = step.event;
+      }
+      const files = [`${source}/${flowTag}${stepName}_HdrDsq.js`];
+      if (!stepEvents.includes('extTopic')) {
+        files.unshift(`${source}/${flowTag}${stepName}_Main.js`);
+      }
+      return files;
+    }),
+    ...(customFlowList.length > 0 ||
+    generatedRoots.length > 0 ||
+    generatedDsqs.length > 0 ||
+    extSteps.length > 0 ||
+    dsqSteps.length > 0
+      ? [YAML_PATH]
+      : [])
+  ];
+}

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`;
+}