@izara_project/izara-core-generate-service-code 1.0.98 → 1.0.100

package/src/emit/application/custom/customFlowS3.js

@@ -1,5 +1,10 @@
 import { renderCustom } from './customFlowTemplates.js';
-import { customFlowRoleName, upperFirst } from './customFlows.js';
+import {
+  customFlowRoleName,
+  upperFirst,
+  resolveS3Parts,
+  flowHasRbac
+} from './customFlows.js';
 import {
   renderInvFunctionYaml,
   renderS3FunctionYaml,
@@ -7,63 +12,81 @@ import {
   renderWbsFunctionYaml
 } from '../../infrastructure/functions/functionYamlArtifact.js';
 
-export async function emitS3Flow(flow, source, handlerRoot) {
+export function isSimplifiedS3Flow(flow) {
+  if (!Array.isArray(flow?.flowSteps) || flow.flowSteps.length === 0) {
+    return false;
+  }
+  const stepNames = flow.flowSteps.map((s) => s.stepName);
+  if (stepNames.includes('ReservedLimit')) {
+    return false;
+  }
+  return true;
+}
+
+export async function emitS3Flow(
+  flow,
+  source,
+  handlerRoot,
+  { objects = [] } = {}
+) {
   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 parts = resolveS3Parts(flow);
+  const isSimplifiedS3 = isSimplifiedS3Flow(flow);
 
   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}`;
+      async (
+        { action, handler, type, mainTemplate, handlerTemplate },
+        index
+      ) => {
+        let isStart = false;
+        if (typeof action === 'string' && action.toLowerCase() === 'start') {
+          isStart = true;
+        }
+        let functionName = `${tag}${action}`;
+        let mainFileName = `${functionName}_Main`;
+        let handlerFileName = `${functionName}_${handler}`;
+        let slsFunctionName = `${functionName}${handler}`;
+        let flowStepName = action;
+        if (isStart) {
+          functionName = tag;
+          mainFileName = `${tag}_Main`;
+          handlerFileName = `${tag}_${handler}`;
+          slsFunctionName = `${tag}${handler}`;
+          flowStepName = '';
+        }
+
+        const nextPart = parts.find((p, i) => i > index && p.type === 'sqs');
+        let nextStepFunctionName = null;
+        if (nextPart) {
+          nextStepFunctionName = `${tag}${nextPart.action}${nextPart.handler}`;
+        }
+
         const mainContent = await renderCustom(
           `s3/${mainTemplate}`,
-          _s3TemplateData({ action, flow, functionName })
+          _s3TemplateData({
+            action,
+            flow,
+            functionName,
+            nextStepFunctionName,
+            isSimplifiedS3,
+            objects
+          })
         );
         const handlerContent = await renderCustom(
           `s3/${handlerTemplate}`,
-          _s3HandlerData({ action, flow, functionName, mainFileName, handler })
+          _s3HandlerData({
+            action,
+            flow,
+            functionName,
+            mainFileName,
+            handler,
+            isSimplifiedS3
+          })
         );
         const descriptor = {
-          functionName: `${functionName}${handler}`,
+          functionName: slsFunctionName,
           handlerPath: `${handlerRoot}/${handlerFileName}.main`,
           roleName
         };
@@ -73,18 +96,18 @@ export async function emitS3Flow(flow, source, handlerRoot) {
             ...descriptor,
             routeName: tag,
             flowTag: flow.flowTag,
-            flowStepName: ''
+            flowStepName
           });
         } else if (type === 'sqs') {
           let filterPatternFunctionName = descriptor.functionName;
-          if (action === 'CreatePreSignUrl') {
+          if (!isSimplifiedS3 && action === 'CreatePreSignUrl') {
             filterPatternFunctionName = 'CreatePresignUrlHdrSqs';
           }
           functionYaml = renderSqsFunctionYaml({
             ...descriptor,
             queueName: descriptor.functionName,
             flowTag: flow.flowTag,
-            flowStepName: '',
+            flowStepName: action,
             filterPatternFunctionName
           });
         } else if (type === 's3') {
@@ -100,14 +123,15 @@ export async function emitS3Flow(flow, source, handlerRoot) {
           functionYaml = renderS3FunctionYaml({
             ...descriptor,
             bucketName: flow.bucketName,
+            s3KeyPrefix: flow.s3KeyPrefix,
             flowTag: flow.flowTag,
-            flowStepName: ''
+            flowStepName: action
           });
         } else {
           functionYaml = renderInvFunctionYaml({
             ...descriptor,
             flowTag: flow.flowTag,
-            flowStepName: ''
+            flowStepName: action
           });
         }
         return {
@@ -127,23 +151,209 @@ export async function emitS3Flow(flow, source, handlerRoot) {
   };
 }
 
-function _s3TemplateData({ action, flow, functionName }) {
-  if (action === 'CreateObject') {
-    return {
-      flowTag: flow.flowTag,
-      objectType: flow.objType?.objectType,
-      functionName
-    };
+export function extractIdentifierFieldNames(identifiers) {
+  if (!Array.isArray(identifiers) || identifiers.length === 0) {
+    return [];
   }
-  if (action === 'CreatePreSignUrl') {
-    return { flowTag: flow.flowTag };
+  const keys = [];
+  for (const item of identifiers) {
+    if (typeof item === 'string') {
+      if (item && !keys.includes(item)) {
+        keys.push(item);
+      }
+    } else if (item && typeof item === 'object') {
+      if (Array.isArray(item.fieldNames) && item.fieldNames.length > 0) {
+        for (const fn of item.fieldNames) {
+          if (typeof fn === 'string' && fn && !keys.includes(fn)) {
+            keys.push(fn);
+          }
+        }
+      } else if (typeof item.fieldName === 'string' && item.fieldName) {
+        if (!keys.includes(item.fieldName)) {
+          keys.push(item.fieldName);
+        }
+      } else if (typeof item.name === 'string' && item.name) {
+        if (!keys.includes(item.name)) {
+          keys.push(item.name);
+        }
+      }
+    }
   }
-  return { flowTag: flow.flowTag, functionName };
+  return keys;
 }
 
-function _s3HandlerData({ action, flow, functionName, mainFileName, handler }) {
-  if (action === 'CreateObject') {
-    return { functionName, handlerType: handler, route: flow.flowTag };
+export function resolveParentIdentifierInfo(flow, objects = []) {
+  let parentObjectType = null;
+  let parentServiceTag = null;
+  const targetObjType =
+    typeof flow.objType === 'string'
+      ? flow.objType
+      : flow.objType?.objectType || flow.objectType;
+  const matchedObject = (objects || []).find(
+    (o) => o.objectType === targetObjType
+  );
+
+  if (flow.parentObjectType) {
+    parentObjectType = flow.parentObjectType;
+  } else if (flow.belongTo?.objectType) {
+    parentObjectType = flow.belongTo.objectType;
+    parentServiceTag = flow.belongTo.serviceTag;
+  } else if (Array.isArray(flow.belongTo) && flow.belongTo[0]?.objectType) {
+    parentObjectType = flow.belongTo[0].objectType;
+    parentServiceTag = flow.belongTo[0].serviceTag;
+  }
+
+  if (!parentObjectType && matchedObject?.belongTo) {
+    const belongTo = matchedObject.belongTo;
+    if (Array.isArray(belongTo) && belongTo[0]?.objectType) {
+      parentObjectType = belongTo[0].objectType;
+      parentServiceTag = belongTo[0].serviceTag;
+    } else if (belongTo.objectType) {
+      parentObjectType = belongTo.objectType;
+      parentServiceTag = belongTo.serviceTag;
+    }
+  }
+
+  const belongToDef = flow.belongTo || matchedObject?.belongTo;
+  const singleBelongTo = Array.isArray(belongToDef) ? belongToDef[0] : belongToDef;
+
+  let parentIdKeys = [];
+  if (Array.isArray(flow.parentIdentifierKeys) && flow.parentIdentifierKeys.length > 0) {
+    parentIdKeys = [...flow.parentIdentifierKeys];
+  } else if (flow.parentIdentifierKey) {
+    parentIdKeys = [flow.parentIdentifierKey];
+  } else if (
+    Array.isArray(singleBelongTo?.parentIdentifierKeys) &&
+    singleBelongTo.parentIdentifierKeys.length > 0
+  ) {
+    parentIdKeys = [...singleBelongTo.parentIdentifierKeys];
+  } else if (
+    Array.isArray(singleBelongTo?.identifiers) &&
+    singleBelongTo.identifiers.length > 0
+  ) {
+    parentIdKeys = extractIdentifierFieldNames(singleBelongTo.identifiers);
+  } else {
+    const parentObj =
+      Array.isArray(objects) && parentObjectType
+        ? objects.find((o) => o.objectType === parentObjectType)
+        : null;
+    const parentIdentifiers =
+      parentObj?.identifiers || matchedObject?.belongToSchema?.identifiers;
+    if (Array.isArray(parentIdentifiers) && parentIdentifiers.length > 0) {
+      parentIdKeys = extractIdentifierFieldNames(parentIdentifiers);
+    }
+    if (parentIdKeys.length === 0 && parentObjectType) {
+      parentIdKeys = [`${parentObjectType}Id`];
+    }
+  }
+
+  let parentIdKey = null;
+  if (parentIdKeys.length > 0) {
+    parentIdKey = parentIdKeys[0];
+  }
+
+  return {
+    parentObjectType,
+    parentServiceTag,
+    parentIdKey,
+    parentIdKeys
+  };
+}
+
+function _s3TemplateData({
+  action,
+  flow,
+  functionName,
+  nextStepFunctionName,
+  isSimplifiedS3,
+  objects = []
+}) {
+  let maxFileSizeMb = 50;
+  if (flow.maxFileSizeMb) {
+    maxFileSizeMb = flow.maxFileSizeMb;
+  }
+  let expires = 86400;
+  if (flow.expires) {
+    expires = flow.expires;
+  }
+  let contentTypePrefix = 'video/';
+  if (flow.contentTypePrefix) {
+    contentTypePrefix = flow.contentTypePrefix;
+  } else if (flow.contentType) {
+    contentTypePrefix = flow.contentType;
+  }
+  const { parentObjectType, parentServiceTag, parentIdKey, parentIdKeys } =
+    resolveParentIdentifierInfo(flow, objects);
+  let s3KeyPrefix = 'uploads/';
+  if (flow.s3KeyPrefix) {
+    s3KeyPrefix = flow.s3KeyPrefix;
+  }
+  let defaultImportType = 'bin';
+  if (flow.defaultImportType) {
+    defaultImportType = flow.defaultImportType;
+  } else if (flow.importType) {
+    defaultImportType = flow.importType;
+  } else if (typeof contentTypePrefix === 'string' && contentTypePrefix.startsWith('video/')) {
+    defaultImportType = 'mp4';
+  } else if (typeof contentTypePrefix === 'string' && contentTypePrefix.startsWith('image/')) {
+    defaultImportType = 'jpg';
+  }
+
+  let isRbac = false;
+  if (typeof flow.isRbac === 'boolean') {
+    isRbac = flow.isRbac;
+  } else if (flowHasRbac(flow, objects)) {
+    isRbac = true;
+  } else if (parentObjectType && parentServiceTag) {
+    isRbac = true;
+  }
+
+  let rbacServiceTag = parentServiceTag;
+  if (!rbacServiceTag) {
+    rbacServiceTag = flow.objType?.serviceTag || flow.serviceTag || 'Rbac';
+  }
+
+  return {
+    action,
+    flowTag: flow.flowTag,
+    objectType: flow.objType?.objectType,
+    functionName,
+    nextStepFunctionName,
+    isSimplifiedS3,
+    bucketName: flow.bucketName,
+    s3KeyPrefix,
+    maxFileSizeMb,
+    expires,
+    contentTypePrefix,
+    parentObjectType,
+    parentServiceTag,
+    parentIdKey,
+    parentIdKeys,
+    defaultImportType,
+    isRbac,
+    rbacServiceTag
+  };
+}
+
+function _s3HandlerData({
+  action,
+  flow,
+  functionName,
+  mainFileName,
+  handler,
+  isSimplifiedS3
+}) {
+  const isStartOrCreate =
+    action === 'CreateObject' ||
+    (typeof action === 'string' && action.toLowerCase() === 'start');
+  if (isStartOrCreate) {
+    return {
+      functionName,
+      mainFileName,
+      handlerType: handler,
+      route: flow.flowTag,
+      isSimplifiedS3
+    };
   }
   if (action === 'ProcessAfterUpload') {
     let bucketName = '';
@@ -154,8 +364,9 @@ function _s3HandlerData({ action, flow, functionName, mainFileName, handler }) {
       flowTag: flow.flowTag,
       functionName,
       mainFileName,
-      s3Bucket: bucketName
+      s3Bucket: bucketName,
+      isSimplifiedS3
     };
   }
-  return { functionName, handlerType: handler };
+  return { functionName, mainFileName, handlerType: handler, isSimplifiedS3 };
 }

package/src/emit/application/custom/customFlows.js

@@ -79,6 +79,9 @@ export function flowExtTopicSteps(flows) {
     if (typeof flow?.flowTag !== 'string' || flow.flowTag === '') {
       return [];
     }
+    if (Array.isArray(flow.event) && flow.event.includes('s3')) {
+      return [];
+    }
     const hasTriggerFlowTypes =
       Array.isArray(flow.triggerFlowTypes) && flow.triggerFlowTypes.length > 0;
     if (flow.statusType === 'triggerCache' && !hasTriggerFlowTypes) {
@@ -341,3 +344,131 @@ function normalizeBelongTo(object) {
   if (!belongTo) return [];
   return Array.isArray(belongTo) ? belongTo : [belongTo];
 }
+
+export const LEGACY_S3_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'
+  }
+];
+
+export function resolveS3Parts(flow) {
+  if (!Array.isArray(flow?.flowSteps) || flow.flowSteps.length === 0) {
+    return LEGACY_S3_PARTS;
+  }
+
+  const stepNames = flow.flowSteps.map((s) => s.stepName);
+  if (
+    stepNames.includes('CreateObject') &&
+    stepNames.includes('ReservedLimit') &&
+    stepNames.includes('ConfirmAfterUpload')
+  ) {
+    return LEGACY_S3_PARTS;
+  }
+
+  const hasS3Step = flow.flowSteps.some(
+    (step) =>
+      (Array.isArray(step.event) && step.event.includes('s3')) ||
+      (typeof step.stepName === 'string' &&
+        step.stepName.toLowerCase().includes('afterupload'))
+  );
+
+  if (!hasS3Step) {
+    return LEGACY_S3_PARTS;
+  }
+
+  const isDeferredNodeFlow =
+    !stepNames.includes('CreatePreSignUrl') &&
+    (stepNames.includes('ConfirmComplete') ||
+      stepNames.includes('ConfirmAfterUpload') ||
+      stepNames.length <= 3);
+
+  return flow.flowSteps.map((step) => {
+    const action = upperFirst(step.stepName);
+    const eventType = Array.isArray(step.event) ? step.event[0] : 'sqs';
+
+    if (eventType === 'wbs' || action === 'Start' || action === 'CreateObject') {
+      let mainTemplate = 'CreateObject_Main.ejs';
+      if (isDeferredNodeFlow) {
+        mainTemplate = 'Start_Main.ejs';
+      }
+      return {
+        action,
+        handler: 'HdrWbs',
+        type: 'wbs',
+        mainTemplate,
+        handlerTemplate: 'CreateObject_HdrWbs.ejs'
+      };
+    }
+
+    if (eventType === 's3' || action === 'ProcessAfterUpload') {
+      return {
+        action,
+        handler: 'HdrS3',
+        type: 's3',
+        mainTemplate: 'ProcessS3File_Main.ejs',
+        handlerTemplate: 'FlowHandler_HdrS3.ejs'
+      };
+    }
+
+    if (action === 'ConfirmComplete') {
+      return {
+        action,
+        handler: 'HdrSqs',
+        type: 'sqs',
+        mainTemplate: 'ConfirmComplete_Main.ejs',
+        handlerTemplate: 'ConfirmComplete_HdrSqs.ejs'
+      };
+    }
+
+    if (action === 'ConfirmAfterUpload') {
+      return {
+        action,
+        handler: 'HdrSqs',
+        type: 'sqs',
+        mainTemplate: 'ConfirmAfterUpload_Main.ejs',
+        handlerTemplate: 'ConfirmAfterUpload_HdrSqs.ejs'
+      };
+    }
+
+    return {
+      action,
+      handler: 'HdrSqs',
+      type: 'sqs',
+      mainTemplate: 'CreatePreSignUrl_Main.ejs',
+      handlerTemplate: 'CreatePreSignUrl_HdrSqs.ejs'
+    };
+  });
+}
+

package/src/emit/application/custom/emitCustomFlowApplicationArtifacts.js

@@ -201,7 +201,9 @@ async function emitFlow(flow, objects) {
     functions.push(...root.functions);
   }
   if (flow.event.includes('s3')) {
-    const s3Artifacts = await emitS3Flow(flow, source, handlerRoot);
+    const s3Artifacts = await emitS3Flow(flow, source, handlerRoot, {
+      objects
+    });
     artifacts.push(...s3Artifacts.artifacts);
     functions.push(...s3Artifacts.functions);
   }

package/src/emit/application/custom/templates/FlowEndpoint_Main.ejs

@@ -247,8 +247,8 @@ export default async function <%- typeof functionName !== 'undefined' ? function
       resultPermissionCheck
     );
 
-    //(<rbacPublish_<%- flowTag %>)
-    //(</rbacPublish_<%- flowTag %>)
+    //(<rbacPublish_<%- flowTag %>>)
+    //(</rbacPublish_<%- flowTag %>>)
 
     return resultPermissionCheck;
 <% } else { -%>

package/src/emit/application/custom/templates/s3/ConfirmAfterUpload_HdrSqs.ejs

@@ -0,0 +1,110 @@
+/*
+Copyright (C) 2026 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { middlewareHandler as middleware } from '@izara_project/izara-middleware';
+import { recordHandlerSharedLib } from '@izara_project/izara-core-library-record-handler';
+import Logger from '@izara_project/izara-core-library-logger';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+
+import <%= functionName %> from './<%= functionName %>_Main.js';
+
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+
+let perRecordsValidatorSchema = {
+  type: 'object',
+  required: ['objType', 'objInstanceFull'],
+  properties: {
+    objType: {
+      type: 'object',
+      required: ['objectType', 'serviceTag'],
+      properties: {
+        objectType: {
+          type: 'string',
+          pattern: '^[a-zA-Z0-9_-]+$'
+        },
+        serviceTag: {
+          type: 'string',
+          pattern: '^[a-zA-Z0-9_-]+$'
+        }
+      }
+    },
+    objInstanceFull: {
+      type: 'object',
+      properties: {
+        identifiers: {
+          type: 'object',
+          minProperties: 1
+        },
+        fields: {
+          type: 'object'
+        }
+      }
+    }
+  }
+};
+
+perRecordsValidatorSchema =
+  callingFlowSharedLib.addOptionalPassBackPropertiesToValidatorSchema(
+    perRecordsValidatorSchema
+  );
+
+export const main = middleware.wrap(async (event, context) => {
+  try {
+    let recordPromises = [];
+
+    await Promise.all(
+      event.Records.map(async (record) => {
+        let passOnProperties = [];
+        record._izContext.logger.debug('record <%= functionName %><%= handlerType %>', record);
+
+        await recordHandlerSharedLib.validateRecord(
+          record,
+          '<%= functionName %><%= handlerType %>',
+          perRecordsValidatorSchema
+        );
+
+        passOnProperties.push(record.body.Message.objType);
+        passOnProperties.push(record.body.Message.objInstanceFull);
+        //(<additionalProperties>)
+        //(</additionalProperties>)
+        passOnProperties.push(
+          callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(
+            record.body.Message
+          )
+        );
+
+        record._izContext.logger.debug(
+          'passOnProperties in <%= functionName %><%= handlerType %>',
+          passOnProperties
+        );
+
+        let returnPromise = await recordHandlerSharedLib.recordHandler(
+          record,
+          <%= functionName %>,
+          passOnProperties
+        );
+
+        recordPromises.push(returnPromise);
+      })
+    );
+
+    return await Promise.all(recordPromises);
+  } catch (err) {
+    Logger.error('Error <%= functionName %><%= handlerType %>: ', err);
+    throw err;
+  }
+});