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

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

@@ -46,6 +46,135 @@ const { TOPIC_NAME_GENERATE_CODE } = consts;
 //(<optionalRequire>)
 //(</optionalRequire>)
 
+// ── 1. Delete_Main Helpers ───────────────────────────────────────────────────
+
+/**
+ * Loads ObjectSchema and resolves submittedByUserId and targetIdentifiers
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} requestParams - Incoming request parameters
+ * @param {Array<string>} errorsFound - Array to collect validation errors
+ * @returns {Promise<{ objType: string, objectSchema: Object, targetIdentifiers?: Object }>}
+ */
+export async function resolveSchemaAndIdentity(
+  _izContext,
+  requestParams,
+  errorsFound
+) {
+  const objType = createObjType(requestParams.objectType);
+  const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
+    _izContext,
+    objType
+  );
+  _izContext.logger.debug(
+    `[${process.env.iz_serviceTag}:<%- flowTag %>] objectSchema:`,
+    objectSchema
+  );
+
+  let submittedByUserId;
+  let targetIdentifiers;
+  if (
+    objectSchema.generatedBy === 'user' ||
+    objectSchema.generatedBy === 'systemWithUser'
+  ) {
+    submittedByUserId =
+      requestParams.submittedByUserId ||
+      _izContext.correlationIds.get(coreConsts.SUBMITTED_BY_USER_ID);
+
+    targetIdentifiers = requestParams.targetIdentifiers;
+    delete requestParams.targetIdentifiers;
+
+    if (
+      !targetIdentifiers &&
+      objectSchema.belongTo?.objectType === 'user' &&
+      submittedByUserId
+    ) {
+      targetIdentifiers = { submittedByUserId };
+    }
+
+    if (!submittedByUserId) {
+      errorsFound.push('Not have submittedByUserId');
+    }
+    if (objectSchema.hasOwnProperty('belongTo') && !targetIdentifiers) {
+      errorsFound.push('not have targetIdentifiers');
+    }
+
+    requestParams.submittedByUserId = submittedByUserId;
+    if (targetIdentifiers) {
+      if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
+        targetIdentifiers.submittedByUserId = submittedByUserId;
+      }
+    }
+
+    _izContext.logger.debug(
+      `[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`,
+      {
+        submittedByUserId: requestParams.submittedByUserId,
+        targetIdentifiers,
+        belongTo: objectSchema.belongTo,
+        generatedBy: objectSchema.generatedBy
+      }
+    );
+  }
+
+  return { objType, objectSchema, targetIdentifiers };
+}
+
+/**
+ * Handles delete errors and publishes error response
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} options - Error context details
+ * @returns {Promise<Object>} Error status result
+ */
+export async function handleDeleteError(
+  _izContext,
+  {
+    objType,
+    identifiers,
+    targetIdentifiers,
+    callingFlowConfig,
+    errorsFound
+  }
+) {
+  const deleteNodeCompleteMessage =
+    callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
+      callingFlowConfig,
+      {
+        objType,
+        identifiers,
+        targetIdentifiers,
+        status: 'error',
+        errorsFound
+      }
+    );
+
+  _izContext.logger.debug(
+    'messageParams OutDeleteNodeComplete::',
+    deleteNodeCompleteMessage
+  );
+  await sns.publishAsync(_izContext, {
+    Message: JSON.stringify(deleteNodeCompleteMessage),
+    MessageAttributes: sns.createStringMessageAttributes(
+      _izContext,
+      callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+        callingFlowConfig,
+        {}
+      )
+    ),
+    TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      TOPIC_NAME_GENERATE_CODE.outDeleteNodeComplete
+    )
+  });
+
+  return {
+    objType,
+    identifiers,
+    targetIdentifiers,
+    status: 'error',
+    errorsFound
+  };
+}
+
 /**
  * Core logical processing library
  * @param {Object} _izContext - Context object with logger
@@ -93,36 +222,13 @@ export async function <%- flowTag %>LogicalLib(
 
     // ── Early exit on errors ──────────────────────────────────────────────────
     if (errorsFound.length) {
-      const deleteNodeCompleteMessage =
-        callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
-          callingFlowConfig,
-          {
-            objType,
-            identifiers: requestParams.identifiers,
-            status: 'error',
-            errorsFound
-          }
-        );
-
-      _izContext.logger.debug(
-        'messageParams OutDeleteNodeComplete::',
-        deleteNodeCompleteMessage
-      );
-      await sns.publishAsync(_izContext, {
-        Message: JSON.stringify(deleteNodeCompleteMessage),
-        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
-          _izContext,
-          TOPIC_NAME_GENERATE_CODE.outDeleteNodeComplete
-        )
-      });
-
-      return {
+      return await handleDeleteError(_izContext, {
         objType,
         identifiers: requestParams.identifiers,
         targetIdentifiers: requestParams.targetIdentifiers,
-        status: 'error',
+        callingFlowConfig,
         errorsFound
-      };
+      });
     }
 
     //(<validateBeforeDelete>)
@@ -168,6 +274,111 @@ export async function <%- flowTag %>LogicalLib(
     }
 
     // ── Complete ──────────────────────────────────────────────────────────────
+    <%_ if (plan?.hasAfterHookSync) { _%>
+    // ── Synchronous After Hooks ──
+    <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv').forEach(hook => { _%>
+    <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length === 1) { _%>
+    if (objType?.objectType === '<%= hook.targetObjectTypes[0] %>') {
+    <%_ } else if (hook.targetObjectTypes && hook.targetObjectTypes.length > 1) { _%>
+    if (<%- JSON.stringify(hook.targetObjectTypes) %>.includes(objType?.objectType)) {
+    <%_ } _%>
+    try {
+      let hookPayload_<%= hook.flowTag %> = {
+        objType,
+        identifiers: requestParams.identifiers,
+        relationships: requestParams.relationships || [],
+        targetIdentifiers: requestParams.targetIdentifiers,
+        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(
+        '[<%- flowTag %>LogicalLib] 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 ──
+    <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'ownTopic').forEach(hook => { _%>
+    <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length === 1) { _%>
+    if (objType?.objectType === '<%= hook.targetObjectTypes[0] %>') {
+    <%_ } else if (hook.targetObjectTypes && hook.targetObjectTypes.length > 1) { _%>
+    if (<%- JSON.stringify(hook.targetObjectTypes) %>.includes(objType?.objectType)) {
+    <%_ } _%>
+    let hookPayload_<%= hook.flowTag %> = {
+      objType,
+      identifiers: requestParams.identifiers,
+      relationships: requestParams.relationships || [],
+      targetIdentifiers: requestParams.targetIdentifiers,
+      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,
+              'DeleteAfterHookCallbackHdrSqs'
+            ),
+            {
+              actionData: {
+                objType,
+                identifiers: requestParams.identifiers,
+                relationships: requestParams.relationships || [],
+                targetIdentifiers: requestParams.targetIdentifiers,
+                parentFlowId: requestParams.parentFlowId,
+                status: 'complete',
+                errorsFound
+              }
+            }
+          )
+        )
+      );
+
+    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) { _%>
+    }
+    <%_ } _%>
+    <%_ }) _%>
+    <%_ } else { _%>
     const outMessage =
       callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
         callingFlowConfig,
@@ -198,12 +409,18 @@ export async function <%- flowTag %>LogicalLib(
         )
       });
     }
+    <%_ } _%>
+
+    let resultStatus = 'complete';
+    if (errorsFound.length > 0) {
+      resultStatus = 'error';
+    }
 
     return {
       objType,
       identifiers: requestParams.identifiers,
       targetIdentifiers: requestParams.targetIdentifiers,
-      status: 'complete',
+      status: resultStatus,
       errorsFound
     };
   } catch (err) {

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

@@ -0,0 +1,120 @@
+/*
+Copyright (C) 2026 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { sns } from '@izara_project/izara-core-library-external-request';
+import { consts } from '@izara_project/izara-core-library-service-schemas';
+
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+const { TOPIC_NAME_GENERATE_CODE } = consts;
+
+/**
+ * Handles callback after async AfterHook completion for Update
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} requestParams - Callback request parameters
+ * @param {Object} passBackProperties - Pass-back properties
+ * @returns {Promise<Object>} Result object
+ */
+export default async function UpdateAfterHookCallbackMain(
+  _izContext,
+  requestParams,
+  passBackProperties
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug('[UpdateAfterHookCallback] started', {
+      requestParams,
+      passBackProperties
+    });
+
+    const {
+      status,
+      errorsFound = [],
+      returnValue,
+      parentFlowId
+    } = requestParams;
+
+    const mergedErrors = Array.isArray(errorsFound) ? [...errorsFound] : [];
+    if (status === 'error' && mergedErrors.length === 0) {
+      mergedErrors.push('AfterHook execution reported error');
+    }
+
+    const callingFlowConfig =
+      passBackProperties?.callingFlowConfig ||
+      requestParams?.passBackProperties?.callingFlowConfig ||
+      passBackProperties;
+
+    const actionData =
+      passBackProperties?.actionData ||
+      requestParams?.passBackProperties?.actionData ||
+      {
+        objType: returnValue?.objType || requestParams?.objType,
+        objInstanceFull:
+          returnValue?.objInstanceFull || requestParams?.objInstanceFull,
+        relationships:
+          returnValue?.relationships || requestParams?.relationships || [],
+        targetIdentifiers: requestParams?.targetIdentifiers,
+        parentFlowId: parentFlowId || returnValue?.parentFlowId,
+        status: mergedErrors.length > 0 ? 'error' : 'complete',
+        errorsFound: mergedErrors
+      };
+
+    const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete
+    );
+
+    const completionPayload =
+      callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
+        callingFlowConfig,
+        {
+          ...actionData,
+          status: mergedErrors.length > 0 ? 'error' : 'complete',
+          errorsFound: mergedErrors
+        }
+      );
+
+    await sns.publishAsync(_izContext, {
+      TopicArn: topicArn,
+      Message: JSON.stringify(completionPayload),
+      MessageAttributes: sns.createStringMessageAttributes(
+        _izContext,
+        callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
+          callingFlowConfig,
+          {}
+        )
+      )
+    });
+
+    //(<afterProcessCallback>)
+    //(</afterProcessCallback>)
+
+    return {
+      returnValue,
+      status: mergedErrors.length > 0 ? 'error' : 'complete',
+      errorsFound: mergedErrors
+    };
+  } catch (error) {
+    _izContext.logger.error('[UpdateAfterHookCallback] error:', error);
+    throw error;
+  }
+}

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

@@ -0,0 +1,112 @@
+/*
+Copyright (C) 2026 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import {
+  <%- flowTag %>LogicalLib,
+  handleUpdateError
+} from './<%- upperCaseFlowTag %>LogicalLib.js';
+
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+/**
+ * Handles callback after async BeforeHook completion
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} requestParams - Callback request parameters
+ * @param {Object} passBackProperties - Pass-back properties
+ * @returns {Promise<Object>} Result object
+ */
+export default async function <%- upperCaseFlowTag %>BeforeHookCallbackMain(
+  _izContext,
+  requestParams,
+  passBackProperties
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug('[<%- upperCaseFlowTag %>BeforeHookCallback] started', {
+      requestParams,
+      passBackProperties
+    });
+
+    const {
+      status,
+      errorsFound = [],
+      returnValue,
+      parentFlowId
+    } = requestParams;
+
+    const mergedErrors = Array.isArray(errorsFound) ? [...errorsFound] : [];
+    if (status === 'error' && mergedErrors.length === 0) {
+      mergedErrors.push('BeforeHook execution reported error');
+    }
+
+    const callingFlowConfig =
+      passBackProperties?.callingFlowConfig ||
+      requestParams?.passBackProperties?.callingFlowConfig ||
+      {};
+
+    const originalRequestParams =
+      passBackProperties?.originalRequestParams ||
+      requestParams?.passBackProperties?.originalRequestParams ||
+      passBackProperties?.requestParams ||
+      passBackProperties;
+
+    if (mergedErrors.length > 0) {
+      _izContext.logger.warn(
+        '[<%- upperCaseFlowTag %>BeforeHookCallback] BeforeHook reported errors:',
+        mergedErrors
+      );
+      return await handleUpdateError(_izContext, {
+        objType: originalRequestParams?.objType,
+        identifiers:
+          originalRequestParams?.objInstanceFull?.identifiers ||
+          originalRequestParams?.identifiers ||
+          {},
+        fields:
+          originalRequestParams?.objInstanceFull?.fields ||
+          {},
+        versionedDataIds: originalRequestParams?.versionedDataIds,
+        callingFlowConfig,
+        errorsFound: mergedErrors
+      });
+    }
+
+    if (returnValue?.fields && originalRequestParams?.objInstanceFull?.fields) {
+      Object.assign(originalRequestParams.objInstanceFull.fields, returnValue.fields);
+    } else if (returnValue?.fieldNames && originalRequestParams?.objInstanceFull?.fields) {
+      Object.assign(originalRequestParams.objInstanceFull.fields, returnValue.fieldNames);
+    } else if (returnValue?.fieldNames && originalRequestParams?.fieldNames) {
+      Object.assign(originalRequestParams.fieldNames, returnValue.fieldNames);
+    }
+    if (returnValue?.relationships && originalRequestParams) {
+      originalRequestParams.relationships = returnValue.relationships;
+    }
+
+    //(<beforeLogicalExecution>)
+    //(</beforeLogicalExecution>)
+
+    return await <%- flowTag %>LogicalLib(
+      _izContext,
+      originalRequestParams,
+      callingFlowConfig
+    );
+  } catch (error) {
+    _izContext.logger.error('[<%- upperCaseFlowTag %>BeforeHookCallback] error:', error);
+    throw error;
+  }
+}

package/src/emit/crud/templates/UpdateComplete_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,107 @@ export default async function UpdateComplete(
       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
+        };
+        //(<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('[UpdateComplete] 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 ──
+      <%_ 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)) {
+      <%_ } _%>
+      let hookPayload_<%= hook.flowTag %> = {
+        objType: returnValue.requestParams.objType,
+        objInstanceFull: node.objInstanceFull,
+        relationships: node.relationships || [],
+        targetIdentifiers: requestParams.targetIdentifiers
+      };
+      //(<beforeSendHook_<%= hook.flowTag %>>)
+      //(</beforeSendHook_<%= hook.flowTag %>>)
+      const hookMsg_<%= hook.flowTag %> = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+        hookPayload_<%= hook.flowTag %>,
+        callingFlowSharedLib.addParentCallingFlowConfig(
+          callingFlowConfig,
+          callingFlowSharedLib.createCallingFlowConfig(
+            await lambdaSharedLib.lambdaFunctionName(
+              _izContext,
+              'UpdateAfterHookCallbackHdrSqs'
+            ),
+            {
+              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) { _%>
+      }
+      <%_ } _%>
+      <%_ }) _%>
+      <%_ } 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 +269,7 @@ export default async function UpdateComplete(
         ),
         TopicArn: topicArn
       });
+      <%_ } _%>
       //(<afterSendMessage>)
       //(</afterSendMessage>)
     }