@izara_project/izara-core-generate-service-code 1.0.99 → 1.0.101

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,82 @@ 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 = [], relationships = [] } = {}
+) {
   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,
+            relationships
+          })
         );
         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,11 +97,11 @@ export async function emitS3Flow(flow, source, handlerRoot) {
             ...descriptor,
             routeName: tag,
             flowTag: flow.flowTag,
-            flowStepName: action
+            flowStepName
           });
         } else if (type === 'sqs') {
           let filterPatternFunctionName = descriptor.functionName;
-          if (action === 'CreatePreSignUrl') {
+          if (!isSimplifiedS3 && action === 'CreatePreSignUrl') {
             filterPatternFunctionName = 'CreatePresignUrlHdrSqs';
           }
           functionYaml = renderSqsFunctionYaml({
@@ -100,6 +124,7 @@ export async function emitS3Flow(flow, source, handlerRoot) {
           functionYaml = renderS3FunctionYaml({
             ...descriptor,
             bucketName: flow.bucketName,
+            s3KeyPrefix: flow.s3KeyPrefix,
             flowTag: flow.flowTag,
             flowStepName: action
           });
@@ -127,23 +152,390 @@ 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 [];
+  }
+  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 keys;
+}
+
+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
+  };
+}
+
+export function resolveFlowRelationships(
+  flow,
+  { objects = [], relationships = [] } = {}
+) {
+  if (Array.isArray(flow.relationships) && flow.relationships.length > 0) {
+    const list = [];
+    for (const rel of flow.relationships) {
+      let targetObj = {
+        objectType: '',
+        serviceTag: ''
+      };
+      if (rel.targetObjType) {
+        targetObj = {
+          objectType: rel.targetObjType.objectType || '',
+          serviceTag: rel.targetObjType.serviceTag || ''
+        };
+      } else if (rel.objectType) {
+        targetObj = {
+          objectType: rel.objectType,
+          serviceTag: rel.serviceTag || ''
+        };
+      }
+
+      let relType = {
+        relationshipTag: '',
+        serviceTag: targetObj.serviceTag
+      };
+      if (rel.relType) {
+        relType = {
+          relationshipTag: rel.relType.relationshipTag || '',
+          serviceTag: rel.relType.serviceTag || targetObj.serviceTag
+        };
+      } else if (rel.relationshipTag) {
+        relType = {
+          relationshipTag: rel.relationshipTag,
+          serviceTag: rel.serviceTag || targetObj.serviceTag
+        };
+      }
+
+      let targetIdentifierKey = '';
+      if (rel.targetIdentifierKey) {
+        targetIdentifierKey = rel.targetIdentifierKey;
+      } else if (rel.targetIdentifiers) {
+        const idKeys = Object.keys(rel.targetIdentifiers);
+        if (idKeys.length > 0) {
+          targetIdentifierKey = idKeys[0];
+        }
+      }
+      if (!targetIdentifierKey && targetObj.objectType) {
+        targetIdentifierKey = `${targetObj.objectType}Id`;
+      }
+
+      let direction = 'to';
+      if (rel.relationshipDirection) {
+        direction = rel.relationshipDirection;
+      }
+
+      list.push({
+        targetObjType: targetObj,
+        relType,
+        targetIdentifierKey,
+        relationshipProperties: rel.relationshipProperties || {},
+        relationshipDirection: direction
+      });
+    }
+    return list;
   }
-  if (action === 'CreatePreSignUrl') {
-    return { flowTag: flow.flowTag };
+
+  let targetObjType = '';
+  if (typeof flow.objType === 'string') {
+    targetObjType = flow.objType;
+  } else if (flow.objType?.objectType) {
+    targetObjType = flow.objType.objectType;
+  } else if (flow.objectType) {
+    targetObjType = flow.objectType;
+  }
+
+  if (
+    !targetObjType ||
+    !Array.isArray(relationships) ||
+    relationships.length === 0
+  ) {
+    return [];
   }
-  return { flowTag: flow.flowTag, functionName };
+
+  const resolved = [];
+  for (const relItem of relationships) {
+    if (!relItem || typeof relItem !== 'object') {
+      continue;
+    }
+
+    if (
+      relItem.objectType &&
+      relItem.objectType.toLowerCase() === targetObjType.toLowerCase() &&
+      relItem.relationshipTag &&
+      relItem.relationshipServiceTag
+    ) {
+      const parentService = relItem.relationshipServiceTag;
+      let parentObjType = '';
+      if (relItem.targetObjectType) {
+        parentObjType = relItem.targetObjectType;
+      } else if (parentService.length > 0) {
+        parentObjType =
+          parentService[0].toLowerCase() + parentService.slice(1);
+      }
+      let targetIdentifierKey = `${parentObjType}Id`;
+      if (relItem.targetIdentifierKey) {
+        targetIdentifierKey = relItem.targetIdentifierKey;
+      }
+      let direction = 'to';
+      if (relItem.relationshipDirection) {
+        direction = relItem.relationshipDirection;
+      }
+      resolved.push({
+        targetObjType: {
+          objectType: parentObjType,
+          serviceTag: parentService
+        },
+        relType: {
+          relationshipTag: relItem.relationshipTag,
+          serviceTag: parentService
+        },
+        targetIdentifierKey,
+        relationshipProperties: {},
+        relationshipDirection: direction
+      });
+      continue;
+    }
+
+    const relKeys = Object.keys(relItem);
+    for (const relTag of relKeys) {
+      const relDef = relItem[relTag];
+      if (!relDef || !Array.isArray(relDef.links)) {
+        continue;
+      }
+      for (const link of relDef.links) {
+        if (!link || !link.from || !link.to) {
+          continue;
+        }
+
+        const isToTarget =
+          link.to.objType?.objectType?.toLowerCase() ===
+          targetObjType.toLowerCase();
+        if (isToTarget && link.to.requiredOnCreate) {
+          const fromObj = link.from.objType || {};
+          const fromObjType = fromObj.objectType || '';
+          const targetIdentifierKey = `${fromObjType}Id`;
+          resolved.push({
+            targetObjType: {
+              objectType: fromObjType,
+              serviceTag: fromObj.serviceTag || ''
+            },
+            relType: {
+              relationshipTag: relTag,
+              serviceTag: fromObj.serviceTag || ''
+            },
+            targetIdentifierKey,
+            relationshipProperties: {},
+            relationshipDirection: 'to'
+          });
+        }
+      }
+    }
+  }
+
+  return resolved;
+}
+
+function _s3TemplateData({
+  action,
+  flow,
+  functionName,
+  nextStepFunctionName,
+  isSimplifiedS3,
+  objects = [],
+  relationships = []
+}) {
+  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';
+  }
+
+  const flowRelationships = resolveFlowRelationships(flow, {
+    objects,
+    relationships
+  });
+
+  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,
+    flowRelationships
+  };
 }
 
-function _s3HandlerData({ action, flow, functionName, mainFileName, handler }) {
-  if (action === 'CreateObject') {
-    return { functionName, handlerType: handler, route: flow.flowTag };
+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 +546,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'
+    };
+  });
+}
+