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

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

@@ -41,237 +41,16 @@ import {
 } 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,
+  resolveAndGenerateIdentifiers,
+  validateFieldNames
+} from './<%- upperCaseFlowTag %>LogicalLib.js';
 
 //(<optionalRequire>)
 //(</optionalRequire>)
 
-const { createObjType, firstLetterUpperCase } = utils;
-const { createDataDetailsLib } = dataDetailsLib;
-const { createIdentifiersByUseCase } = identifiersObject;
-
-// ── Helper Functions ──────────────────────────────────────────────────────────
-
-/**
- * Loads Schema and resolves submittedByUserId and targetIdentifiers
- * @param {Object} _izContext - Izara context object
- * @param {Object} requestParams - Request parameters
- * @param {Array<string>} errorsFound - Error list
- * @returns {Promise<{ objType: Object, objectSchema: Object, targetIdentifiers?: Object }>}
- */
-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, targetIdentifiers;
-  if (
-    objectSchema.generatedBy === 'user' ||
-    objectSchema.generatedBy === 'systemWithUser'
-  ) {
-    submittedByUserId =
-      requestParams.submittedByUserId ||
-      _izContext.correlationIds.get(coreConsts.SUBMITTED_BY_USER_ID);
-
-    targetIdentifiers = requestParams.targetIdentifiers;
-
-    if (!targetIdentifiers && submittedByUserId) {
-      targetIdentifiers = { submittedByUserId };
-    }
-
-    if (!submittedByUserId) errorsFound.push('Not have submittedByUserId');
-    if (objectSchema.hasOwnProperty('belongTo') && !targetIdentifiers)
-      errorsFound.push('not have targetIdentifiers');
-
-    if (targetIdentifiers) {
-      if (!targetIdentifiers.submittedByUserId && submittedByUserId) {
-        targetIdentifiers.submittedByUserId = submittedByUserId;
-      }
-
-      if (Array.isArray(objectSchema.identifiers)) {
-        for (const identifier of objectSchema.identifiers) {
-          if (identifier.fieldName) {
-            if (targetIdentifiers[identifier.fieldName] === undefined) {
-              targetIdentifiers[identifier.fieldName] = null;
-            }
-          } else if (Array.isArray(identifier.fieldNames)) {
-            for (const fn of identifier.fieldNames) {
-              if (targetIdentifiers[fn] === undefined) {
-                targetIdentifiers[fn] = null;
-              }
-            }
-          } else if (identifier.name) {
-            if (targetIdentifiers[identifier.name] === undefined) {
-              targetIdentifiers[identifier.name] = null;
-            }
-          }
-        }
-      }
-
-      requestParams.targetIdentifiers = targetIdentifiers;
-    }
-
-    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`, {
-      submittedByUserId: requestParams.submittedByUserId,
-      targetIdentifiers: requestParams.targetIdentifiers,
-      belongTo: objectSchema.belongTo,
-      generatedBy: objectSchema.generatedBy
-    });
-  } else if (objectSchema.generatedBy === 'searchResultGenerated') {
-    throw new NoRetryError(
-      'error searchResultGenerated should not happen here'
-    );
-  }
-
-  return { objType, objectSchema, targetIdentifiers };
-}
-
-/**
- * Resolves fromRequiredOnCreate fields and generates identifiers
- * @param {Object} _izContext - Izara context object
- * @param {Object} requestParams - Request parameters
- * @param {Object} objectSchema - Base object schema
- * @param {Object} objType - Object type
- * @param {Object} targetIdentifiers - Target identifiers
- * @param {Array<string>} errorsFound - Error list
- * @returns {Promise<{ objectSchemas: Object, createDataDetails: Object }>}
- */
-async function resolveAndGenerateIdentifiers(
-  _izContext,
-  requestParams,
-  objectSchema,
-  objType,
-  targetIdentifiers,
-  errorsFound
-) {
-  const objectSchemas =
-    uploadUseCase.generateObjectSchemaForCombineFieldNames(
-      _izContext,
-      objectSchema
-    );
-  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] objectSchemas:`, objectSchemas);
-
-  const createDataDetails = await createDataDetailsLib(
-    _izContext,
-    objectSchemas
-  );
-  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] createDataDetails:`, createDataDetails);
-
-  if (requestParams.relationships?.length > 0) {
-    //(<beforeValidateRelationships>)
-    //(</beforeValidateRelationships>)
-  }
-
-  errorsFound.push(
-    ...(await createNodeLib.validateRequiredOnCreateLinks(
-      _izContext,
-      objType,
-      requestParams.relationships
-    ))
-  );
-  _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] errorsFound:`, errorsFound);
-
-  // ── Resolve fromRequiredOnCreate fields ──
-  if (objectSchemas.fieldNames) {
-    if (!requestParams.fieldNames) requestParams.fieldNames = {};
-    for (const [fieldName, val] of Object.entries(objectSchemas.fieldNames)) {
-      if (val.fromRequiredOnCreate && requestParams.fieldNames[fieldName] === undefined) {
-        const fromConfig = val.fromRequiredOnCreate;
-        const sourceField = fromConfig.fieldName || fieldName;
-        if (fromConfig.belongToObjType === true && targetIdentifiers) {
-          const targetValue =
-            targetIdentifiers[sourceField] !== undefined
-              ? targetIdentifiers[sourceField]
-              : Object.values(targetIdentifiers)[0];
-          requestParams.fieldNames[fieldName] = targetValue;
-        } else if (fromConfig.relType && requestParams.relationships?.length > 0) {
-          const matchedRel = requestParams.relationships.find(
-            (rel) =>
-              rel.relType?.serviceTag === fromConfig.relType.serviceTag &&
-              rel.relType?.relationshipTag === fromConfig.relType.relationshipTag
-          );
-          if (matchedRel?.targetIdentifiers?.[sourceField] !== undefined) {
-            requestParams.fieldNames[fieldName] = matchedRel.targetIdentifiers[sourceField];
-          }
-        }
-      }
-    }
-  }
-
-  // ── Resolve identifiers ──
-  let errors;
-  const identifiers = objectSchemas.identifiers;
-  let optionalOnCreateIdentifiers;
-
-  if (
-    identifiers.length === 1 &&
-    !identifiers[0].hasOwnProperty('fieldNames')
-  ) {
-    [requestParams, errors] = await createIdentifiersByUseCase(
-      _izContext,
-      requestParams,
-      objectSchemas,
-      identifiers[0],
-      optionalOnCreateIdentifiers
-    );
-    errorsFound.push(...errors);
-  } else if (identifiers.length > 1) {
-    for (const identifier of identifiers) {
-      [requestParams, errors] = await createIdentifiersByUseCase(
-        _izContext,
-        requestParams,
-        objectSchemas,
-        identifier,
-        optionalOnCreateIdentifiers
-      );
-      errorsFound.push(...errors);
-    }
-  }
-
-  return { objectSchemas, createDataDetails };
-}
-
-/**
- * Validates request field names against schema
- * @param {Object} requestParams - Request parameters
- * @param {Object} objectSchemas - Combined schema
- * @param {Array<string>} errorsFound - Error list
- */
-function validateFieldNames(requestParams, objectSchemas, errorsFound) {
-  const listOfRequiredOnCreate = [];
-  const listOfOptionalOnCreate = [];
-
-  for (const [key, val] of Object.entries(objectSchemas.fieldNames)) {
-    if (
-      val.randomOnCreate === true ||
-      val.requiredOnCreate === true ||
-      val.fromRequiredOnCreate ||
-      val.hashOnCreate?.length
-    ) {
-      listOfRequiredOnCreate.push(key);
-    }
-    if (val.requiredOnCreate === false && val.optionalOnCreate === true) {
-      listOfOptionalOnCreate.push(key);
-    }
-  }
-
-  for (const fieldName of Object.keys(requestParams.fieldNames)) {
-    if (
-      !listOfRequiredOnCreate.includes(fieldName) &&
-      !listOfOptionalOnCreate.includes(fieldName)
-    ) {
-      errorsFound.push('[invalid] over fieldNames create object');
-    }
-    if (errorsFound.length > 0) {
-      _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] HaveError:`, errorsFound);
-      break;
-    }
-  }
-}
-
 // ── Main Entry Function ───────────────────────────────────────────────────────
 
 /**
@@ -284,20 +63,23 @@ function validateFieldNames(requestParams, objectSchemas, errorsFound) {
 export default async function <%- flowTag %>(
   _izContext,
   requestParams,
-  callingFlowConfig = {},
+  callingFlowConfig = {}
   //(<additionalParams>)
   //(</additionalParams>)
 ) {
   try {
-    _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] createMain:`, {
-      requestParams,
-      callingFlowConfig
-    });
+    _izContext.logger.debug(
+      `[${process.env.iz_serviceTag}:<%- flowTag %>] createMain:`,
+      {
+        requestParams,
+        callingFlowConfig
+      }
+    );
 
     const errorsFound = [];
 
     // Step 1: Resolve Schema & Identity
-    const { objType, objectSchema, targetIdentifiers } =
+    const { objType, objectSchema } =
       await resolveSchemaAndIdentity(_izContext, requestParams, errorsFound);
 
     //(<beforeQuery>)
@@ -308,8 +90,6 @@ export default async function <%- flowTag %>(
       _izContext,
       requestParams,
       objectSchema,
-      objType,
-      targetIdentifiers,
       errorsFound
     );
 
@@ -323,7 +103,7 @@ export default async function <%- flowTag %>(
     }
 
     // Step 3: Validate FieldNames
-    validateFieldNames(requestParams, objectSchemas, errorsFound);
+    validateFieldNames(_izContext, requestParams, objectSchemas, errorsFound);
 
     if (errorsFound.length > 0) {
       return await <%- flowTag %>LogicalLib(
@@ -381,7 +161,9 @@ export default async function <%- flowTag %>(
         },
         parameterGroups,
         {
-          targetIdentifiers,
+          targetIdentifiers:
+            requestParams.rbacTargetIdentifiers ||
+            requestParams.targetIdentifiers,
           rbacObjType: {
             serviceTag: <%- rbacServiceTags.length === 1 ? rbacServiceTags[0] : `{ ${Object.entries(rbacServiceTagMap).map(([k, v]) => `'${k}': ${v}`).join(', ')} }[requestParams.objectType] || process.env.iz_serviceTag` %>
           },
@@ -412,111 +194,122 @@ 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,
+          fieldNames: requestParams.fieldNames,
+          relationships: requestParams.relationships || [],
+          targetIdentifiers: requestParams.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?.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(objInstanceFull.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,
+        fieldNames: requestParams.fieldNames,
+        relationships: requestParams.relationships || [],
+        targetIdentifiers: requestParams.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: requestParams.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(objInstanceFull.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,
@@ -524,32 +317,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 createLogicalLib ────────────
-      const phaseResults = Object.fromEntries(
-        lambdaSyncInvResults.map(({ flowTag: tag, returnValue }) => [tag, returnValue])
-      );
-
       return await <%- flowTag %>LogicalLib(
         _izContext,
         requestParams,
         callingFlowConfig,
-        errorsFound,
-        phaseResults
+        errorsFound
       );
       <%_ } _%>
     }
@@ -565,7 +362,10 @@ export default async function <%- flowTag %>(
       errorsFound
     );
   } catch (err) {
-    _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>] error:`, err);
+    _izContext.logger.error(
+      `[${process.env.iz_serviceTag}:<%- flowTag %>] error:`,
+      err
+    );
     throw err;
   }
 }