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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.100",
+  "version": "1.0.102",
   "description": "Code for locally generating per service files",
   "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "repository": {

package/src/emit/application/crud/templates/CreateLogicalLib.ejs

@@ -140,6 +140,12 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, foundE
   }
 
   requestParams.submittedByUserId = submittedByUserId;
+  if (submittedByUserId) {
+    _izContext.correlationIds?.set(
+      coreConsts.SUBMITTED_BY_USER_ID,
+      submittedByUserId
+    );
+  }
   return { objType, objectSchema, targetIdentifiers };
 }
 

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

@@ -27,7 +27,7 @@ export async function emitS3Flow(
   flow,
   source,
   handlerRoot,
-  { objects = [] } = {}
+  { objects = [], relationships = [] } = {}
 ) {
   const tag = upperFirst(flow.flowTag);
   const roleName = customFlowRoleName(flow.flowTag);
@@ -71,7 +71,8 @@ export async function emitS3Flow(
             functionName,
             nextStepFunctionName,
             isSimplifiedS3,
-            objects
+            objects,
+            relationships
           })
         );
         const handlerContent = await renderCustom(
@@ -260,13 +261,216 @@ export function resolveParentIdentifierInfo(flow, objects = []) {
   };
 }
 
+export function resolveTargetIdentifierInfo(flow, objects = []) {
+  const targetObjType =
+    typeof flow.objType === 'string'
+      ? flow.objType
+      : flow.objType?.objectType || flow.objectType;
+  const matchedObject = (objects || []).find(
+    (o) => o.objectType === targetObjType
+  );
+
+  let identifierKeys = [];
+  if (Array.isArray(flow.identifierKeys) && flow.identifierKeys.length > 0) {
+    identifierKeys = [...flow.identifierKeys];
+  } else if (flow.identifierKey) {
+    identifierKeys = [flow.identifierKey];
+  } else if (
+    Array.isArray(matchedObject?.identifiers) &&
+    matchedObject.identifiers.length > 0
+  ) {
+    identifierKeys = extractIdentifierFieldNames(matchedObject.identifiers);
+  }
+
+  if (identifierKeys.length === 0 && targetObjType) {
+    identifierKeys = [`${targetObjType}Id`];
+  }
+
+  let identifierKey =
+    identifierKeys.length > 0 ? identifierKeys[0] : `${targetObjType}Id`;
+
+  return {
+    identifierKey,
+    identifierKeys
+  };
+}
+
+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;
+  }
+
+  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 [];
+  }
+
+  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 = []
+  objects = [],
+  relationships = []
 }) {
   let maxFileSizeMb = 50;
   if (flow.maxFileSizeMb) {
@@ -284,6 +488,8 @@ function _s3TemplateData({
   }
   const { parentObjectType, parentServiceTag, parentIdKey, parentIdKeys } =
     resolveParentIdentifierInfo(flow, objects);
+  const { identifierKey, identifierKeys } =
+    resolveTargetIdentifierInfo(flow, objects);
   let s3KeyPrefix = 'uploads/';
   if (flow.s3KeyPrefix) {
     s3KeyPrefix = flow.s3KeyPrefix;
@@ -293,9 +499,15 @@ function _s3TemplateData({
     defaultImportType = flow.defaultImportType;
   } else if (flow.importType) {
     defaultImportType = flow.importType;
-  } else if (typeof contentTypePrefix === 'string' && contentTypePrefix.startsWith('video/')) {
+  } else if (
+    typeof contentTypePrefix === 'string' &&
+    contentTypePrefix.startsWith('video/')
+  ) {
     defaultImportType = 'mp4';
-  } else if (typeof contentTypePrefix === 'string' && contentTypePrefix.startsWith('image/')) {
+  } else if (
+    typeof contentTypePrefix === 'string' &&
+    contentTypePrefix.startsWith('image/')
+  ) {
     defaultImportType = 'jpg';
   }
 
@@ -313,10 +525,17 @@ function _s3TemplateData({
     rbacServiceTag = flow.objType?.serviceTag || flow.serviceTag || 'Rbac';
   }
 
+  const flowRelationships = resolveFlowRelationships(flow, {
+    objects,
+    relationships
+  });
+
   return {
     action,
     flowTag: flow.flowTag,
     objectType: flow.objType?.objectType,
+    identifierKey,
+    identifierKeys,
     functionName,
     nextStepFunctionName,
     isSimplifiedS3,
@@ -331,7 +550,8 @@ function _s3TemplateData({
     parentIdKeys,
     defaultImportType,
     isRbac,
-    rbacServiceTag
+    rbacServiceTag,
+    flowRelationships
   };
 }
 

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

@@ -350,22 +350,22 @@ export const LEGACY_S3_PARTS = [
     action: 'CreateObject',
     handler: 'HdrWbs',
     type: 'wbs',
-    mainTemplate: 'CreateObject_Main.ejs',
-    handlerTemplate: 'CreateObject_HdrWbs.ejs'
+    mainTemplate: 'legacy/CreateObject_Main.ejs',
+    handlerTemplate: 'legacy/CreateObject_HdrWbs.ejs'
   },
   {
     action: 'ReservedLimit',
     handler: 'HdrSqs',
     type: 'sqs',
-    mainTemplate: 'ReservedLimit_Main.ejs',
-    handlerTemplate: 'ReservedLimit_HdrSqs.ejs'
+    mainTemplate: 'legacy/ReservedLimit_Main.ejs',
+    handlerTemplate: 'legacy/ReservedLimit_HdrSqs.ejs'
   },
   {
     action: 'CreatePreSignUrl',
     handler: 'HdrSqs',
     type: 'sqs',
-    mainTemplate: 'CreatePreSignUrl_Main.ejs',
-    handlerTemplate: 'CreatePreSignUrl_HdrSqs.ejs'
+    mainTemplate: 'legacy/CreatePreSignUrl_Main.ejs',
+    handlerTemplate: 'legacy/CreatePreSignUrl_HdrSqs.ejs'
   },
   {
     action: 'ProcessAfterUpload',
@@ -378,8 +378,8 @@ export const LEGACY_S3_PARTS = [
     action: 'ConfirmAfterUpload',
     handler: 'HdrSqs',
     type: 'sqs',
-    mainTemplate: 'ConfirmReserved_Main.ejs',
-    handlerTemplate: 'ConfirmReserved_HdrSqs.ejs'
+    mainTemplate: 'legacy/ConfirmReserved_Main.ejs',
+    handlerTemplate: 'legacy/ConfirmReserved_HdrSqs.ejs'
   }
 ];
 
@@ -419,16 +419,18 @@ export function resolveS3Parts(flow) {
     const eventType = Array.isArray(step.event) ? step.event[0] : 'sqs';
 
     if (eventType === 'wbs' || action === 'Start' || action === 'CreateObject') {
-      let mainTemplate = 'CreateObject_Main.ejs';
+      let mainTemplate = 'legacy/CreateObject_Main.ejs';
+      let handlerTemplate = 'legacy/CreateObject_HdrWbs.ejs';
       if (isDeferredNodeFlow) {
         mainTemplate = 'Start_Main.ejs';
+        handlerTemplate = 'Start_HdrWbs.ejs';
       }
       return {
         action,
         handler: 'HdrWbs',
         type: 'wbs',
         mainTemplate,
-        handlerTemplate: 'CreateObject_HdrWbs.ejs'
+        handlerTemplate
       };
     }
 
@@ -453,12 +455,18 @@ export function resolveS3Parts(flow) {
     }
 
     if (action === 'ConfirmAfterUpload') {
+      let mainTemplate = 'legacy/ConfirmAfterUpload_Main.ejs';
+      let handlerTemplate = 'legacy/ConfirmAfterUpload_HdrSqs.ejs';
+      if (isDeferredNodeFlow) {
+        mainTemplate = 'ConfirmComplete_Main.ejs';
+        handlerTemplate = 'ConfirmComplete_HdrSqs.ejs';
+      }
       return {
         action,
         handler: 'HdrSqs',
         type: 'sqs',
-        mainTemplate: 'ConfirmAfterUpload_Main.ejs',
-        handlerTemplate: 'ConfirmAfterUpload_HdrSqs.ejs'
+        mainTemplate,
+        handlerTemplate
       };
     }
 
@@ -466,8 +474,8 @@ export function resolveS3Parts(flow) {
       action,
       handler: 'HdrSqs',
       type: 'sqs',
-      mainTemplate: 'CreatePreSignUrl_Main.ejs',
-      handlerTemplate: 'CreatePreSignUrl_HdrSqs.ejs'
+      mainTemplate: 'legacy/CreatePreSignUrl_Main.ejs',
+      handlerTemplate: 'legacy/CreatePreSignUrl_HdrSqs.ejs'
     };
   });
 }

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

@@ -35,7 +35,7 @@ export { customFlowApplicationManagedPaths };
 
 export async function emitCustomFlowApplicationArtifacts(
   flows,
-  { objects = [] } = {}
+  { objects = [], relationships = [] } = {}
 ) {
   const customFlows = supportedCustomFlows(flows);
   const generatedRoots = generatedOwnTopicFlows(flows);
@@ -51,7 +51,7 @@ export async function emitCustomFlowApplicationArtifacts(
   }
 
   const emitted = await Promise.all(
-    customFlows.map((flow) => emitFlow(flow, objects))
+    customFlows.map((flow) => emitFlow(flow, objects, relationships))
   );
   const roots = await Promise.all(
     generatedRoots.map((flow) => emitOwnTopicRoot(flow, objects))
@@ -77,7 +77,7 @@ export async function emitCustomFlowApplicationArtifacts(
   ];
 }
 
-async function emitFlow(flow, objects) {
+async function emitFlow(flow, objects, relationships = []) {
   const tag = upperFirst(flow.flowTag);
   const process = tag;
   const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
@@ -202,7 +202,8 @@ async function emitFlow(flow, objects) {
   }
   if (flow.event.includes('s3')) {
     const s3Artifacts = await emitS3Flow(flow, source, handlerRoot, {
-      objects
+      objects,
+      relationships
     });
     artifacts.push(...s3Artifacts.artifacts);
     functions.push(...s3Artifacts.functions);

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

@@ -95,6 +95,7 @@ export const main = middleware.wrap(async (event, context) => {
         let returnPromise = await recordHandlerSharedLib.recordHandler(
           record,
           <%= functionName %>,
+          '<%= functionName %><%= handlerType %>',
           passOnProperties
         );
 

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

@@ -50,32 +50,43 @@ export default async function <%- functionName %>(
       passBackProperties
     });
 
-    const targetId =
-      objInstanceFull.identifiers?.<%- objectType %>Id ||
-      Object.values(objInstanceFull.identifiers || {})[0];
+    let targetId =
+      passBackProperties.rawId ||
+      passBackProperties.<%- (typeof identifierKey !== 'undefined' && identifierKey) ? identifierKey : `${objectType}Id` %> ||
+      passBackProperties.parentPassBackProperties?.rawId ||
+      passBackProperties.parentPassBackProperties?.<%- (typeof identifierKey !== 'undefined' && identifierKey) ? identifierKey : `${objectType}Id` %> ||
+      objInstanceFull?.identifiers?.<%- (typeof identifierKey !== 'undefined' && identifierKey) ? identifierKey : `${objectType}Id` %>;
+
+    if (!targetId && objInstanceFull?.identifiers) {
+      targetId = Object.values(objInstanceFull.identifiers)[0];
+    }
 
     //(<confirmUsageHook>)
     //(</confirmUsageHook>)
 
     const taskKey = `${createFlowTypeConcat(_izContext, { flowTag: '<%- flowTag %>', serviceTag: process.env.iz_serviceTag })}${targetId}`;
-    const taskRecord = await dynamodbSharedLib.getItem(
+    const tasks = await dynamodbSharedLib.query(
       _izContext,
       await dynamodbSharedLib.tableName(_izContext, 'WebSocketTask'),
-      { taskKey: taskKey }
+      { taskKey }
     );
 
-    if (taskRecord && taskRecord.connectionId) {
-      await postToConnection(
-        _izContext,
-        {
-          status: 'completed',
-          data: {
-            <%- objectType %>Id: targetId,
-            objInstanceFull: objInstanceFull
-          }
-        },
-        taskRecord.connectionId
-      );
+    if (tasks && tasks.Items && tasks.Items.length > 0) {
+      for (const taskRecord of tasks.Items) {
+        if (taskRecord.connectionId && taskRecord.connectionId !== 'NONE') {
+          await postToConnection(
+            _izContext,
+            {
+              status: 'completed',
+              data: {
+                <%- (typeof identifierKey !== 'undefined' && identifierKey) ? identifierKey : `${objectType}Id` %>: targetId,
+                objInstanceFull: objInstanceFull
+              }
+            },
+            taskRecord.connectionId
+          );
+        }
+      }
     }
 
     return {