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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.87",
+  "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

@@ -22,11 +22,66 @@ const VALID_INITIATE_BY_ENUM = [
   'systemNoUser'
 ];
 
+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 =
     VALID_INITIATE_BY_ENUM;
 }
 
+if (
+  basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
+    ?.properties?.codeHookTag
+) {
+  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.codeHookTag.enum =
+    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',
@@ -113,9 +168,101 @@ export async function loadLocalSchemaDirectory(
     if (directoryName === 'FlowSchemas') {
       for (const schema of loadedSchemas) {
         if (Object.prototype.hasOwnProperty.call(schema?.generatedCodeConfig ?? {}, 'codeHookTag')) {
-          throw new Error(
-            `Unsupported FlowHook configuration in ${entry.name}: generatedCodeConfig.codeHookTag is no longer supported`
-          );
+          const hookTag = schema.generatedCodeConfig.codeHookTag;
+          if (hookTag === 'beforeLogical') {
+            throw new Error(
+              `Unsupported FlowHook configuration in ${entry.name}: generatedCodeConfig.codeHookTag is no longer supported`
+            );
+          }
+          if (hookTag !== 'before' && hookTag !== 'after') {
+            throw new Error(
+              `Unsupported FlowHook configuration in ${entry.name}: generatedCodeConfig.codeHookTag '${hookTag}' is invalid. Must be 'before' or 'after'`
+            );
+          }
+        }
+        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`
+            );
+          }
         }
       }
     }
@@ -177,13 +324,55 @@ export async function loadLocalSchemaDirectory(
             { logger },
             schema
           );
-          if (!status && Array.isArray(errors) && VALID_INITIATE_BY_ENUM.includes(schema?.initiateBy)) {
-            errors = errors.filter(
-              (err) =>
-                !err.includes('initiateBy') &&
-                !err.includes('must be equal to one of the allowed values (enum)') &&
-                !(err.includes('should be one of enum') && err.includes(schema?.initiateBy))
-            );
+          if (!status && Array.isArray(errors)) {
+            if (VALID_INITIATE_BY_ENUM.includes(schema?.initiateBy)) {
+              errors = errors.filter(
+                (err) =>
+                  !err.includes('initiateBy') &&
+                  !err.includes('must be equal to one of the allowed values (enum)') &&
+                  !(err.includes('should be one of enum') && err.includes(schema?.initiateBy))
+              );
+            }
+            if (
+              VALID_CODE_HOOK_TAG_ENUM.includes(
+                schema?.generatedCodeConfig?.codeHookTag
+              )
+            ) {
+              errors = errors.filter(
+                (err) =>
+                  !err.includes('codeHookTag') &&
+                  !err.includes('must be equal to one of the allowed values (enum)') &&
+                  !(
+                    err.includes('should be one of enum') &&
+                    err.includes(schema?.generatedCodeConfig?.codeHookTag)
+                  )
+              );
+            }
+            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,6 +1,32 @@
 export const CRUD_ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
 
-export function createCrudActionPlans(objects = []) {
+export function findHooksForAction(flows = [], action) {
+  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;
+    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;
+  });
+}
+
+export function createCrudActionPlans(objects = [], flows = []) {
   const hasGraph = hasGraphStorageResource(objects);
   const hasRbac = objects.some(
     (object) => isCrudObject(object) && hasRbacObject(object, objects)
@@ -12,29 +38,102 @@ export function createCrudActionPlans(objects = []) {
   return Object.fromEntries(
     CRUD_ACTIONS.map((action) => [
       action,
-      createCrudActionPlan(action, { hasGraph, hasRbac, isBillable })
+      createCrudActionPlan(action, { hasGraph, hasRbac, isBillable, 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 } = {}
+  { hasGraph = false, hasRbac = false, isBillable = true, flows = [] } = {}
 ) {
   const actionHasRbac = action !== 'Get' && hasRbac;
   const outputTopic = action !== 'Get';
   const hasQuotaReservation = action === 'Create' && hasRbac && isBillable;
 
+  const actionHooks = findHooksForAction(flows, action).map((h) => ({
+    ...h,
+    targetObjectTypes: resolveHookTargetObjectTypes(h)
+  }));
+  const beforeHooks = actionHooks.filter(
+    (h) => h?.generatedCodeConfig?.codeHookTag === 'before'
+  );
+  const afterHooks = actionHooks.filter(
+    (h) => h?.generatedCodeConfig?.codeHookTag === 'after'
+  );
+  const hasBeforeHookSync = beforeHooks.some(
+    (h) => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv'
+  );
+  const hasBeforeHookAsync = beforeHooks.some(
+    (h) => h?.generatedCodeConfig?.invocationType === 'ownTopic'
+  );
+  const hasBeforeHookCallback = outputTopic && hasBeforeHookAsync;
+
+  const hasAfterHookSync = afterHooks.some(
+    (h) => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv'
+  );
+  const hasAfterHookAsync = afterHooks.some(
+    (h) => h?.generatedCodeConfig?.invocationType === 'ownTopic'
+  );
+  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),
+    hasComplete,
     hasRbacCallback: false,
-    hasCreateNodeCallback:
-      outputTopic && action === 'Create' && actionHasRbac && hasGraph && hasQuotaReservation
+    hasCreateNodeCallback,
+    hasBeforeHookSync,
+    hasBeforeHookAsync,
+    hasBeforeHookCallback,
+    hasAfterHookSync,
+    hasAfterHookAsync,
+    hasAfterHookCallback,
+    beforeHooks,
+    afterHooks
   };
 }
 

package/src/emit/crud/emitCrudApplicationArtifacts.js

@@ -51,7 +51,7 @@ export async function emitCrudApplicationArtifacts({
   }
 
   const handlers = await Promise.all(
-    ACTIONS.map((action) => emitAction(action, objects, serviceTag))
+    ACTIONS.map((action) => emitAction(action, objects, serviceTag, flows))
   );
   return [
     ...handlers.flatMap((handler) => handler.artifacts),
@@ -88,6 +88,10 @@ export function crudApplicationManagedPaths() {
           `${source}/${action}RbacCallback_HdrSqs.js`,
           `${source}/${action}NodeCallback_Main.js`,
           `${source}/${action}NodeCallback_HdrSqs.js`,
+          `${source}/${action}BeforeHookCallback_Main.js`,
+          `${source}/${action}BeforeHookCallback_HdrSqs.js`,
+          `${source}/${action}AfterHookCallback_Main.js`,
+          `${source}/${action}AfterHookCallback_HdrSqs.js`,
           `${source}/${action}Complete_Main.js`,
           `${source}/${action}Complete_HdrSqs.js`
         );
@@ -98,10 +102,10 @@ export function crudApplicationManagedPaths() {
   ];
 }
 
-async function emitAction(action, objects, serviceTag) {
+async function emitAction(action, objects, serviceTag, flows = []) {
   const source = `app/src/generatedCode/FlowObjects/${action}/source`;
   const handlerRoot = `src/generatedCode/FlowObjects/${action}/source`;
-  const plan = createCrudActionPlans(objects)[action];
+  const plan = createCrudActionPlans(objects, flows)[action];
   const mainFileName = `${action}_Main`;
   const shared = {
     flowTag: action,
@@ -326,6 +330,62 @@ async function emitAction(action, objects, serviceTag) {
     });
   }
 
+  if (plan.hasBeforeHookCallback) {
+    const beforeHookCallbackMain = `${action}BeforeHookCallback_Main`;
+    artifacts.push(
+      {
+        path: `${source}/${beforeHookCallbackMain}.js`,
+        content: await render(`${action}BeforeHookCallback_Main.ejs`, shared)
+      },
+      {
+        path: `${source}/${action}BeforeHookCallback_HdrSqs.js`,
+        content: await renderShared('FlowHandler_HdrSqs.ejs', {
+          ...shared,
+          mainFileName: beforeHookCallbackMain,
+          functionName: `${action}BeforeHookCallbackMain`,
+          queueName: `${action}BeforeHookCallbackHdrSqs`
+        })
+      }
+    );
+    functions.push({
+      type: 'sqs',
+      functionName: `${action}BeforeHookCallbackHdrSqs`,
+      handlerPath: `${handlerRoot}/${action}BeforeHookCallback_HdrSqs.main`,
+      roleName: 'FlowObjectsRole',
+      queueName: `${action}BeforeHookCallbackHdrSqs`,
+      flowTag: action,
+      flowStepName: 'BeforeHookCallback'
+    });
+  }
+
+  if (plan.hasAfterHookCallback) {
+    const afterHookCallbackMain = `${action}AfterHookCallback_Main`;
+    artifacts.push(
+      {
+        path: `${source}/${afterHookCallbackMain}.js`,
+        content: await render(`${action}AfterHookCallback_Main.ejs`, shared)
+      },
+      {
+        path: `${source}/${action}AfterHookCallback_HdrSqs.js`,
+        content: await renderShared('FlowHandler_HdrSqs.ejs', {
+          ...shared,
+          mainFileName: afterHookCallbackMain,
+          functionName: `${action}AfterHookCallbackMain`,
+          queueName: `${action}AfterHookCallbackHdrSqs`
+        })
+      }
+    );
+    functions.push({
+      type: 'sqs',
+      functionName: `${action}AfterHookCallbackHdrSqs`,
+      handlerPath: `${handlerRoot}/${action}AfterHookCallback_HdrSqs.main`,
+      roleName: 'FlowObjectsRole',
+      queueName: `${action}AfterHookCallbackHdrSqs`,
+      flowTag: action,
+      flowStepName: 'AfterHookCallback'
+    });
+  }
+
   if (plan.hasComplete) {
     const completeMain = `${action}Complete_Main`;
     let templateName = `${action}Complete_Main.ejs`;

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
     });
   }