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

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;
+  }
+}

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>)
@@ -218,7 +173,8 @@ export default async function <%- flowTag %>(
             serviceTag: <%- rbacServiceTags.length === 1 ? rbacServiceTags[0] : `{ ${Object.entries(rbacServiceTagMap).map(([k, v]) => `'${k}': ${v}`).join(', ')} }[requestParams.objectType] || process.env.iz_serviceTag` %>
           },
           requestParams: requestParams,
-          nextFlowStepName: '<%- plan?.hasRbacCallback ? `${flowTag}RbacCallback` : `${flowTag}Complete` %>'
+          nextFlowStepName: '<%- plan?.hasRbacCallback ? `${flowTag}RbacCallback` : `${flowTag}Complete` %>',
+          sync: true
         }
       );
 
@@ -227,119 +183,137 @@ export default async function <%- flowTag %>(
         resultPermissionCheck
       );
 
+      if (resultPermissionCheck && resultPermissionCheck.permission !== true) {
+        errorsFound.push('Permission denied');
+        return await <%- flowTag %>LogicalLib(
+          _izContext,
+          requestParams,
+          callingFlowConfig,
+          errorsFound
+        );
+      }
+
       //(<rbacPublish_<%- flowTag %>)
       //(</rbacPublish_<%- flowTag %>)
-
-      return resultPermissionCheck;
     }
     <%_ } _%>
 
     // ── 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,
+              objInstanceFull: requestParams.objInstanceFull,
+              identifiers: requestParams.objInstanceFull?.identifiers,
+              fieldNames: requestParams.objInstanceFull?.fields || requestParams.fieldNames,
+              relationships: requestParams.relationships || [],
+              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?.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 => { _%>
+      const hookMsg_<%= config.flowTag %> =
+        callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+          {
+            objType,
+            objInstanceFull: requestParams.objInstanceFull,
+            identifiers: requestParams.objInstanceFull?.identifiers,
+            fieldNames: requestParams.objInstanceFull?.fields || requestParams.fieldNames,
+            relationships: requestParams.relationships || [],
+            targetIdentifiers,
+            submittedByUserId: requestParams.submittedByUserId
+          },
           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,
@@ -347,32 +321,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 ────────────────────────────────────────

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/function/functionYamlArtifact.js

@@ -319,8 +319,10 @@ function _sqsFilterPatterns(
           - body:
               MessageAttributes:
                 callingFlow:
-                  Value:
-                    - exists: false
+                  - exists: false
+          - body:
+              MessageAttributes:
+                - exists: false
         #<#/${hookFunctionName}FilterPatterns#>
 `;
 }

package/src/emit/rbac/emitDynamicRbacFlowSchemas.js

@@ -18,9 +18,6 @@ const RBAC_CORE_FLOW_DEFINITIONS = [
 ];
 
 const LIMIT_FLOW_DEFINITIONS = [
-  { flowTag: 'CreateRoleLimit', event: ['ownTopic'] },
-  { flowTag: 'ListRoleLimits', event: ['lambdaSyncApi'] },
-  { flowTag: 'DeleteRoleLimit', event: ['ownTopic'] },
   { flowTag: 'ReservedDynamicUsage', event: ['ownTopic'] },
   { flowTag: 'ConfirmUsage', event: ['ownTopic'] },
   { flowTag: 'CancelUsage', event: ['ownTopic'] }