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

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

@@ -21,14 +21,10 @@ import {
   objectHash as hash,
   identifierUuid
 } from '@izara_project/izara-shared-core';
-import {
-  consts as coreConsts,
-  NoRetryError
-} from '@izara_project/izara-core-library-core';
+import { NoRetryError } from '@izara_project/izara-core-library-core';
 
 // ==================== Core Service Schemas ====================
 import {
-  getObjectSchema,
   consts,
   utils,
   identifiersObject,
@@ -53,7 +49,10 @@ import {
   lambda
 } from '@izara_project/izara-core-library-external-request';
 
-import { <%- flowTag %>LogicalLib } from './<%- upperCaseFlowTag %>LogicalLib.js';
+import {
+  <%- flowTag %>LogicalLib,
+  resolveSchemaAndIdentity
+} from './<%- upperCaseFlowTag %>LogicalLib.js';
 
 //(<optionalRequire>)
 //(</optionalRequire>)
@@ -79,88 +78,44 @@ export default async function <%- flowTag %>(
     });
 
     const errorsFound = [];
-    const objType = createObjType(requestParams.objectType);
-
-    // ── Load schema ───────────────────────────────────────────────────────────
-    const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
-      _izContext,
-      objType
-    );
-    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] objectSchema:`, objectSchema);
-
-    // ── Resolve submittedByUserId / targetIdentifiers ─────────────────────────
-    let submittedByUserId, 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
-      });
-    } else if (objectSchema.generatedBy === 'searchResultGenerated') {
-      throw new NoRetryError(
-        'error searchResultGenerated should not happen here'
-      );
-    }
+    // ── Resolve Schema & Identity ─────────────────────────────────────────────
+    const { objType, objectSchema, targetIdentifiers } =
+      await resolveSchemaAndIdentity(_izContext, requestParams, errorsFound);
 
     // ── Build identifiers used by asynchronous processing ────────────────────
     const identifiers = requestParams.objInstanceFull?.identifiers;
 
-    if (!objectSchema.hasOwnProperty('belongTo')) {
-      if (!targetIdentifiers && identifiers) {
-        targetIdentifiers = { ...identifiers };
-      } else if (targetIdentifiers && identifiers) {
-        for (const [key, value] of Object.entries(identifiers)) {
-          if (targetIdentifiers[key] === undefined && value !== undefined) {
-            targetIdentifiers[key] = value;
-          }
-        }
-      }
-      if (targetIdentifiers) {
-        if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
-          targetIdentifiers.submittedByUserId = submittedByUserId;
-        }
-      }
-    }
-
-    if (targetIdentifiers && identifiers) {
-      for (const [key, value] of Object.entries(identifiers)) {
-        if (
-          targetIdentifiers[key] !== undefined &&
-          value !== undefined &&
-          targetIdentifiers[key] !== value
-        ) {
-          errorsFound.push(
-            `targetIdentifiers.${key} must match objInstanceFull.identifiers.${key}`
-          );
-        }
-      }
-    }
+    // if (!objectSchema.hasOwnProperty('belongTo')) {
+    //   if (!targetIdentifiers && identifiers) {
+    //     targetIdentifiers = { ...identifiers };
+    //   } else if (targetIdentifiers && identifiers) {
+    //     for (const [key, value] of Object.entries(identifiers)) {
+    //       if (targetIdentifiers[key] === undefined && value !== undefined) {
+    //         targetIdentifiers[key] = value;
+    //       }
+    //     }
+    //   }
+    //   if (targetIdentifiers) {
+    //     if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
+    //       targetIdentifiers.submittedByUserId = submittedByUserId;
+    //     }
+    //   }
+    // }
+
+    // if (targetIdentifiers && identifiers) {
+    //   for (const [key, value] of Object.entries(identifiers)) {
+    //     if (
+    //       targetIdentifiers[key] !== undefined &&
+    //       value !== undefined &&
+    //       targetIdentifiers[key] !== value
+    //     ) {
+    //       errorsFound.push(
+    //         `targetIdentifiers.${key} must match objInstanceFull.identifiers.${key}`
+    //       );
+    //     }
+    //   }
+    // }
 
     //(<validateBeforeUpdate>)
     //(</validateBeforeUpdate>)
@@ -245,110 +200,132 @@ export default async function <%- flowTag %>(
 
     // ── Optional phase extension point ────────────────────────────────────────
     <%_
-    const groupedByObjType = [];
+    const allCrudObjectTypes = (objects || []).filter(isCrudObject).map(o => o.objectType);
+    const beforeHooksByObjType = (plan?.beforeHooks || []).reduce((acc, 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;
+    }, {});
     _%>
-    <%_ Object.entries(groupedByObjType).forEach(([objectType, configs]) => { _%>
+    <%_ Object.entries(beforeHooksByObjType).forEach(([objectType, configs]) => { _%>
     <%_
-      const hasOwnTopic      = configs.some(c => c.invocationType === 'ownTopic');
-      const hasLambdaSyncInv = configs.some(c => c.invocationType === 'lambdaSyncInv');
-      _%>
+      const hasOwnTopic = configs.some(c => c?.generatedCodeConfig?.invocationType === 'ownTopic' || c?.event?.includes('ownTopic'));
+      const hasLambdaSyncInv = configs.some(c => c?.generatedCodeConfig?.invocationType === 'lambdaSyncInv' || c?.event?.includes('lambdaSyncInv'));
+    _%>
     if (requestParams.objectType === '<%= objectType %>') {
       <%_ if (hasLambdaSyncInv) { _%>
-      const lambdaSyncInvResults = await Promise.all([
-        <%_ configs.filter(c => c.invocationType === 'lambdaSyncInv').forEach((config, index, arr) => { _%>
-        // lambdaSyncInv <%= config.flowTag %>
-        lambda
-          .invokeSync(
+      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(
             _izContext,
-            await lambdaSharedLib.lambdaFunctionName(
-              _izContext,
-              'Process<%= config.flowTag %>HdrInv'
-            ),
-            { requestParams, callingFlowConfig }
-          )
-          .then((returnValue) => ({
-            flowTag: '<%= config.flowTag %>',
-            returnValue
-          })) /*__EJS_COMMA_14__*/
-        // lambdaSyncInv <%= config.flowTag %>
-        <%_ }) _%>
-      ]);
+            '<%= config.flowTag %>'
+          ),
+          {
+            requestParams: hookPayload_<%= config.flowTag %>,
+            callingFlowConfig
+          }
+        );
+        lambdaSyncInvResults.push({
+          flowTag: '<%= config.flowTag %>',
+          returnValue
+        });
+        if (returnValue?.errorsFound?.length > 0) {
+          errorsFound.push(...returnValue.errorsFound);
+        } else if (returnValue?.status === 'error') {
+          errorsFound.push('Error from <%= config.flowTag %>');
+        } else {
+          if (returnValue?.fields && requestParams?.objInstanceFull?.fields) {
+            Object.assign(requestParams.objInstanceFull.fields, returnValue.fields);
+          } else if (returnValue?.fieldNames && requestParams?.objInstanceFull?.fields) {
+            Object.assign(requestParams.objInstanceFull.fields, returnValue.fieldNames);
+          } else if (returnValue?.fieldNames && requestParams?.fieldNames) {
+            Object.assign(requestParams.fieldNames, returnValue.fieldNames);
+          }
+          if (returnValue?.relationships && requestParams) {
+            requestParams.relationships = returnValue.relationships;
+          }
+        }
+      } catch (hookErr) {
+        _izContext.logger.error(
+          '[<%- flowTag %>] Sync hook <%= config.flowTag %> error:',
+          hookErr
+        );
+        errorsFound.push(hookErr.message || 'Hook <%= config.flowTag %> failed');
+      }
+      <%_ } _%>
+
+      if (errorsFound.length > 0) {
+        return await <%- flowTag %>LogicalLib(
+          _izContext,
+          requestParams,
+          callingFlowConfig,
+          errorsFound
+        );
+      }
       <%_ } _%>
 
       //(<afterBeforeLogical_<%= objectType %>>)
       //(</afterBeforeLogical_<%= objectType %>>)
 
       <%_ if (hasOwnTopic) { _%>
-      // ── ownTopic (async — create awaitingSteps and then publish) ──────────
-      const awaitingMultipleStepIds = [];
-      const recordMsgs = [];
-
-      <%_ configs.filter(c => c.invocationType === 'ownTopic').forEach(config => { _%>
-      // ownTopic <%= config.flowTag %>
-      awaitingMultipleStepIds.push({
-        awaitingStepId: await asyncFlowSharedLib.createAwaitingStepId(
-          hash(identifiers),
-          'logical_<%= objectType %>_<%= config.flowTag.charAt(0).toUpperCase() + config.flowTag.slice(1) %>'
-        ),
-        additionalAttributes: {}
-      });
-
-      recordMsgs.push({
-        msg: callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-          requestParams,
+      // ── 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(
+          hookPayload_<%= config.flowTag %>,
           callingFlowSharedLib.addParentCallingFlowConfig(
             callingFlowConfig,
             callingFlowSharedLib.createCallingFlowConfig(
-              //(<callingFlowProperties_<%= config.flowTag %>>)
               await lambdaSharedLib.lambdaFunctionName(
                 _izContext,
-                '<%= flowTag.toLowerCase() %>Complete'
+                '<%- flowTag %>BeforeHookCallbackHdrSqs'
               ),
-              {}
-              //(</callingFlowProperties_<%= config.flowTag %>>)
+              {
+                originalRequestParams: {
+                  ...requestParams,
+                  objType,
+                  targetIdentifiers
+                },
+                callingFlowConfig
+              }
             )
           )
-        ),
-        flowTag: '<%= config.flowTag.charAt(0).toUpperCase() + config.flowTag.slice(1) %>'
-      });
-      <%_ }) _%>
-
-      <%_ if (hasLambdaSyncInv) { _%>
-      // ── Add lambdaSyncInv results to awaitingSteps ────────────────────────
-      for (const syncResult of lambdaSyncInvResults) {
-        awaitingMultipleStepIds.push({
-          awaitingStepId: await asyncFlowSharedLib.createAwaitingStepId(
-            hash(identifiers),
-            'logical_<%= objectType %>_' + syncResult.flowTag
-          ),
-          additionalAttributes: {
-            complete: true,
-            errorsFound: [],
-            returnValue: syncResult.returnValue
-          }
-        });
-      }
-      <%_ } _%>
-
-      await asyncFlowSharedLib.createAwaitingMultipleSteps(
-        _izContext,
-        asyncFlowSharedLib.createPendingStepId(
-          _izContext.uniqueRequestId,
-          'logical_<%= objectType %>'
-        ),
-        awaitingMultipleStepIds,
-        {
-          additionalAttributes: {
-            callingFlowConfig
-          }
-        }
-      );
-
-      //(<beforePublish_<%= objectType %>>)
-      //(</beforePublish_<%= objectType %>>)
+        );
 
-      for (const recordMsg of recordMsgs) {
-        const messageAttributes = sns.createStringMessageAttributes(
+      const messageAttributes_<%= config.flowTag %> =
+        sns.createStringMessageAttributes(
           _izContext,
           callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
             callingFlowConfig,
@@ -356,32 +333,36 @@ export default async function <%- flowTag %>(
           )
         );
 
-        const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
-          _izContext,
-          `${recordMsg.flowTag}_In`
-        );
+      const topicArn_<%= config.flowTag %> = snsSharedLib.snsTopicArnByFlowSchema(
+        _izContext,
+        '<%= config.flowTag %>_In'
+      );
 
-        await sns.publishAsync(_izContext, {
-          Message: JSON.stringify(recordMsg.msg),
-          MessageAttributes: messageAttributes,
-          TopicArn: topicArn
-        });
-      }
+      _izContext.logger.debug(
+        `[${process.env.iz_serviceTag}:<%- flowTag %>] Dispatching to BeforeHook:`,
+        {
+          topicArn: topicArn_<%= config.flowTag %>,
+          flowTag: '<%= config.flowTag %>'
+        }
+      );
 
-      return 'complete logical <%= objectType %>';
+      await sns.publishAsync(_izContext, {
+        Message: JSON.stringify(hookMsg_<%= config.flowTag %>),
+        MessageAttributes: messageAttributes_<%= config.flowTag %>,
+        TopicArn: topicArn_<%= config.flowTag %>
+      });
+      <%_ }) _%>
 
+      return {
+        status: 'pending',
+        message: 'Dispatched to BeforeHook'
+      };
       <%_ } else { _%>
-      // ── lambdaSyncInv only — collect results and proceed to updateLogicalLib
-      const phaseResults = Object.fromEntries(
-        lambdaSyncInvResults.map(({ flowTag: tag, returnValue }) => [tag, returnValue])
-      );
-
       return await <%- flowTag %>LogicalLib(
         _izContext,
         requestParams,
         callingFlowConfig,
-        errorsFound,
-        phaseResults
+        errorsFound
       );
       <%_ } _%>
     }

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

@@ -108,7 +108,7 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
       if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
         targetIdentifiers.submittedByUserId = submittedByUserId;
       }
-      requestParams.targetIdentifiers = targetIdentifiers;
+      // requestParams.targetIdentifiers = targetIdentifiers;
     }
 
     _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`, {
@@ -124,7 +124,7 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
   }
 
   requestParams.submittedByUserId = submittedByUserId;
-  return { objType, objectSchema };
+  return { objType, objectSchema, targetIdentifiers };
 }
 
 // ── 2. UpdateRbacCallback_Main Helpers ────────────────────────────────────────
@@ -852,12 +852,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 +986,7 @@ export async function <%- flowTag %>LogicalLib(
         objInstanceFull: { identifiers, fields },
         versionedDataIds
       },
-      status: 'complete',
+      status: resultStatus,
       errorsFound
     };
   } catch (err) {

package/src/emit/custom/customFlows.js

@@ -16,7 +16,9 @@ export function supportedCustomFlows(flows) {
     (flow) =>
       typeof flow?.flowTag === 'string' &&
       flow.flowTag !== '' &&
-      !flow.generatedCodeConfig &&
+      (!flow.generatedCodeConfig ||
+        (flow.generatedCodeConfig.codeHookTag &&
+          !flow.event.includes('ownTopic'))) &&
       Array.isArray(flow.event) &&
       flow.event.some((event) => SUPPORTED_EVENTS.has(event))
   );

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;