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

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

@@ -167,18 +167,36 @@ export default async function CreateNodeCallbackMain(
           _izContext.correlationIds?.get(coreConsts.SUBMITTED_BY_USER_ID) ||
           _izContext.correlationIds?.get('submittedByUserId');
 
+        <%_ const rootRbacObjs = (objects || []).filter(obj => {
+          const hasSelfRbac = Array.isArray(obj?.addOnDataStructure) && obj.addOnDataStructure.some(addOn => addOn?.type === 'rbac');
+          return hasSelfRbac && !obj?.belongTo && obj?.objectType !== 'user' && obj?.generatedBy !== 'systemNoUser';
+        }); _%>
+        <%_ if (rootRbacObjs.length > 0) { _%>
         await autoProvisionOwnerTargetRole(_izContext, {
           node,
-          submittedByUserId
+          submittedByUserId,
+          objType: returnValue?.requestParams?.objType
         });
+        <%_ } _%>
 
         <%_ if (plan?.hasAfterHookSync) { _%>
         // ── Synchronous After Hooks ──
         <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv').forEach(hook => { _%>
-        <%_ if (hook.objType?.objectType) { _%>
-        if (returnValue.requestParams?.objType?.objectType === '<%= hook.objType.objectType %>') {
+        <%_ 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
+          };
+          //(<beforeSendHook_<%= hook.flowTag %>>)
+          //(</beforeSendHook_<%= hook.flowTag %>>)
           const hookResult = await lambda.invokeSync(
             _izContext,
             await lambdaSharedLib.lambdaFunctionName(
@@ -186,13 +204,7 @@ export default async function CreateNodeCallbackMain(
               '<%= hook.flowTag %>'
             ),
             {
-              requestParams: {
-                objType: returnValue.requestParams.objType,
-                objInstanceFull: node.objInstanceFull,
-                relationships: node.relationships || [],
-                targetIdentifiers: requestParams.targetIdentifiers,
-                submittedByUserId
-              },
+              requestParams: hookPayload_<%= hook.flowTag %>,
               callingFlowConfig
             }
           );
@@ -203,7 +215,7 @@ export default async function CreateNodeCallbackMain(
           _izContext.logger.error('[CreateNodeCallback] Sync hook <%= hook.flowTag %> error:', hookErr);
           errorsFound.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
         }
-        <%_ if (hook.objType?.objectType) { _%>
+        <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
         }
         <%_ } _%>
         <%_ }) _%>
@@ -238,17 +250,22 @@ export default async function CreateNodeCallbackMain(
       <%_ if (plan?.hasAfterHookAsync) { _%>
       // ── Asynchronous After Hooks ──
       <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'ownTopic').forEach(hook => { _%>
-      <%_ if (hook.objType?.objectType) { _%>
-      if (returnValue.requestParams?.objType?.objectType === '<%= hook.objType.objectType %>') {
+      <%_ 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,
+        submittedByUserId
+      };
+      //(<beforeSendHook_<%= hook.flowTag %>>)
+      //(</beforeSendHook_<%= hook.flowTag %>>)
       const hookMsg_<%= hook.flowTag %> = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-        {
-          objType: returnValue.requestParams.objType,
-          objInstanceFull: node.objInstanceFull,
-          relationships: node.relationships || [],
-          targetIdentifiers: requestParams.targetIdentifiers,
-          submittedByUserId
-        },
+        hookPayload_<%= hook.flowTag %>,
         callingFlowSharedLib.addParentCallingFlowConfig(
           callingFlowConfig,
           callingFlowSharedLib.createCallingFlowConfig(
@@ -272,7 +289,7 @@ export default async function CreateNodeCallbackMain(
         Message: JSON.stringify(hookMsg_<%= hook.flowTag %>),
         MessageAttributes: sns.createStringMessageAttributes(_izContext, {})
       });
-      <%_ if (hook.objType?.objectType) { _%>
+      <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
       }
       <%_ } _%>
       <%_ }) _%>

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

@@ -0,0 +1,118 @@
+/*
+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 Delete
+ * @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 DeleteAfterHookCallbackMain(
+  _izContext,
+  requestParams,
+  passBackProperties
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug('[DeleteAfterHookCallback] 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,
+        identifiers:
+          returnValue?.identifiers || requestParams?.identifiers || {},
+        targetIdentifiers: requestParams?.targetIdentifiers,
+        parentFlowId: parentFlowId || returnValue?.parentFlowId,
+        status: mergedErrors.length > 0 ? 'error' : 'complete',
+        errorsFound: mergedErrors
+      };
+
+    const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      TOPIC_NAME_GENERATE_CODE.outDeleteNodeComplete
+    );
+
+    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('[DeleteAfterHookCallback] error:', error);
+    throw error;
+  }
+}

package/src/emit/crud/templates/DeleteComplete_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,127 @@ export default async function DeleteComplete(
       const callingFlowConfig =
         result?.additionalAttributes?.callingFlowConfig ||
         passBackProperties;
+      const actionData = {
+        objType: returnValue.requestParams.objType,
+        objInstanceFull: node.objInstanceFull,
+        identifiers:
+          node.objInstanceFull?.identifiers ||
+          requestParams?.targetIdentifiers ||
+          {},
+        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,
+          identifiers:
+            node.objInstanceFull?.identifiers ||
+            requestParams.targetIdentifiers ||
+            {},
+          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(
+          '[DeleteComplete] 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,
+        identifiers:
+          node.objInstanceFull?.identifiers ||
+          requestParams.targetIdentifiers ||
+          {},
+        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,
+                'DeleteAfterHookCallbackHdrSqs'
+              ),
+              {
+                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 +289,7 @@ export default async function DeleteComplete(
         ),
         TopicArn: topicArn
       });
+      <%_ } _%>
       //(<afterSendMessage>)
       //(</afterSendMessage>)
     }

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

@@ -188,11 +188,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;
     }, {});
     _%>
@@ -206,6 +210,14 @@ 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,
+          identifiers: requestParams.identifiers,
+          targetIdentifiers,
+          submittedByUserId: requestParams.submittedByUserId
+        };
+        //(<beforeSendHook_<%= config.flowTag %>>)
+        //(</beforeSendHook_<%= config.flowTag %>>)
         const returnValue = await lambda.invokeSync(
           _izContext,
           await lambdaSharedLib.lambdaFunctionName(
@@ -213,12 +225,7 @@ export default async function <%- flowTag %>(
             '<%= config.flowTag %>'
           ),
           {
-            requestParams: {
-              objType,
-              identifiers: requestParams.identifiers,
-              targetIdentifiers,
-              submittedByUserId: requestParams.submittedByUserId
-            },
+            requestParams: hookPayload_<%= config.flowTag %>,
             callingFlowConfig
           }
         );
@@ -260,14 +267,17 @@ 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,
+        identifiers: requestParams.identifiers,
+        targetIdentifiers,
+        submittedByUserId: requestParams.submittedByUserId
+      };
+      //(<beforeSendHook_<%= config.flowTag %>>)
+      //(</beforeSendHook_<%= config.flowTag %>>)
       const hookMsg_<%= config.flowTag %> =
         callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-          {
-            objType,
-            identifiers: requestParams.identifiers,
-            targetIdentifiers,
-            submittedByUserId: requestParams.submittedByUserId
-          },
+          hookPayload_<%= config.flowTag %>,
           callingFlowSharedLib.addParentCallingFlowConfig(
             callingFlowConfig,
             callingFlowSharedLib.createCallingFlowConfig(

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

@@ -100,9 +100,7 @@ export async function resolveSchemaAndIdentity(
 
     requestParams.submittedByUserId = submittedByUserId;
     if (targetIdentifiers) {
-      if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
-        targetIdentifiers.submittedByUserId = submittedByUserId;
-      }
+      requestParams.targetIdentifiers = targetIdentifiers;
     }
 
     _izContext.logger.debug(
@@ -274,6 +272,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,
@@ -304,12 +407,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) {