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

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

@@ -19,7 +19,7 @@ import {
   objectHash as hash,
   identifierUuid
 } from '@izara_project/izara-shared-core';
-import { consts as coreConsts } from '@izara_project/izara-core-library-core';
+
 import {
   sns,
   lambda
@@ -29,17 +29,18 @@ import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow
 import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
 import {
   consts,
-  getObjectSchema,
   utils
 } from '@izara_project/izara-core-library-service-schemas';
 import snsSharedLib from '@izara_project/izara-core-library-sns';
 
-import { <%- flowTag %>LogicalLib } from './<%- upperCaseFlowTag %>LogicalLib.js';
+import {
+  <%- flowTag %>LogicalLib,
+  resolveSchemaAndIdentity
+} from './<%- upperCaseFlowTag %>LogicalLib.js';
 
 //(<optionalRequire>)
 //(</optionalRequire>)
 
-const { createObjType } = utils;
 
 /**
  * Deletes an object instance with optional RBAC routing
@@ -62,53 +63,13 @@ export default async function <%- flowTag %>(
     });
 
     const errorsFound = [];
-    const objType = createObjType(requestParams.objectType);
 
     //(<beforeDelete>)
     //(</beforeDelete>)
 
-    // ── 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
-      });
-    }
+    // ── Resolve Schema & Identity ─────────────────────────────────────────────
+    const { objType, objectSchema, targetIdentifiers } =
+      await resolveSchemaAndIdentity(_izContext, requestParams, errorsFound);
 
     //(<beforeQuery>)
     //(</beforeQuery>)
@@ -116,36 +77,36 @@ export default async function <%- flowTag %>(
     // ── Build identifiers used by asynchronous processing ────────────────────
     const identifiers = requestParams.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 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 identifiers.${key}`
+    //       );
+    //     }
+    //   }
+    // }
 
     if (errorsFound.length > 0)
       return await <%- flowTag %>LogicalLib(
@@ -227,110 +188,107 @@ export default async function <%- flowTag %>(
 
     // ── Optional phase extension point ────────────────────────────────────────
     <%_
-    const groupedByObjType = [];
+    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);
+      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 {
+        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: {
+              objType,
+              identifiers: requestParams.identifiers,
+              targetIdentifiers,
+              submittedByUserId: requestParams.submittedByUserId
+            },
+            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?.identifiers && requestParams?.identifiers) {
+            Object.assign(requestParams.identifiers, returnValue.identifiers);
+          }
+        }
+      } 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 => { _%>
+      const hookMsg_<%= config.flowTag %> =
+        callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+          {
+            objType,
+            identifiers: requestParams.identifiers,
+            targetIdentifiers,
+            submittedByUserId: requestParams.submittedByUserId
+          },
           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,
@@ -338,32 +296,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 deleteLogicalLib
-      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/DeleteLogicalLib.ejs

@@ -46,6 +46,135 @@ const { TOPIC_NAME_GENERATE_CODE } = consts;
 //(<optionalRequire>)
 //(</optionalRequire>)
 
+// ── 1. Delete_Main Helpers ───────────────────────────────────────────────────
+
+/**
+ * Loads ObjectSchema and resolves submittedByUserId and targetIdentifiers
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} requestParams - Incoming request parameters
+ * @param {Array<string>} errorsFound - Array to collect validation errors
+ * @returns {Promise<{ objType: string, objectSchema: Object, targetIdentifiers?: Object }>}
+ */
+export async function resolveSchemaAndIdentity(
+  _izContext,
+  requestParams,
+  errorsFound
+) {
+  const objType = createObjType(requestParams.objectType);
+  const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
+    _izContext,
+    objType
+  );
+  _izContext.logger.debug(
+    `[${process.env.iz_serviceTag}:<%- flowTag %>] objectSchema:`,
+    objectSchema
+  );
+
+  let submittedByUserId;
+  let targetIdentifiers;
+  if (
+    objectSchema.generatedBy === 'user' ||
+    objectSchema.generatedBy === 'systemWithUser'
+  ) {
+    submittedByUserId =
+      requestParams.submittedByUserId ||
+      _izContext.correlationIds.get(coreConsts.SUBMITTED_BY_USER_ID);
+
+    targetIdentifiers = requestParams.targetIdentifiers;
+    delete requestParams.targetIdentifiers;
+
+    if (
+      !targetIdentifiers &&
+      objectSchema.belongTo?.objectType === 'user' &&
+      submittedByUserId
+    ) {
+      targetIdentifiers = { submittedByUserId };
+    }
+
+    if (!submittedByUserId) {
+      errorsFound.push('Not have submittedByUserId');
+    }
+    if (objectSchema.hasOwnProperty('belongTo') && !targetIdentifiers) {
+      errorsFound.push('not have targetIdentifiers');
+    }
+
+    requestParams.submittedByUserId = submittedByUserId;
+    if (targetIdentifiers) {
+      if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
+        targetIdentifiers.submittedByUserId = submittedByUserId;
+      }
+    }
+
+    _izContext.logger.debug(
+      `[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`,
+      {
+        submittedByUserId: requestParams.submittedByUserId,
+        targetIdentifiers,
+        belongTo: objectSchema.belongTo,
+        generatedBy: objectSchema.generatedBy
+      }
+    );
+  }
+
+  return { objType, objectSchema, targetIdentifiers };
+}
+
+/**
+ * Handles delete errors and publishes error response
+ * @param {Object} _izContext - Izara context object
+ * @param {Object} options - Error context details
+ * @returns {Promise<Object>} Error status result
+ */
+export async function handleDeleteError(
+  _izContext,
+  {
+    objType,
+    identifiers,
+    targetIdentifiers,
+    callingFlowConfig,
+    errorsFound
+  }
+) {
+  const deleteNodeCompleteMessage =
+    callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
+      callingFlowConfig,
+      {
+        objType,
+        identifiers,
+        targetIdentifiers,
+        status: 'error',
+        errorsFound
+      }
+    );
+
+  _izContext.logger.debug(
+    'messageParams OutDeleteNodeComplete::',
+    deleteNodeCompleteMessage
+  );
+  await sns.publishAsync(_izContext, {
+    Message: JSON.stringify(deleteNodeCompleteMessage),
+    MessageAttributes: sns.createStringMessageAttributes(
+      _izContext,
+      callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+        callingFlowConfig,
+        {}
+      )
+    ),
+    TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      TOPIC_NAME_GENERATE_CODE.outDeleteNodeComplete
+    )
+  });
+
+  return {
+    objType,
+    identifiers,
+    targetIdentifiers,
+    status: 'error',
+    errorsFound
+  };
+}
+
 /**
  * Core logical processing library
  * @param {Object} _izContext - Context object with logger
@@ -93,36 +222,13 @@ export async function <%- flowTag %>LogicalLib(
 
     // ── Early exit on errors ──────────────────────────────────────────────────
     if (errorsFound.length) {
-      const deleteNodeCompleteMessage =
-        callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
-          callingFlowConfig,
-          {
-            objType,
-            identifiers: requestParams.identifiers,
-            status: 'error',
-            errorsFound
-          }
-        );
-
-      _izContext.logger.debug(
-        'messageParams OutDeleteNodeComplete::',
-        deleteNodeCompleteMessage
-      );
-      await sns.publishAsync(_izContext, {
-        Message: JSON.stringify(deleteNodeCompleteMessage),
-        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
-          _izContext,
-          TOPIC_NAME_GENERATE_CODE.outDeleteNodeComplete
-        )
-      });
-
-      return {
+      return await handleDeleteError(_izContext, {
         objType,
         identifiers: requestParams.identifiers,
         targetIdentifiers: requestParams.targetIdentifiers,
-        status: 'error',
+        callingFlowConfig,
         errorsFound
-      };
+      });
     }
 
     //(<validateBeforeDelete>)

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

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