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

package/package.json

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

@@ -1,8 +1,12 @@
 import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
 import snsSharedLib from '@izara_project/izara-core-library-sns';
-import { sns } from '@izara_project/izara-core-library-external-request';
+import {
+  sns,
+  lambda
+} from '@izara_project/izara-core-library-external-request';
 import { consts } from '@izara_project/izara-core-library-service-schemas';
 import { NoRetryError } from '@izara_project/izara-core-library-core';
 
@@ -142,18 +146,138 @@ export default async function CreateComplete(
       const callingFlowConfig =
         result?.additionalAttributes?.callingFlowConfig ||
         passBackProperties;
+      const actionData = {
+        objType: returnValue.requestParams.objType,
+        objInstanceFull: node.objInstanceFull,
+        relationships: node.relationships,
+        parentFlowId: parentFlowId || returnValue?.parentFlowId,
+        existsNode,
+        status,
+        errorsFound
+      };
+
+      <%_ if (plan?.hasAfterHookSync) { _%>
+      // ── Synchronous After Hooks ──
+      <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv').forEach(hook => { _%>
+      <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length === 1) { _%>
+      if (returnValue.requestParams?.objType?.objectType === '<%= hook.targetObjectTypes[0] %>') {
+      <%_ } else if (hook.targetObjectTypes && hook.targetObjectTypes.length > 1) { _%>
+      if (<%- JSON.stringify(hook.targetObjectTypes) %>.includes(returnValue.requestParams?.objType?.objectType)) {
+      <%_ } _%>
+      try {
+        let hookPayload_<%= hook.flowTag %> = {
+          objType: returnValue.requestParams.objType,
+          objInstanceFull: node.objInstanceFull,
+          relationships: node.relationships || [],
+          targetIdentifiers: requestParams.targetIdentifiers,
+          submittedByUserId: returnValue?.requestParams?.submittedByUserId || requestParams?.submittedByUserId
+        };
+        //(<beforeSendHook_<%= hook.flowTag %>>)
+        //(</beforeSendHook_<%= hook.flowTag %>>)
+        const hookResult = await lambda.invokeSync(
+          _izContext,
+          await lambdaSharedLib.lambdaFunctionName(
+            _izContext,
+            '<%= hook.flowTag %>'
+          ),
+          {
+            requestParams: hookPayload_<%= hook.flowTag %>,
+            callingFlowConfig
+          }
+        );
+        if (hookResult?.errorsFound?.length > 0 || hookResult?.status === 'error') {
+          errorsFound.push(...(hookResult.errorsFound || ['Hook <%= hook.flowTag %> failed']));
+        }
+      } catch (hookErr) {
+        _izContext.logger.error('[CreateComplete] Sync hook <%= hook.flowTag %> error:', hookErr);
+        errorsFound.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
+      }
+      <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
+      }
+      <%_ } _%>
+      <%_ }) _%>
+      <%_ } _%>
+
+      <%_ if (plan?.hasAfterHookAsync) { _%>
+      // ── Asynchronous After Hooks ──
+      let afterHookDispatched = false;
+      <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'ownTopic').forEach(hook => { _%>
+      <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length === 1) { _%>
+      if (returnValue.requestParams?.objType?.objectType === '<%= hook.targetObjectTypes[0] %>') {
+      <%_ } else if (hook.targetObjectTypes && hook.targetObjectTypes.length > 1) { _%>
+      if (<%- JSON.stringify(hook.targetObjectTypes) %>.includes(returnValue.requestParams?.objType?.objectType)) {
+      <%_ } _%>
+        afterHookDispatched = true;
+        let hookPayload_<%= hook.flowTag %> = {
+          objType: returnValue.requestParams.objType,
+          objInstanceFull: node.objInstanceFull,
+          relationships: node.relationships || [],
+          targetIdentifiers: requestParams.targetIdentifiers,
+          submittedByUserId: returnValue?.requestParams?.submittedByUserId || requestParams?.submittedByUserId
+        };
+        //(<beforeSendHook_<%= hook.flowTag %>>)
+        //(</beforeSendHook_<%= hook.flowTag %>>)
+        const hookMsg_<%= hook.flowTag %> = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+          hookPayload_<%= hook.flowTag %>,
+          callingFlowSharedLib.addParentCallingFlowConfig(
+            callingFlowConfig,
+            callingFlowSharedLib.createCallingFlowConfig(
+              await lambdaSharedLib.lambdaFunctionName(
+                _izContext,
+                'CreateAfterHookCallbackHdrSqs'
+              ),
+              {
+                actionData
+              }
+            )
+          )
+        );
+
+        await sns.publishAsync(_izContext, {
+          TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+            _izContext,
+            '<%= hook.flowTag %>_In'
+          ),
+          Message: JSON.stringify(hookMsg_<%= hook.flowTag %>),
+          MessageAttributes: sns.createStringMessageAttributes(_izContext, {})
+        });
+      <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
+      }
+      <%_ } _%>
+      <%_ }) _%>
+      if (!afterHookDispatched) {
+        const message =
+          callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
+            callingFlowConfig,
+            actionData
+          );
+        const messageAttributes =
+          callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
+            callingFlowConfig,
+            {}
+          );
+        const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
+          _izContext,
+          TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete
+        );
+        _izContext.logger.debug('[CreateComplete] publishing to SNS', {
+          TopicArn: topicArn,
+          message
+        });
+        await sns.publishAsync(_izContext, {
+          Message: JSON.stringify(message),
+          MessageAttributes: sns.createStringMessageAttributes(
+            _izContext,
+            messageAttributes
+          ),
+          TopicArn: topicArn
+        });
+      }
+      <%_ } else { _%>
       const message =
         callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
           callingFlowConfig,
-          {
-            objType: returnValue.requestParams.objType,
-            objInstanceFull: node.objInstanceFull,
-            relationships: node.relationships,
-            parentFlowId: parentFlowId || returnValue?.parentFlowId,
-            existsNode,
-            status,
-            errorsFound
-          }
+          actionData
         );
       const messageAttributes =
         callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
@@ -176,6 +300,7 @@ export default async function CreateComplete(
         ),
         TopicArn: topicArn
       });
+      <%_ } _%>
       //(<afterSendMessage>)
       //(</afterSendMessage>)
     }