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

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,117 @@ 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,
+          identifiers: requestParams.identifiers,
+          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?.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 => { _%>
+      let hookPayload_<%= config.flowTag %> = {
+        objType,
+        identifiers: requestParams.identifiers,
+        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,
@@ -338,32 +306,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
       );
       <%_ } _%>
     }