@izara_project/izara-core-generate-service-code 1.0.88 → 1.0.89

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.88",
+  "version": "1.0.89",
   "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/compile/flowValidator.js

@@ -32,6 +32,31 @@ export function validateFlowSchema(flowSchema) {
     );
   }
 
+  let flowEvents = [];
+  if (Array.isArray(flowSchema.event)) {
+    flowEvents = flowSchema.event;
+  }
+  const syncEvents = ['lambdaSyncInv', 'lambdaSyncApi'];
+  let hasSyncEvent = false;
+  for (const eventName of flowEvents) {
+    if (syncEvents.includes(eventName)) {
+      hasSyncEvent = true;
+      break;
+    }
+  }
+
+  if (hasSyncEvent && steps.length > 1) {
+    let flowTag = 'unknown';
+    if (flowSchema.flowTag) {
+      flowTag = flowSchema.flowTag;
+    }
+    throw new Error(
+      `FlowSchema validation error: Flow '${flowTag}' with synchronous ` +
+      `events ('lambdaSyncInv' | 'lambdaSyncApi') must only define a ` +
+      `single entry step 'Start'`
+    );
+  }
+
   const entryStep = steps[0];
   if (
     !entryStep ||

package/src/compile/loadSchemas.js

@@ -23,6 +23,7 @@ const VALID_INITIATE_BY_ENUM = [
 ];
 
 const VALID_CODE_HOOK_TAG_ENUM = ['before', 'after'];
+const VALID_GENERATE_CODE_TAG_ENUM = ['create', 'update', 'delete'];
 
 if (basicValidatorSchema?.basicFlowSchema?.properties?.initiateBy) {
   basicValidatorSchema.basicFlowSchema.properties.initiateBy.enum =
@@ -37,6 +38,50 @@ if (
     VALID_CODE_HOOK_TAG_ENUM;
 }
 
+if (
+  basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
+    ?.properties?.generateCodeTag
+) {
+  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.generateCodeTag = {
+    anyOf: [
+      {
+        type: 'array',
+        items: {
+          type: 'string',
+          enum: VALID_GENERATE_CODE_TAG_ENUM
+        }
+      },
+      {
+        type: 'string',
+        enum: VALID_GENERATE_CODE_TAG_ENUM
+      }
+    ]
+  };
+}
+
+if (
+  basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
+    ?.properties
+) {
+  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.objType = {
+    anyOf: [
+      { type: 'string' },
+      {
+        type: 'array',
+        items: { type: 'string' }
+      },
+      {
+        type: 'object',
+        properties: {
+          objectType: { type: 'string' },
+          serviceTag: { type: 'string' }
+        },
+        required: ['objectType']
+      }
+    ]
+  };
+}
+
 const VALID_GENERATED_BY_ENUM = [
   'user',
   'systemWithUser',
@@ -135,6 +180,90 @@ export async function loadLocalSchemaDirectory(
             );
           }
         }
+        if (
+          Object.prototype.hasOwnProperty.call(
+            schema?.generatedCodeConfig ?? {},
+            'generateCodeTag'
+          )
+        ) {
+          const codeTag = schema.generatedCodeConfig.generateCodeTag;
+          if (Array.isArray(codeTag)) {
+            if (codeTag.length === 0) {
+              throw new Error(
+                `Unsupported FlowHook configuration in ${entry.name}: ` +
+                `generatedCodeConfig.generateCodeTag array must not be empty`
+              );
+            }
+            for (const tag of codeTag) {
+              if (
+                typeof tag !== 'string' ||
+                !VALID_GENERATE_CODE_TAG_ENUM.includes(tag.toLowerCase())
+              ) {
+                throw new Error(
+                  `Unsupported FlowHook configuration in ${entry.name}: ` +
+                  `generatedCodeConfig.generateCodeTag contains invalid ` +
+                  `tag '${tag}'. Must be 'create', 'update', or 'delete'`
+                );
+              }
+            }
+          } else if (typeof codeTag === 'string') {
+            if (!VALID_GENERATE_CODE_TAG_ENUM.includes(codeTag.toLowerCase())) {
+              throw new Error(
+                `Unsupported FlowHook configuration in ${entry.name}: ` +
+                `generatedCodeConfig.generateCodeTag '${codeTag}' ` +
+                `is invalid. Must be 'create', 'update', or 'delete'`
+              );
+            }
+          } else {
+            throw new Error(
+              `Unsupported FlowHook configuration in ${entry.name}: ` +
+              `generatedCodeConfig.generateCodeTag must be an array or string`
+            );
+          }
+        }
+        if (
+          Object.prototype.hasOwnProperty.call(
+            schema?.generatedCodeConfig ?? {},
+            'objType'
+          )
+        ) {
+          const hookObjType = schema.generatedCodeConfig.objType;
+          if (Array.isArray(hookObjType)) {
+            if (hookObjType.length === 0) {
+              throw new Error(
+                `Unsupported FlowHook configuration in ${entry.name}: ` +
+                `generatedCodeConfig.objType array must not be empty`
+              );
+            }
+            for (const item of hookObjType) {
+              const strVal = typeof item === 'string' ? item : item?.objectType;
+              if (!strVal || typeof strVal !== 'string') {
+                throw new Error(
+                  `Unsupported FlowHook configuration in ${entry.name}: ` +
+                  `generatedCodeConfig.objType array items must be non-empty strings or objects with objectType`
+                );
+              }
+            }
+          } else if (typeof hookObjType === 'object' && hookObjType !== null) {
+            if (
+              !hookObjType.objectType ||
+              typeof hookObjType.objectType !== 'string'
+            ) {
+              throw new Error(
+                `Unsupported FlowHook configuration in ${entry.name}: ` +
+                `generatedCodeConfig.objType object must have string property objectType`
+              );
+            }
+          } else if (
+            typeof hookObjType !== 'string' ||
+            hookObjType.trim() === ''
+          ) {
+            throw new Error(
+              `Unsupported FlowHook configuration in ${entry.name}: ` +
+              `generatedCodeConfig.objType must be a non-empty string, array, or object`
+            );
+          }
+        }
       }
     }
 
@@ -219,6 +348,31 @@ export async function loadLocalSchemaDirectory(
                   )
               );
             }
+            const generateCodeTag =
+              schema?.generatedCodeConfig?.generateCodeTag;
+            let isGenerateCodeTagValid = false;
+            if (Array.isArray(generateCodeTag)) {
+              isGenerateCodeTagValid =
+                generateCodeTag.length > 0 &&
+                generateCodeTag.every((t) => {
+                  return (
+                    typeof t === 'string' &&
+                    VALID_GENERATE_CODE_TAG_ENUM.includes(t.toLowerCase())
+                  );
+                });
+            } else if (typeof generateCodeTag === 'string') {
+              isGenerateCodeTagValid = VALID_GENERATE_CODE_TAG_ENUM.includes(
+                generateCodeTag.toLowerCase()
+              );
+            }
+            if (isGenerateCodeTagValid) {
+              errors = errors.filter((err) => {
+                return (
+                  !err.includes('generateCodeTag') &&
+                  !err.includes('must match a schema in "anyOf"')
+                );
+              });
+            }
             if (errors.length === 0) {
               status = true;
             }

package/src/emit/coreFunction/templates/InitialSetupConfig.ejs

@@ -181,12 +181,6 @@ const tableConfigs = {
 
   const currentServiceTag = (typeof serviceTag !== 'undefined' && serviceTag) ? serviceTag : ((typeof project !== 'undefined' && project?.serviceTag) ? project.serviceTag : '');
   const rbacSubs = [];
-  if (crud && rbac) {
-    if (typeof hasQuotaReservation !== 'undefined' && hasQuotaReservation) {
-      rbacSubs.push({ serviceTag: 'Rbac', topicName: 'ConfirmUsage_Out', sqsEndpoint: 'CreateCompleteHdrSqs' });
-      rbacSubs.push({ serviceTag: 'Rbac', topicName: 'CancelUsage_Out', sqsEndpoint: 'CreateCompleteHdrSqs' });
-    }
-  }
 
   if (typeof customRbacFlowTags !== 'undefined' && customRbacFlowTags && customRbacFlowTags.length > 0) {
     const allRbacTags = Array.from(new Set([
@@ -309,7 +303,9 @@ function roleConfigs() {
           Effect: 'Allow',
           Action: ['lambda:InvokeFunction'],
           Resource: [
-            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv', 'Rbac')}`<% if (rbac) { %>,
+            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv', 'Rbac')}`,
+            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ConfirmUsageHdrInv', 'Rbac')}`,
+            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'CancelUsageHdrInv', 'Rbac')}`<% if (rbac) { %>,
             `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv')}`<% } %><% (rbacValidatorServiceTags || []).forEach(function(tag) { %>,
             `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv', '<%= tag %>')}`<% }); %>
           ]

package/src/emit/crud/crudActionPlan.js

@@ -1,12 +1,28 @@
 export const CRUD_ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
 
 export function findHooksForAction(flows = [], action) {
-  if (!Array.isArray(flows)) return [];
-  return flows.filter((f) => {
-    const config = f?.generatedCodeConfig;
-    if (!config) return false;
+  if (!Array.isArray(flows)) {
+    return [];
+  }
+  const actionLower = action?.toLowerCase();
+  return flows.filter((flow) => {
+    const config = flow?.generatedCodeConfig;
+    if (!config) {
+      return false;
+    }
     const tag = config.generateCodeTag || config.generatedCodeTag;
-    return Boolean(tag && tag.toLowerCase() === action.toLowerCase());
+    if (!tag) {
+      return false;
+    }
+    if (Array.isArray(tag)) {
+      return tag.some((t) => {
+        return typeof t === 'string' && t.toLowerCase() === actionLower;
+      });
+    }
+    if (typeof tag === 'string') {
+      return tag.toLowerCase() === actionLower;
+    }
+    return false;
   });
 }
 
@@ -27,6 +43,34 @@ export function createCrudActionPlans(objects = [], flows = []) {
   );
 }
 
+export function resolveHookTargetObjectTypes(hook) {
+  const config = hook?.generatedCodeConfig;
+  const targetObjType = config?.objType ?? config?.objectType;
+  if (targetObjType) {
+    if (typeof targetObjType === 'string') {
+      return [targetObjType];
+    }
+    if (Array.isArray(targetObjType)) {
+      const types = targetObjType
+        .map((t) => (typeof t === 'string' ? t : t?.objectType))
+        .filter(Boolean);
+      if (types.length > 0) {
+        return types;
+      }
+    }
+    if (typeof targetObjType === 'object' && targetObjType?.objectType) {
+      return [targetObjType.objectType];
+    }
+  }
+  if (hook?.objType?.objectType) {
+    return [hook.objType.objectType];
+  }
+  if (typeof hook?.objType === 'string') {
+    return [hook.objType];
+  }
+  return null;
+}
+
 export function createCrudActionPlan(
   action,
   { hasGraph = false, hasRbac = false, isBillable = true, flows = [] } = {}
@@ -35,7 +79,10 @@ export function createCrudActionPlan(
   const outputTopic = action !== 'Get';
   const hasQuotaReservation = action === 'Create' && hasRbac && isBillable;
 
-  const actionHooks = findHooksForAction(flows, action);
+  const actionHooks = findHooksForAction(flows, action).map((h) => ({
+    ...h,
+    targetObjectTypes: resolveHookTargetObjectTypes(h)
+  }));
   const beforeHooks = actionHooks.filter(
     (h) => h?.generatedCodeConfig?.codeHookTag === 'before'
   );
@@ -58,16 +105,27 @@ export function createCrudActionPlan(
   );
   const hasAfterHookCallback = outputTopic && hasAfterHookAsync;
 
+  const hasCreateNodeCallback =
+    outputTopic &&
+    action === 'Create' &&
+    actionHasRbac &&
+    hasGraph &&
+    hasQuotaReservation;
+
+  const hasComplete =
+    outputTopic &&
+    !hasCreateNodeCallback &&
+    (actionHasRbac || hasGraph || hasAfterHookCallback);
+
   return {
     action,
     outputTopic,
     hasGraph: outputTopic && hasGraph,
     hasRbac: actionHasRbac,
     hasQuotaReservation,
-    hasComplete: outputTopic && (actionHasRbac || hasGraph || hasAfterHookCallback),
+    hasComplete,
     hasRbacCallback: false,
-    hasCreateNodeCallback:
-      outputTopic && action === 'Create' && actionHasRbac && hasGraph && hasQuotaReservation,
+    hasCreateNodeCallback,
     hasBeforeHookSync,
     hasBeforeHookAsync,
     hasBeforeHookCallback,

package/src/emit/crud/emitDynamicCrudFlowSchemas.js

@@ -72,8 +72,10 @@ function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user')
         toStepNames: ['RbacCallback']
       }
     );
-  } else if (plan.hasComplete) {
-    const nextStepName = plan.hasCreateNodeCallback ? 'CreateNodeCallback' : 'Complete';
+  } else if (plan.hasComplete || plan.hasCreateNodeCallback) {
+    const nextStepName = plan.hasCreateNodeCallback
+      ? 'CreateNodeCallback'
+      : 'Complete';
     startNextSteps.push({
       targetType: 'ownTopic',
       stepName: nextStepName
@@ -106,7 +108,9 @@ function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user')
   ];
 
   if (plan.hasRbacCallback) {
-    const nextStepName = plan.hasCreateNodeCallback ? 'CreateNodeCallback' : 'Complete';
+    const nextStepName = plan.hasCreateNodeCallback
+      ? 'CreateNodeCallback'
+      : 'Complete';
     const rbacNextSteps = [
       {
         targetType: 'ownTopic',
@@ -162,14 +166,9 @@ function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user')
       ],
       nextSteps: [
         {
-          targetType: 'ownTopic',
-          stepName: 'Complete'
-        },
-        {
-          targetType: 'extTopic',
+          targetType: 'lambdaSyncInv',
           serviceTag: 'Rbac',
-          topicName: 'ConfirmUsage_In',
-          toStepNames: ['Complete']
+          functionName: 'ConfirmUsageHdrInv'
         }
       ],
       properties: [
@@ -184,9 +183,7 @@ function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user')
   }
 
   if (plan.hasComplete) {
-    const prevStepName = plan.hasCreateNodeCallback
-      ? 'CreateNodeCallback'
-      : (plan.hasRbacCallback ? 'RbacCallback' : 'Start');
+    const prevStepName = plan.hasRbacCallback ? 'RbacCallback' : 'Start';
 
     const completePrevSteps = [
       {
@@ -195,14 +192,7 @@ function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user')
       }
     ];
 
-    if (plan.hasCreateNodeCallback) {
-      completePrevSteps.push({
-        sourceType: 'extTopic',
-        serviceTag: 'Rbac',
-        topicName: 'ConfirmUsage_Out',
-        fromStepNames: ['CreateNodeCallback']
-      });
-    } else if (plan.hasGraph) {
+    if (plan.hasGraph) {
       completePrevSteps.push({
         sourceType: 'extTopic',
         serviceTag: 'GraphHandler',
@@ -215,22 +205,15 @@ function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user')
       stepName: 'Complete',
       event: ['extTopic'],
       previousSteps: completePrevSteps,
-      properties: plan.hasCreateNodeCallback
+      properties: plan.hasGraph
         ? [
             'returnValue',
             'parentFlowId',
             'status',
-            'errorsFound'
+            'errorsFound',
+            'graphServiceTag'
           ]
-        : (plan.hasGraph
-            ? [
-                'returnValue',
-                'parentFlowId',
-                'status',
-                'errorsFound',
-                'graphServiceTag'
-              ]
-            : []),
+        : [],
       messageAttributes: MESSAGE_ATTRIBUTES
     });
   }

package/src/emit/crud/templates/CreateEndpoint_Main.ejs

@@ -51,10 +51,6 @@ import {
 //(<optionalRequire>)
 //(</optionalRequire>)
 
-const { createObjType, firstLetterUpperCase } = utils;
-const { createDataDetailsLib } = dataDetailsLib;
-const { createIdentifiersByUseCase } = identifiersObject;
-
 // ── Main Entry Function ───────────────────────────────────────────────────────
 
 /**
@@ -83,7 +79,7 @@ export default async function <%- flowTag %>(
     const errorsFound = [];
 
     // Step 1: Resolve Schema & Identity
-    const { objType, objectSchema, targetIdentifiers } =
+    const { objType, objectSchema } =
       await resolveSchemaAndIdentity(_izContext, requestParams, errorsFound);
 
     //(<beforeQuery>)
@@ -94,8 +90,6 @@ export default async function <%- flowTag %>(
       _izContext,
       requestParams,
       objectSchema,
-      objType,
-      targetIdentifiers,
       errorsFound
     );
 
@@ -167,7 +161,9 @@ export default async function <%- flowTag %>(
         },
         parameterGroups,
         {
-          targetIdentifiers,
+          targetIdentifiers:
+            requestParams.rbacTargetIdentifiers ||
+            requestParams.targetIdentifiers,
           rbacObjType: {
             serviceTag: <%- rbacServiceTags.length === 1 ? rbacServiceTags[0] : `{ ${Object.entries(rbacServiceTagMap).map(([k, v]) => `'${k}': ${v}`).join(', ')} }[requestParams.objectType] || process.env.iz_serviceTag` %>
           },
@@ -198,11 +194,15 @@ export default async function <%- flowTag %>(
 
     // ── Optional phase extension point ────────────────────────────────────────
     <%_
+    const allCrudObjectTypes = (objects || []).filter(isCrudObject).map(o => o.objectType);
     const beforeHooksByObjType = (plan?.beforeHooks || []).reduce((acc, hook) => {
-      const key = hook?.objType?.objectType;
-      if (!key) return acc;
-      if (!acc[key]) acc[key] = [];
-      acc[key].push(hook);
+      const targets = (hook?.targetObjectTypes && hook.targetObjectTypes.length > 0)
+        ? hook.targetObjectTypes
+        : allCrudObjectTypes;
+      for (const key of targets) {
+        if (!acc[key]) acc[key] = [];
+        acc[key].push(hook);
+      }
       return acc;
     }, {});
     _%>
@@ -216,6 +216,15 @@ export default async function <%- flowTag %>(
       const lambdaSyncInvResults = [];
       <%_ for (const config of configs.filter(c => c?.generatedCodeConfig?.invocationType === 'lambdaSyncInv' || c?.event?.includes('lambdaSyncInv'))) { _%>
       try {
+        let hookPayload_<%= config.flowTag %> = {
+          objType,
+          fieldNames: requestParams.fieldNames,
+          relationships: requestParams.relationships || [],
+          targetIdentifiers: requestParams.targetIdentifiers,
+          submittedByUserId: requestParams.submittedByUserId
+        };
+        //(<beforeSendHook_<%= config.flowTag %>>)
+        //(</beforeSendHook_<%= config.flowTag %>>)
         const returnValue = await lambda.invokeSync(
           _izContext,
           await lambdaSharedLib.lambdaFunctionName(
@@ -223,13 +232,7 @@ export default async function <%- flowTag %>(
             '<%= config.flowTag %>'
           ),
           {
-            requestParams: {
-              objType,
-              fieldNames: requestParams.fieldNames,
-              relationships: requestParams.relationships || [],
-              targetIdentifiers,
-              submittedByUserId: requestParams.submittedByUserId
-            },
+            requestParams: hookPayload_<%= config.flowTag %>,
             callingFlowConfig
           }
         );
@@ -274,15 +277,18 @@ export default async function <%- flowTag %>(
       <%_ if (hasOwnTopic) { _%>
       // ── ownTopic (async — dispatch to before-hook and await callback) ──────────
       <%_ configs.filter(c => c?.generatedCodeConfig?.invocationType === 'ownTopic' || c?.event?.includes('ownTopic')).forEach(config => { _%>
+      let hookPayload_<%= config.flowTag %> = {
+        objType,
+        fieldNames: requestParams.fieldNames,
+        relationships: requestParams.relationships || [],
+        targetIdentifiers: requestParams.targetIdentifiers,
+        submittedByUserId: requestParams.submittedByUserId
+      };
+      //(<beforeSendHook_<%= config.flowTag %>>)
+      //(</beforeSendHook_<%= config.flowTag %>>)
       const hookMsg_<%= config.flowTag %> =
         callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-          {
-            objType,
-            fieldNames: requestParams.fieldNames,
-            relationships: requestParams.relationships || [],
-            targetIdentifiers,
-            submittedByUserId: requestParams.submittedByUserId
-          },
+          hookPayload_<%= config.flowTag %>,
           callingFlowSharedLib.addParentCallingFlowConfig(
             callingFlowConfig,
             callingFlowSharedLib.createCallingFlowConfig(
@@ -294,7 +300,7 @@ export default async function <%- flowTag %>(
                 originalRequestParams: {
                   ...requestParams,
                   objType,
-                  targetIdentifiers
+                  targetIdentifiers: requestParams.targetIdentifiers
                 },
                 callingFlowConfig
               }