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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.87",
+  "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/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),
+    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/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;
+  }
+}