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

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

@@ -122,7 +122,11 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
       //   }
       // }
 
-      // requestParams.targetIdentifiers = targetIdentifiers;
+      requestParams.targetIdentifiers = targetIdentifiers;
+    }
+
+    if (requestParams.rbacTargetIdentifiers === undefined && targetIdentifiers) {
+      requestParams.rbacTargetIdentifiers = targetIdentifiers;
     }
 
     _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`, {
@@ -140,50 +144,161 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
 }
 
 /**
- * Resolves and generates primary identifiers for the object
+ * Resolves fromRequiredOnCreate fields and generates identifiers
  * @param {Object} _izContext - Izara context object
- * @param {Object} objectSchemas - Combined object schema
- * @param {Object} requestParams - Incoming request parameters
- * @returns {Promise<void>}
+ * @param {Object} requestParams - Request parameters
+ * @param {Object} objectSchema - Base object schema
+ * @param {Array<string>} errorsFound - Error list
+ * @returns {Promise<{ objectSchemas: Object }>}
  */
-export async function resolveAndGenerateIdentifiers(_izContext, objectSchemas, requestParams) {
-  const identifiers = await createIdentifiersByUseCase(
-    _izContext,
-    objectSchemas,
-    requestParams.fieldNames
+export async function resolveAndGenerateIdentifiers(
+  _izContext,
+  requestParams,
+  objectSchema,
+  errorsFound
+) {
+  const objType = createObjType(requestParams.objectType);
+  const targetIdentifiers = requestParams.targetIdentifiers;
+
+  const objectSchemas =
+    uploadUseCase.generateObjectSchemaForCombineFieldNames(
+      _izContext,
+      objectSchema
+    );
+  _izContext.logger.debug(
+    `[${process.env.iz_serviceTag}:<%- flowTag %>] objectSchemas:`,
+    objectSchemas
+  );
+
+  errorsFound.push(
+    ...(await createNodeLib.validateRequiredOnCreateLinks(
+      _izContext,
+      objType,
+      requestParams.relationships
+    ))
+  );
+  _izContext.logger.debug(
+    `[${process.env.iz_serviceTag}:<%- flowTag %>] errorsFound:`,
+    errorsFound
   );
 
-  for (const [key, value] of Object.entries(identifiers)) {
-    if (!requestParams.fieldNames.hasOwnProperty(key)) {
-      requestParams.fieldNames[key] = value;
+  // ── Resolve fromRequiredOnCreate fields ──────────────────────────────────
+  if (objectSchemas.fieldNames) {
+    if (!requestParams.fieldNames) {
+      requestParams.fieldNames = {};
+    }
+    for (const [fieldName, val] of Object.entries(objectSchemas.fieldNames)) {
+      if (
+        val.fromRequiredOnCreate &&
+        requestParams.fieldNames[fieldName] === undefined
+      ) {
+        const fromConfig = val.fromRequiredOnCreate;
+        const sourceField = fromConfig.fieldName || fieldName;
+        if (fromConfig.belongToObjType === true && targetIdentifiers) {
+          let targetValue = targetIdentifiers[sourceField];
+          if (targetValue === undefined) {
+            targetValue = Object.values(targetIdentifiers)[0];
+          }
+          requestParams.fieldNames[fieldName] = targetValue;
+        } else if (
+          fromConfig.relType &&
+          requestParams.relationships?.length > 0
+        ) {
+          const matchedRel = requestParams.relationships.find(
+            (rel) =>
+              rel.relType?.serviceTag === fromConfig.relType.serviceTag &&
+              rel.relType?.relationshipTag === fromConfig.relType.relationshipTag
+          );
+          if (matchedRel?.targetIdentifiers?.[sourceField] !== undefined) {
+            requestParams.fieldNames[fieldName] =
+              matchedRel.targetIdentifiers[sourceField];
+          }
+        }
+      }
+    }
+  }
+
+  // ── Resolve identifiers ───────────────────────────────────────────────────
+  let errors;
+  const identifiers = objectSchemas.identifiers;
+  let optionalOnCreateIdentifiers;
+
+  if (
+    identifiers?.length === 1 &&
+    !identifiers[0].hasOwnProperty('fieldNames')
+  ) {
+    [requestParams, errors] = await createIdentifiersByUseCase(
+      _izContext,
+      requestParams,
+      objectSchemas,
+      identifiers[0],
+      optionalOnCreateIdentifiers
+    );
+    if (errors?.length > 0) {
+      errorsFound.push(...errors);
+    }
+  } else if (identifiers?.length > 1) {
+    for (const identifier of identifiers) {
+      [requestParams, errors] = await createIdentifiersByUseCase(
+        _izContext,
+        requestParams,
+        objectSchemas,
+        identifier,
+        optionalOnCreateIdentifiers
+      );
+      if (errors?.length > 0) {
+        errorsFound.push(...errors);
+      }
     }
   }
 
-  _izContext.logger.debug(
-    `[${process.env.iz_serviceTag}:<%- flowTag %>] Identifiers generated:`,
-    identifiers
-  );
+  return { objectSchemas };
 }
 
 /**
  * Validates request field names against schema definition
  * @param {Object} _izContext - Izara context object
- * @param {Object} objectSchemas - Combined object schema
  * @param {Object} requestParams - Incoming request parameters
+ * @param {Object} objectSchemas - Combined object schema
  * @param {Array<string>} errorsFound - Array to collect validation errors
  */
-export function validateFieldNames(_izContext, objectSchemas, requestParams, errorsFound) {
-  const invalidFieldNames = [];
-  for (const fieldName of Object.keys(requestParams.fieldNames || {})) {
-    if (!objectSchemas.fieldNames.includes(fieldName)) {
-      invalidFieldNames.push(fieldName);
+export function validateFieldNames(
+  _izContext,
+  requestParams,
+  objectSchemas,
+  errorsFound
+) {
+  const listOfRequiredOnCreate = [];
+  const listOfOptionalOnCreate = [];
+
+  for (const [key, val] of Object.entries(objectSchemas?.fieldNames || {})) {
+    if (
+      val.randomOnCreate === true ||
+      val.requiredOnCreate === true ||
+      val.fromRequiredOnCreate ||
+      val.hashOnCreate?.length
+    ) {
+      listOfRequiredOnCreate.push(key);
+    }
+    if (val.requiredOnCreate === false && val.optionalOnCreate === true) {
+      listOfOptionalOnCreate.push(key);
     }
   }
 
-  if (invalidFieldNames.length > 0) {
-    errorsFound.push(
-      `Invalid fieldName not match from Schema: ${invalidFieldNames.join(',')}`
-    );
+  for (const fieldName of Object.keys(requestParams.fieldNames || {})) {
+    if (
+      !listOfRequiredOnCreate.includes(fieldName) &&
+      !listOfOptionalOnCreate.includes(fieldName)
+    ) {
+      errorsFound.push('[invalid] over fieldNames create object');
+    }
+    if (errorsFound.length > 0) {
+      _izContext.logger.debug(
+        `[${process.env.iz_serviceTag}:<%- flowTag %>] HaveError:`,
+        errorsFound
+      );
+      break;
+    }
   }
 }
 
@@ -641,60 +756,93 @@ export function resolveQuotaDeductionKeys(
 }
 
 /**
- * Forwards quota confirmation message to ConfirmUsage_In or CancelUsage_In
+ * Forwards quota confirmation or cancellation to RBAC via synchronous invoke
+ * and publishes final completion message to outCreateNodeComplete
  * @param {Object} _izContext - Izara context object
  * @param {Object} options - Message forwarding options
- * @returns {Promise<void>}
+ * @returns {Promise<Object>} Quota invocation result
  */
 export async function forwardToQuotaConfirmation(
   _izContext,
   {
     status,
-    errorsFound,
+    errorsFound = [],
     quotaKeys,
     actionData,
     callingFlowConfig
   }
 ) {
-  const nextTargetTopic =
-    status === 'complete' && errorsFound.length === 0
-      ? 'ConfirmUsage_In'
-      : 'CancelUsage_In';
+  let quotaResult = null;
+  if (quotaKeys && (quotaKeys.limitTag || quotaKeys.flowTypeConcat)) {
+    let targetFunction = 'CancelUsageHdrInv';
+    if (status === 'complete' && errorsFound.length === 0) {
+      targetFunction = 'ConfirmUsageHdrInv';
+    }
 
-  const forwardMessage =
-    callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-      {
-        ...quotaKeys,
-        parentPassBackProperties: actionData
-      },
-      callingFlowSharedLib.addParentCallingFlowConfig(
-        callingFlowConfig,
-        callingFlowSharedLib.createCallingFlowConfig(
-          await lambdaSharedLib.lambdaFunctionName(
-            _izContext,
-            'CreateCompleteHdrSqs'
-          ),
-          {}
-        )
-      )
+    const functionName = await lambdaSharedLib.lambdaFunctionName(
+      _izContext,
+      targetFunction,
+      'Rbac'
     );
 
-  const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
-    _izContext,
-    nextTargetTopic,
-    'Rbac'
+    const forwardMessage = {
+      ...quotaKeys,
+      parentPassBackProperties: actionData,
+      callingFlowConfig
+    };
+
+    _izContext.logger.debug('[CreateLogicalLib] invoking RBAC quota sync', {
+      targetFunction,
+      functionName,
+      forwardMessage
+    });
+
+    try {
+      quotaResult = await lambda.invokeSync(
+        _izContext,
+        functionName,
+        forwardMessage
+      );
+    } catch (err) {
+      _izContext.logger.error(
+        `[CreateLogicalLib] error invoking ${targetFunction}:`,
+        err
+      );
+      if (targetFunction === 'ConfirmUsageHdrInv') {
+        try {
+          const cancelFunctionName = await lambdaSharedLib.lambdaFunctionName(
+            _izContext,
+            'CancelUsageHdrInv',
+            'Rbac'
+          );
+          await lambda.invokeSync(
+            _izContext,
+            cancelFunctionName,
+            forwardMessage
+          );
+        } catch (cancelErr) {
+          _izContext.logger.error(
+            '[CreateLogicalLib] error invoking CancelUsageHdrInv fallback:',
+            cancelErr
+          );
+        }
+      }
+      errorsFound.push(err.message || 'Quota confirmation failed');
+      if (actionData) {
+        actionData.status = 'error';
+        actionData.errorsFound = errorsFound;
+      }
+    }
+  }
+
+  const { message, messageAttributes } = buildCompletionPayload(
+    callingFlowConfig,
+    actionData
   );
 
-  _izContext.logger.debug('[CreateNodeCallback] forwarding to RBAC', {
-    nextTargetTopic,
-    TopicArn: topicArn,
-    forwardMessage
-  });
+  await publishCompletionMessage(_izContext, message, messageAttributes);
 
-  await sns.publishAsync(_izContext, {
-    Message: JSON.stringify(forwardMessage),
-    TopicArn: topicArn
-  });
+  return quotaResult;
 }
 
 // ── 4. CreateComplete_Main Helpers ───────────────────────────────────────────
@@ -1357,10 +1505,24 @@ export async function <%- flowTag %>LogicalLib(
             <%_ if (plan?.hasAfterHookSync) { _%>
             // ── Synchronous After Hooks ──
             <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv').forEach(hook => { _%>
-            <%_ if (hook.objType?.objectType) { _%>
-            if (objType.objectType === '<%= hook.objType.objectType %>') {
+            <%_ 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,
+                objInstanceFull: {
+                  identifiers: identifiersForCreateData,
+                  fields: fieldsForHook
+                },
+                relationships: requestParams.relationships || [],
+                targetIdentifiers: requestParams.targetIdentifiers,
+                submittedByUserId: requestParams.submittedByUserId
+              };
+              //(<beforeSendHook_<%= hook.flowTag %>>)
+              //(</beforeSendHook_<%= hook.flowTag %>>)
               const hookResult = await lambda.invokeSync(
                 _izContext,
                 await lambdaSharedLib.lambdaFunctionName(
@@ -1368,16 +1530,7 @@ export async function <%- flowTag %>LogicalLib(
                   '<%= hook.flowTag %>'
                 ),
                 {
-                  requestParams: {
-                    objType,
-                    objInstanceFull: {
-                      identifiers: identifiersForCreateData,
-                      fields: fieldsForHook
-                    },
-                    relationships: requestParams.relationships || [],
-                    targetIdentifiers: requestParams.targetIdentifiers,
-                    submittedByUserId: requestParams.submittedByUserId
-                  },
+                  requestParams: hookPayload_<%= hook.flowTag %>,
                   callingFlowConfig
                 }
               );
@@ -1388,7 +1541,7 @@ export async function <%- flowTag %>LogicalLib(
               _izContext.logger.error('[<%- flowTag %>LogicalLib] 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) { _%>
             }
             <%_ } _%>
             <%_ }) _%>
@@ -1397,20 +1550,25 @@ export async function <%- flowTag %>LogicalLib(
             <%_ if (plan?.hasAfterHookAsync) { _%>
             // ── Asynchronous After Hooks ──
             <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'ownTopic').forEach(hook => { _%>
-            <%_ if (hook.objType?.objectType) { _%>
-            if (objType.objectType === '<%= hook.objType.objectType %>') {
+            <%_ 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)) {
             <%_ } _%>
-            const hookMsg_<%= hook.flowTag %> = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-              {
-                objType,
-                objInstanceFull: {
-                  identifiers: identifiersForCreateData,
-                  fields: fieldsForHook
-                },
-                relationships: requestParams.relationships || [],
-                targetIdentifiers: requestParams.targetIdentifiers,
-                submittedByUserId: requestParams.submittedByUserId
+            let hookPayload_<%= hook.flowTag %> = {
+              objType,
+              objInstanceFull: {
+                identifiers: identifiersForCreateData,
+                fields: fieldsForHook
               },
+              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(
@@ -1443,7 +1601,7 @@ export async function <%- flowTag %>LogicalLib(
               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/CreateNodeCallback_Main.ejs

@@ -175,10 +175,21 @@ export default async function CreateNodeCallbackMain(
         <%_ 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 +197,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 +208,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 +243,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 +282,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;
+  }
+}