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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.86",
+  "version": "1.0.88",
   "description": "Code for locally generating per service files",
   "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "repository": {

package/src/compile/loadSchemas.js

@@ -22,11 +22,21 @@ const VALID_INITIATE_BY_ENUM = [
   'systemNoUser'
 ];
 
+const VALID_CODE_HOOK_TAG_ENUM = ['before', 'after'];
+
 if (basicValidatorSchema?.basicFlowSchema?.properties?.initiateBy) {
   basicValidatorSchema.basicFlowSchema.properties.initiateBy.enum =
     VALID_INITIATE_BY_ENUM;
 }
 
+if (
+  basicValidatorSchema?.basicFlowSchema?.properties?.generatedCodeConfig
+    ?.properties?.codeHookTag
+) {
+  basicValidatorSchema.basicFlowSchema.properties.generatedCodeConfig.properties.codeHookTag.enum =
+    VALID_CODE_HOOK_TAG_ENUM;
+}
+
 const VALID_GENERATED_BY_ENUM = [
   'user',
   'systemWithUser',
@@ -113,9 +123,17 @@ export async function loadLocalSchemaDirectory(
     if (directoryName === 'FlowSchemas') {
       for (const schema of loadedSchemas) {
         if (Object.prototype.hasOwnProperty.call(schema?.generatedCodeConfig ?? {}, 'codeHookTag')) {
-          throw new Error(
-            `Unsupported FlowHook configuration in ${entry.name}: generatedCodeConfig.codeHookTag is no longer supported`
-          );
+          const hookTag = schema.generatedCodeConfig.codeHookTag;
+          if (hookTag === 'beforeLogical') {
+            throw new Error(
+              `Unsupported FlowHook configuration in ${entry.name}: generatedCodeConfig.codeHookTag is no longer supported`
+            );
+          }
+          if (hookTag !== 'before' && hookTag !== 'after') {
+            throw new Error(
+              `Unsupported FlowHook configuration in ${entry.name}: generatedCodeConfig.codeHookTag '${hookTag}' is invalid. Must be 'before' or 'after'`
+            );
+          }
         }
       }
     }
@@ -177,13 +195,30 @@ export async function loadLocalSchemaDirectory(
             { logger },
             schema
           );
-          if (!status && Array.isArray(errors) && VALID_INITIATE_BY_ENUM.includes(schema?.initiateBy)) {
-            errors = errors.filter(
-              (err) =>
-                !err.includes('initiateBy') &&
-                !err.includes('must be equal to one of the allowed values (enum)') &&
-                !(err.includes('should be one of enum') && err.includes(schema?.initiateBy))
-            );
+          if (!status && Array.isArray(errors)) {
+            if (VALID_INITIATE_BY_ENUM.includes(schema?.initiateBy)) {
+              errors = errors.filter(
+                (err) =>
+                  !err.includes('initiateBy') &&
+                  !err.includes('must be equal to one of the allowed values (enum)') &&
+                  !(err.includes('should be one of enum') && err.includes(schema?.initiateBy))
+              );
+            }
+            if (
+              VALID_CODE_HOOK_TAG_ENUM.includes(
+                schema?.generatedCodeConfig?.codeHookTag
+              )
+            ) {
+              errors = errors.filter(
+                (err) =>
+                  !err.includes('codeHookTag') &&
+                  !err.includes('must be equal to one of the allowed values (enum)') &&
+                  !(
+                    err.includes('should be one of enum') &&
+                    err.includes(schema?.generatedCodeConfig?.codeHookTag)
+                  )
+              );
+            }
             if (errors.length === 0) {
               status = true;
             }

package/src/emit/coreFunction/emitCoreFunctionArtifacts.js

@@ -95,12 +95,12 @@ function _extractDynamoTableNames({
     }
   }
   if (rbac) {
+    dynamoTableNames.add('Roles');
     dynamoTableNames.add('TargetRoles');
     dynamoTableNames.add('RolePermissions');
     dynamoTableNames.add('RoleUsers');
     dynamoTableNames.add('UserRoles');
     dynamoTableNames.add('RbacPermissionCaches');
-    dynamoTableNames.add('RoleLimit');
     dynamoTableNames.add('RunningTotalUsage');
     dynamoTableNames.add('RunningTotalReservedUsage');
   }

package/src/emit/coreFunction/templates/InitialSetupConfig.ejs

@@ -66,12 +66,12 @@ const externalServices = {
     }
   });
   if (typeof rbac !== 'undefined' && rbac) {
+    dynamoTableNames.add('Roles');
     dynamoTableNames.add('TargetRoles');
     dynamoTableNames.add('RolePermissions');
     dynamoTableNames.add('RoleUsers');
     dynamoTableNames.add('UserRoles');
     dynamoTableNames.add('RbacPermissionCaches');
-    dynamoTableNames.add('RoleLimit');
     dynamoTableNames.add('RunningTotalUsage');
     dynamoTableNames.add('RunningTotalReservedUsage');
   }
@@ -182,20 +182,6 @@ const tableConfigs = {
   const currentServiceTag = (typeof serviceTag !== 'undefined' && serviceTag) ? serviceTag : ((typeof project !== 'undefined' && project?.serviceTag) ? project.serviceTag : '');
   const rbacSubs = [];
   if (crud && rbac) {
-    const allRbacTags = Array.from(new Set([
-      'Rbac',
-      currentServiceTag,
-      ...(typeof rbacValidatorServiceTags !== 'undefined' && rbacValidatorServiceTags ? rbacValidatorServiceTags : [])
-    ])).filter(Boolean);
-    const hasGraph = typeof objectGraphServiceTags !== 'undefined' && objectGraphServiceTags && objectGraphServiceTags.length > 0;
-    const createEndpoint = hasGraph ? 'CreateRbacCallbackHdrSqs' : 'CreateCompleteHdrSqs';
-    const updateEndpoint = hasGraph ? 'UpdateRbacCallbackHdrSqs' : 'UpdateCompleteHdrSqs';
-    const deleteEndpoint = hasGraph ? 'DeleteRbacCallbackHdrSqs' : 'DeleteCompleteHdrSqs';
-    allRbacTags.forEach(function(tag) {
-      rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: createEndpoint });
-      rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: updateEndpoint });
-      rbacSubs.push({ serviceTag: tag, topicName: 'ValidatorRbac_Out', sqsEndpoint: deleteEndpoint });
-    });
     if (typeof hasQuotaReservation !== 'undefined' && hasQuotaReservation) {
       rbacSubs.push({ serviceTag: 'Rbac', topicName: 'ConfirmUsage_Out', sqsEndpoint: 'CreateCompleteHdrSqs' });
       rbacSubs.push({ serviceTag: 'Rbac', topicName: 'CancelUsage_Out', sqsEndpoint: 'CreateCompleteHdrSqs' });
@@ -318,6 +304,17 @@ function roleConfigs() {
 <% }); -%>
 <% } -%>
 <% if (rbac || (rbacValidatorServiceTags && rbacValidatorServiceTags.length > 0)) { -%>
+        {
+          Sid: 'FlowObjectsInvokeValidatorRbac',
+          Effect: 'Allow',
+          Action: ['lambda:InvokeFunction'],
+          Resource: [
+            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv', 'Rbac')}`<% if (rbac) { %>,
+            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv')}`<% } %><% (rbacValidatorServiceTags || []).forEach(function(tag) { %>,
+            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv', '<%= tag %>')}`<% }); %>
+          ]
+        },
+
         {
           Sid: 'FlowObjectsPublishValidatorRbacTopics',
           Effect: 'Allow',
@@ -340,6 +337,16 @@ function roleConfigs() {
     {
       roleName: 'FlowRbac',
       statement: [
+        {
+          Sid: 'FlowRbacInvokeValidatorRbac',
+          Effect: 'Allow',
+          Action: ['lambda:InvokeFunction'],
+          Resource: [
+            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv', 'Rbac')}`<% if (rbac) { %>,
+            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv')}`<% } %><% (rbacValidatorServiceTags || []).forEach(function(tag) { %>,
+            `arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, 'ValidatorRbacHdrInv', '<%= tag %>')}`<% }); %>
+          ]
+        },
         {
           Sid: 'FlowRbacPublishValidatorRbacTopics',
           Effect: 'Allow',

package/src/emit/crud/crudActionPlan.js

@@ -1,6 +1,16 @@
 export const CRUD_ACTIONS = ['Create', 'Update', 'Delete', 'Get'];
 
-export function createCrudActionPlans(objects = []) {
+export function findHooksForAction(flows = [], action) {
+  if (!Array.isArray(flows)) return [];
+  return flows.filter((f) => {
+    const config = f?.generatedCodeConfig;
+    if (!config) return false;
+    const tag = config.generateCodeTag || config.generatedCodeTag;
+    return Boolean(tag && tag.toLowerCase() === action.toLowerCase());
+  });
+}
+
+export function createCrudActionPlans(objects = [], flows = []) {
   const hasGraph = hasGraphStorageResource(objects);
   const hasRbac = objects.some(
     (object) => isCrudObject(object) && hasRbacObject(object, objects)
@@ -12,29 +22,60 @@ export function createCrudActionPlans(objects = []) {
   return Object.fromEntries(
     CRUD_ACTIONS.map((action) => [
       action,
-      createCrudActionPlan(action, { hasGraph, hasRbac, isBillable })
+      createCrudActionPlan(action, { hasGraph, hasRbac, isBillable, flows })
     ])
   );
 }
 
 export function createCrudActionPlan(
   action,
-  { hasGraph = false, hasRbac = false, isBillable = true } = {}
+  { hasGraph = false, hasRbac = false, isBillable = true, flows = [] } = {}
 ) {
   const actionHasRbac = action !== 'Get' && hasRbac;
   const outputTopic = action !== 'Get';
   const hasQuotaReservation = action === 'Create' && hasRbac && isBillable;
 
+  const actionHooks = findHooksForAction(flows, action);
+  const beforeHooks = actionHooks.filter(
+    (h) => h?.generatedCodeConfig?.codeHookTag === 'before'
+  );
+  const afterHooks = actionHooks.filter(
+    (h) => h?.generatedCodeConfig?.codeHookTag === 'after'
+  );
+  const hasBeforeHookSync = beforeHooks.some(
+    (h) => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv'
+  );
+  const hasBeforeHookAsync = beforeHooks.some(
+    (h) => h?.generatedCodeConfig?.invocationType === 'ownTopic'
+  );
+  const hasBeforeHookCallback = outputTopic && hasBeforeHookAsync;
+
+  const hasAfterHookSync = afterHooks.some(
+    (h) => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv'
+  );
+  const hasAfterHookAsync = afterHooks.some(
+    (h) => h?.generatedCodeConfig?.invocationType === 'ownTopic'
+  );
+  const hasAfterHookCallback = outputTopic && hasAfterHookAsync;
+
   return {
     action,
     outputTopic,
     hasGraph: outputTopic && hasGraph,
     hasRbac: actionHasRbac,
     hasQuotaReservation,
-    hasComplete: outputTopic && (actionHasRbac || hasGraph),
-    hasRbacCallback: outputTopic && actionHasRbac && hasGraph,
+    hasComplete: outputTopic && (actionHasRbac || hasGraph || hasAfterHookCallback),
+    hasRbacCallback: false,
     hasCreateNodeCallback:
-      outputTopic && action === 'Create' && actionHasRbac && hasGraph && hasQuotaReservation
+      outputTopic && action === 'Create' && actionHasRbac && hasGraph && hasQuotaReservation,
+    hasBeforeHookSync,
+    hasBeforeHookAsync,
+    hasBeforeHookCallback,
+    hasAfterHookSync,
+    hasAfterHookAsync,
+    hasAfterHookCallback,
+    beforeHooks,
+    afterHooks
   };
 }
 

package/src/emit/crud/emitCrudApplicationArtifacts.js

@@ -51,7 +51,7 @@ export async function emitCrudApplicationArtifacts({
   }
 
   const handlers = await Promise.all(
-    ACTIONS.map((action) => emitAction(action, objects, serviceTag))
+    ACTIONS.map((action) => emitAction(action, objects, serviceTag, flows))
   );
   return [
     ...handlers.flatMap((handler) => handler.artifacts),
@@ -88,6 +88,10 @@ export function crudApplicationManagedPaths() {
           `${source}/${action}RbacCallback_HdrSqs.js`,
           `${source}/${action}NodeCallback_Main.js`,
           `${source}/${action}NodeCallback_HdrSqs.js`,
+          `${source}/${action}BeforeHookCallback_Main.js`,
+          `${source}/${action}BeforeHookCallback_HdrSqs.js`,
+          `${source}/${action}AfterHookCallback_Main.js`,
+          `${source}/${action}AfterHookCallback_HdrSqs.js`,
           `${source}/${action}Complete_Main.js`,
           `${source}/${action}Complete_HdrSqs.js`
         );
@@ -98,10 +102,10 @@ export function crudApplicationManagedPaths() {
   ];
 }
 
-async function emitAction(action, objects, serviceTag) {
+async function emitAction(action, objects, serviceTag, flows = []) {
   const source = `app/src/generatedCode/FlowObjects/${action}/source`;
   const handlerRoot = `src/generatedCode/FlowObjects/${action}/source`;
-  const plan = createCrudActionPlans(objects)[action];
+  const plan = createCrudActionPlans(objects, flows)[action];
   const mainFileName = `${action}_Main`;
   const shared = {
     flowTag: action,
@@ -326,6 +330,62 @@ async function emitAction(action, objects, serviceTag) {
     });
   }
 
+  if (plan.hasBeforeHookCallback) {
+    const beforeHookCallbackMain = `${action}BeforeHookCallback_Main`;
+    artifacts.push(
+      {
+        path: `${source}/${beforeHookCallbackMain}.js`,
+        content: await render(`${action}BeforeHookCallback_Main.ejs`, shared)
+      },
+      {
+        path: `${source}/${action}BeforeHookCallback_HdrSqs.js`,
+        content: await renderShared('FlowHandler_HdrSqs.ejs', {
+          ...shared,
+          mainFileName: beforeHookCallbackMain,
+          functionName: `${action}BeforeHookCallbackMain`,
+          queueName: `${action}BeforeHookCallbackHdrSqs`
+        })
+      }
+    );
+    functions.push({
+      type: 'sqs',
+      functionName: `${action}BeforeHookCallbackHdrSqs`,
+      handlerPath: `${handlerRoot}/${action}BeforeHookCallback_HdrSqs.main`,
+      roleName: 'FlowObjectsRole',
+      queueName: `${action}BeforeHookCallbackHdrSqs`,
+      flowTag: action,
+      flowStepName: 'BeforeHookCallback'
+    });
+  }
+
+  if (plan.hasAfterHookCallback) {
+    const afterHookCallbackMain = `${action}AfterHookCallback_Main`;
+    artifacts.push(
+      {
+        path: `${source}/${afterHookCallbackMain}.js`,
+        content: await render(`${action}AfterHookCallback_Main.ejs`, shared)
+      },
+      {
+        path: `${source}/${action}AfterHookCallback_HdrSqs.js`,
+        content: await renderShared('FlowHandler_HdrSqs.ejs', {
+          ...shared,
+          mainFileName: afterHookCallbackMain,
+          functionName: `${action}AfterHookCallbackMain`,
+          queueName: `${action}AfterHookCallbackHdrSqs`
+        })
+      }
+    );
+    functions.push({
+      type: 'sqs',
+      functionName: `${action}AfterHookCallbackHdrSqs`,
+      handlerPath: `${handlerRoot}/${action}AfterHookCallback_HdrSqs.main`,
+      roleName: 'FlowObjectsRole',
+      queueName: `${action}AfterHookCallbackHdrSqs`,
+      flowTag: action,
+      flowStepName: 'AfterHookCallback'
+    });
+  }
+
   if (plan.hasComplete) {
     const completeMain = `${action}Complete_Main`;
     let templateName = `${action}Complete_Main.ejs`;

package/src/emit/crud/emitDynamicCrudFlowSchemas.js

@@ -73,16 +73,17 @@ function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user')
       }
     );
   } else if (plan.hasComplete) {
+    const nextStepName = plan.hasCreateNodeCallback ? 'CreateNodeCallback' : 'Complete';
     startNextSteps.push({
       targetType: 'ownTopic',
-      stepName: 'Complete'
+      stepName: nextStepName
     });
     if (plan.hasGraph) {
       startNextSteps.push({
         targetType: 'extTopic',
         serviceTag: 'GraphHandler',
         topicName: `${action}Node_In`,
-        toStepNames: ['Complete']
+        toStepNames: [nextStepName]
       });
     }
   }
@@ -143,19 +144,20 @@ function _createDynamicFlow(action, plan, serviceTag = '', initiateBy = 'user')
   }
 
   if (plan.hasCreateNodeCallback) {
+    const prevStepName = plan.hasRbacCallback ? 'RbacCallback' : 'Start';
     flowSteps.push({
       stepName: 'CreateNodeCallback',
       event: ['extTopic'],
       previousSteps: [
         {
           sourceType: 'ownTopic',
-          stepName: 'RbacCallback'
+          stepName: prevStepName
         },
         {
           sourceType: 'extTopic',
           serviceTag: 'GraphHandler',
           topicName: 'CreateNode_Out',
-          fromStepNames: ['RbacCallback']
+          fromStepNames: [prevStepName]
         }
       ],
       nextSteps: [

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

@@ -0,0 +1,121 @@
+/*
+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';
+import { forwardToQuotaConfirmation } from './CreateLogicalLib.js';
+
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+const { TOPIC_NAME_GENERATE_CODE } = consts;
+
+/**
+ * Handles callback after async AfterHook 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 CreateAfterHookCallbackMain(
+  _izContext,
+  requestParams,
+  passBackProperties
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    _izContext.logger.debug('[CreateAfterHookCallback] 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 quotaKeys =
+      passBackProperties?.quotaKeys ||
+      requestParams?.passBackProperties?.quotaKeys;
+
+    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
+      };
+
+    if (quotaKeys) {
+      await forwardToQuotaConfirmation(_izContext, {
+        status: mergedErrors.length > 0 ? 'error' : 'complete',
+        errorsFound: mergedErrors,
+        quotaKeys,
+        actionData,
+        callingFlowConfig
+      });
+    } else {
+      const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
+        _izContext,
+        TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete
+      );
+      const completionPayload = {
+        ...actionData,
+        status: mergedErrors.length > 0 ? 'error' : 'complete',
+        errorsFound: mergedErrors
+      };
+      await sns.publishAsync(_izContext, {
+        TopicArn: topicArn,
+        Message: JSON.stringify(completionPayload),
+        MessageAttributes: sns.createStringMessageAttributes(_izContext, {})
+      });
+    }
+
+    //(<afterProcessCallback>)
+    //(</afterProcessCallback>)
+
+    return {
+      returnValue,
+      status: mergedErrors.length > 0 ? 'error' : 'complete',
+      errorsFound: mergedErrors
+    };
+  } catch (error) {
+    _izContext.logger.error('[CreateAfterHookCallback] error:', error);
+    throw error;
+  }
+}

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

@@ -0,0 +1,108 @@
+/*
+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,
+  handleCreateError
+} 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 handleCreateError(_izContext, {
+        objType: originalRequestParams?.objType,
+        objInstanceFull: {
+          identifiers:
+            originalRequestParams?.identifiers ||
+            originalRequestParams?.targetIdentifiers ||
+            {},
+          fields: originalRequestParams?.fieldNames || {}
+        },
+        requestParams: originalRequestParams || {},
+        callingFlowConfig,
+        errorsFound: mergedErrors
+      });
+    }
+
+    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;
+  }
+}