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

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

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

@@ -200,11 +200,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;
     }, {});
     _%>
@@ -218,6 +222,18 @@ 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,
+          objInstanceFull: requestParams.objInstanceFull,
+          identifiers: requestParams.objInstanceFull?.identifiers,
+          fieldNames:
+            requestParams.objInstanceFull?.fields || requestParams.fieldNames,
+          relationships: requestParams.relationships || [],
+          targetIdentifiers,
+          submittedByUserId: requestParams.submittedByUserId
+        };
+        //(<beforeSendHook_<%= config.flowTag %>>)
+        //(</beforeSendHook_<%= config.flowTag %>>)
         const returnValue = await lambda.invokeSync(
           _izContext,
           await lambdaSharedLib.lambdaFunctionName(
@@ -225,15 +241,7 @@ export default async function <%- flowTag %>(
             '<%= config.flowTag %>'
           ),
           {
-            requestParams: {
-              objType,
-              objInstanceFull: requestParams.objInstanceFull,
-              identifiers: requestParams.objInstanceFull?.identifiers,
-              fieldNames: requestParams.objInstanceFull?.fields || requestParams.fieldNames,
-              relationships: requestParams.relationships || [],
-              targetIdentifiers,
-              submittedByUserId: requestParams.submittedByUserId
-            },
+            requestParams: hookPayload_<%= config.flowTag %>,
             callingFlowConfig
           }
         );
@@ -282,17 +290,21 @@ 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,
+        objInstanceFull: requestParams.objInstanceFull,
+        identifiers: requestParams.objInstanceFull?.identifiers,
+        fieldNames:
+          requestParams.objInstanceFull?.fields || requestParams.fieldNames,
+        relationships: requestParams.relationships || [],
+        targetIdentifiers,
+        submittedByUserId: requestParams.submittedByUserId
+      };
+      //(<beforeSendHook_<%= config.flowTag %>>)
+      //(</beforeSendHook_<%= config.flowTag %>>)
       const hookMsg_<%= config.flowTag %> =
         callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-          {
-            objType,
-            objInstanceFull: requestParams.objInstanceFull,
-            identifiers: requestParams.objInstanceFull?.identifiers,
-            fieldNames: requestParams.objInstanceFull?.fields || requestParams.fieldNames,
-            relationships: requestParams.relationships || [],
-            targetIdentifiers,
-            submittedByUserId: requestParams.submittedByUserId
-          },
+          hookPayload_<%= config.flowTag %>,
           callingFlowSharedLib.addParentCallingFlowConfig(
             callingFlowConfig,
             callingFlowSharedLib.createCallingFlowConfig(

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

@@ -105,9 +105,6 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
 
     requestParams.submittedByUserId = submittedByUserId;
     if (targetIdentifiers) {
-      if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
-        targetIdentifiers.submittedByUserId = submittedByUserId;
-      }
       // requestParams.targetIdentifiers = targetIdentifiers;
     }
 
@@ -852,12 +849,132 @@ export async function <%- flowTag %>LogicalLib(
 
     // 5. If no graph storage, complete immediately
     if (!hasGraphStorage) {
+      <%_ 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,
+          objInstanceFull: createObjInstanceFullFromParams(
+            updateItem,
+            requestParams
+          ),
+          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,
+        objInstanceFull: createObjInstanceFullFromParams(
+          updateItem,
+          requestParams
+        ),
+        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,
+                'UpdateAfterHookCallbackHdrSqs'
+              ),
+              {
+                actionData: {
+                  objType,
+                  objInstanceFull: createObjInstanceFullFromParams(
+                    updateItem,
+                    requestParams
+                  ),
+                  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 { _%>
       await handleDynamoDbOnlyComplete(_izContext, {
         objType,
         updateItem,
         requestParams,
         callingFlowConfig
       });
+      <%_ } _%>
+    }
+
+    let resultStatus = 'complete';
+    if (errorsFound.length > 0) {
+      resultStatus = 'error';
     }
 
     return {
@@ -866,7 +983,7 @@ export async function <%- flowTag %>LogicalLib(
         objInstanceFull: { identifiers, fields },
         versionedDataIds
       },
-      status: 'complete',
+      status: resultStatus,
       errorsFound
     };
   } catch (err) {

package/src/emit/rbac/emitDynamicRbacFlowSchemas.js

@@ -19,8 +19,14 @@ const RBAC_CORE_FLOW_DEFINITIONS = [
 
 const LIMIT_FLOW_DEFINITIONS = [
   { flowTag: 'ReservedDynamicUsage', event: ['ownTopic'] },
-  { flowTag: 'ConfirmUsage', event: ['ownTopic'] },
-  { flowTag: 'CancelUsage', event: ['ownTopic'] }
+  {
+    flowTag: 'ConfirmUsage',
+    event: ['ownTopic', 'lambdaSyncInv', 'lambdaSyncApi']
+  },
+  {
+    flowTag: 'CancelUsage',
+    event: ['ownTopic', 'lambdaSyncInv', 'lambdaSyncApi']
+  }
 ];
 
 const RBAC_FLOW_DEFINITIONS = [

package/src/emit/rbac/templates/CancelUsage_Main.ejs

@@ -146,20 +146,40 @@ export default async function CancelUsage(_izContext, requestParams) {
       }
     }
 
-    await sns.publishMessage(_izContext, {
-      message: {
-        returnResult: {
-          status: true,
-          uniqueIdentify: usedTimestampId,
-          usedTimestampId,
-          runningTotalReservedId
-        }
-      },
-      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
-        _izContext,
-        'CancelUsage_Out'
-      )
-    });
+    const returnResult = {
+      status: true,
+      uniqueIdentify: usedTimestampId,
+      usedTimestampId,
+      runningTotalReservedId
+    };
+
+    const eventSourceTag =
+      _izContext.izEventSource?.eventSourceTag ||
+      requestParams?.izEventSource?.eventSourceTag;
+
+    let isSync = false;
+    if (
+      eventSourceTag === 'DirectInvoke' ||
+      eventSourceTag === 'ApiGateway' ||
+      eventSourceTag === 'ApiGatewayV2' ||
+      requestParams?.hasOwnProperty('__context__')
+    ) {
+      isSync = true;
+    }
+
+    if (!isSync) {
+      await sns.publishMessage(_izContext, {
+        message: {
+          returnResult
+        },
+        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+          _izContext,
+          'CancelUsage_Out'
+        )
+      });
+    }
+
+    return returnResult;
   } catch (error) {
     _izContext.logger.error(`[${process.env.iz_serviceTag}:CancelUsage] error:`, error);
     throw error;

package/src/emit/rbac/templates/ConfirmUsage_Main.ejs

@@ -170,20 +170,40 @@ export default async function ConfirmUsage(_izContext, requestParams) {
       ).catch(() => null);
     }
 
-    await sns.publishMessage(_izContext, {
-      message: {
-        returnResult: {
-          status: true,
-          uniqueIdentify: usedTimestampId,
-          usedTimestampId,
-          runningTotalReservedId
-        }
-      },
-      TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
-        _izContext,
-        'ConfirmUsage_Out'
-      )
-    });
+    const returnResult = {
+      status: true,
+      uniqueIdentify: usedTimestampId,
+      usedTimestampId,
+      runningTotalReservedId
+    };
+
+    const eventSourceTag =
+      _izContext.izEventSource?.eventSourceTag ||
+      requestParams?.izEventSource?.eventSourceTag;
+
+    let isSync = false;
+    if (
+      eventSourceTag === 'DirectInvoke' ||
+      eventSourceTag === 'ApiGateway' ||
+      eventSourceTag === 'ApiGatewayV2' ||
+      requestParams?.hasOwnProperty('__context__')
+    ) {
+      isSync = true;
+    }
+
+    if (!isSync) {
+      await sns.publishMessage(_izContext, {
+        message: {
+          returnResult
+        },
+        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+          _izContext,
+          'ConfirmUsage_Out'
+        )
+      });
+    }
+
+    return returnResult;
   } catch (error) {
     _izContext.logger.error(`[${process.env.iz_serviceTag}:ConfirmUsage] error:`, error);
     throw error;