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

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

@@ -51,10 +51,6 @@ import {
 //(<optionalRequire>)
 //(</optionalRequire>)
 
-const { createObjType, firstLetterUpperCase } = utils;
-const { createDataDetailsLib } = dataDetailsLib;
-const { createIdentifiersByUseCase } = identifiersObject;
-
 // ── Main Entry Function ───────────────────────────────────────────────────────
 
 /**
@@ -83,7 +79,7 @@ export default async function <%- flowTag %>(
     const errorsFound = [];
 
     // Step 1: Resolve Schema & Identity
-    const { objType, objectSchema, targetIdentifiers } =
+    const { objType, objectSchema } =
       await resolveSchemaAndIdentity(_izContext, requestParams, errorsFound);
 
     //(<beforeQuery>)
@@ -94,8 +90,6 @@ export default async function <%- flowTag %>(
       _izContext,
       requestParams,
       objectSchema,
-      objType,
-      targetIdentifiers,
       errorsFound
     );
 
@@ -167,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` %>
           },
@@ -198,11 +194,15 @@ export default async function <%- flowTag %>(
 
     // ── Optional phase extension point ────────────────────────────────────────
     <%_
+    const allCrudObjectTypes = (objects || []).filter(isCrudObject).map(o => o.objectType);
     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);
+      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;
     }, {});
     _%>
@@ -216,6 +216,15 @@ export default async function <%- flowTag %>(
       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(
@@ -223,13 +232,7 @@ export default async function <%- flowTag %>(
             '<%= config.flowTag %>'
           ),
           {
-            requestParams: {
-              objType,
-              fieldNames: requestParams.fieldNames,
-              relationships: requestParams.relationships || [],
-              targetIdentifiers,
-              submittedByUserId: requestParams.submittedByUserId
-            },
+            requestParams: hookPayload_<%= config.flowTag %>,
             callingFlowConfig
           }
         );
@@ -274,15 +277,18 @@ export default async function <%- flowTag %>(
       <%_ if (hasOwnTopic) { _%>
       // ── 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(
-          {
-            objType,
-            fieldNames: requestParams.fieldNames,
-            relationships: requestParams.relationships || [],
-            targetIdentifiers,
-            submittedByUserId: requestParams.submittedByUserId
-          },
+          hookPayload_<%= config.flowTag %>,
           callingFlowSharedLib.addParentCallingFlowConfig(
             callingFlowConfig,
             callingFlowSharedLib.createCallingFlowConfig(
@@ -294,7 +300,7 @@ export default async function <%- flowTag %>(
                 originalRequestParams: {
                   ...requestParams,
                   objType,
-                  targetIdentifiers
+                  targetIdentifiers: requestParams.targetIdentifiers
                 },
                 callingFlowConfig
               }

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

@@ -89,7 +89,11 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
 
     targetIdentifiers = requestParams.targetIdentifiers;
 
-    if (!targetIdentifiers && submittedByUserId) {
+    if (
+      !targetIdentifiers &&
+      objectSchema.belongTo?.objectType === 'user' &&
+      submittedByUserId
+    ) {
       targetIdentifiers = { submittedByUserId };
     }
 
@@ -98,10 +102,6 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
       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) {
@@ -122,7 +122,11 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
       //   }
       // }
 
-      // requestParams.targetIdentifiers = targetIdentifiers;
+      requestParams.targetIdentifiers = targetIdentifiers;
+    }
+
+    if (requestParams.rbacTargetIdentifiers === undefined && targetIdentifiers) {
+      requestParams.rbacTargetIdentifiers = { ...targetIdentifiers };
     }
 
     _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`, {
@@ -140,50 +144,161 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
 }
 
 /**
- * Resolves and generates primary identifiers for the object
+ * Resolves fromRequiredOnCreate fields and generates identifiers
  * @param {Object} _izContext - Izara context object
- * @param {Object} objectSchemas - Combined object schema
- * @param {Object} requestParams - Incoming request parameters
- * @returns {Promise<void>}
+ * @param {Object} requestParams - Request parameters
+ * @param {Object} objectSchema - Base object schema
+ * @param {Array<string>} errorsFound - Error list
+ * @returns {Promise<{ objectSchemas: Object }>}
  */
-export async function resolveAndGenerateIdentifiers(_izContext, objectSchemas, requestParams) {
-  const identifiers = await createIdentifiersByUseCase(
-    _izContext,
-    objectSchemas,
-    requestParams.fieldNames
+export async function resolveAndGenerateIdentifiers(
+  _izContext,
+  requestParams,
+  objectSchema,
+  errorsFound
+) {
+  const objType = createObjType(requestParams.objectType);
+  const targetIdentifiers = requestParams.targetIdentifiers;
+
+  const objectSchemas =
+    uploadUseCase.generateObjectSchemaForCombineFieldNames(
+      _izContext,
+      objectSchema
+    );
+  _izContext.logger.debug(
+    `[${process.env.iz_serviceTag}:<%- flowTag %>] objectSchemas:`,
+    objectSchemas
   );
 
-  for (const [key, value] of Object.entries(identifiers)) {
-    if (!requestParams.fieldNames.hasOwnProperty(key)) {
-      requestParams.fieldNames[key] = value;
+  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) {
+          let targetValue = targetIdentifiers[sourceField];
+          if (targetValue === undefined) {
+            targetValue = 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];
+          }
+        }
+      }
     }
   }
 
-  _izContext.logger.debug(
-    `[${process.env.iz_serviceTag}:<%- flowTag %>] Identifiers generated:`,
-    identifiers
-  );
+  // ── 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
+    );
+    if (errors?.length > 0) {
+      errorsFound.push(...errors);
+    }
+  } else if (identifiers?.length > 1) {
+    for (const identifier of identifiers) {
+      [requestParams, errors] = await createIdentifiersByUseCase(
+        _izContext,
+        requestParams,
+        objectSchemas,
+        identifier,
+        optionalOnCreateIdentifiers
+      );
+      if (errors?.length > 0) {
+        errorsFound.push(...errors);
+      }
+    }
+  }
+
+  return { objectSchemas };
 }
 
 /**
  * Validates request field names against schema definition
  * @param {Object} _izContext - Izara context object
- * @param {Object} objectSchemas - Combined object schema
  * @param {Object} requestParams - Incoming request parameters
+ * @param {Object} objectSchemas - Combined object schema
  * @param {Array<string>} errorsFound - Array to collect validation errors
  */
-export function validateFieldNames(_izContext, objectSchemas, requestParams, errorsFound) {
-  const invalidFieldNames = [];
-  for (const fieldName of Object.keys(requestParams.fieldNames || {})) {
-    if (!objectSchemas.fieldNames.includes(fieldName)) {
-      invalidFieldNames.push(fieldName);
+export function validateFieldNames(
+  _izContext,
+  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);
     }
   }
 
-  if (invalidFieldNames.length > 0) {
-    errorsFound.push(
-      `Invalid fieldName not match from Schema: ${invalidFieldNames.join(',')}`
-    );
+  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;
+    }
   }
 }
 
@@ -372,14 +487,43 @@ export async function saveDynamoDbRecords(_izContext, listOfRecords) {
   );
 }
 
+<%_
+const rootRbacObjects = (objects || []).filter(obj => {
+  const hasSelfRbac = Array.isArray(obj?.addOnDataStructure) && obj.addOnDataStructure.some(addOn => addOn?.type === 'rbac');
+  return hasSelfRbac && !obj?.belongTo && obj?.objectType !== 'user' && obj?.generatedBy !== 'systemNoUser';
+});
+_%>
+const ROOT_RBAC_OBJECT_TYPES = new Set([
+<%_ for (const obj of rootRbacObjects) { _%>
+  '<%- obj.objectType %>',
+<%_ } _%>
+]);
+
 /**
  * Auto-provisions owner TargetRole for Root RBAC object after Graph and DynamoDB write
  * @param {Object} _izContext - Izara context object
  * @param {Object} options - Target node and submitter details
  * @returns {Promise<void>}
  */
-export async function autoProvisionOwnerTargetRole(_izContext, { node, submittedByUserId }) {
+export async function autoProvisionOwnerTargetRole(_izContext, { node, submittedByUserId, objType }) {
   try {
+    let objectType = null;
+    if (typeof objType === 'string') {
+      objectType = objType;
+    } else if (objType && objType.objectType) {
+      objectType = objType.objectType;
+    } else if (typeof node?.objType === 'string') {
+      objectType = node.objType;
+    } else if (node?.objType?.objectType) {
+      objectType = node.objType.objectType;
+    } else if (node?.objectType) {
+      objectType = node.objectType;
+    }
+
+    if (!objectType || !ROOT_RBAC_OBJECT_TYPES.has(objectType)) {
+      return;
+    }
+
     if (!submittedByUserId || !node?.objInstanceFull?.identifiers) {
       return;
     }
@@ -641,60 +785,93 @@ export function resolveQuotaDeductionKeys(
 }
 
 /**
- * Forwards quota confirmation message to ConfirmUsage_In or CancelUsage_In
+ * Forwards quota confirmation or cancellation to RBAC via synchronous invoke
+ * and publishes final completion message to outCreateNodeComplete
  * @param {Object} _izContext - Izara context object
  * @param {Object} options - Message forwarding options
- * @returns {Promise<void>}
+ * @returns {Promise<Object>} Quota invocation result
  */
 export async function forwardToQuotaConfirmation(
   _izContext,
   {
     status,
-    errorsFound,
+    errorsFound = [],
     quotaKeys,
     actionData,
     callingFlowConfig
   }
 ) {
-  const nextTargetTopic =
-    status === 'complete' && errorsFound.length === 0
-      ? 'ConfirmUsage_In'
-      : 'CancelUsage_In';
+  let quotaResult = null;
+  if (quotaKeys && (quotaKeys.limitTag || quotaKeys.flowTypeConcat)) {
+    let targetFunction = 'CancelUsageHdrInv';
+    if (status === 'complete' && errorsFound.length === 0) {
+      targetFunction = 'ConfirmUsageHdrInv';
+    }
 
-  const forwardMessage =
-    callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-      {
-        ...quotaKeys,
-        parentPassBackProperties: actionData
-      },
-      callingFlowSharedLib.addParentCallingFlowConfig(
-        callingFlowConfig,
-        callingFlowSharedLib.createCallingFlowConfig(
-          await lambdaSharedLib.lambdaFunctionName(
-            _izContext,
-            'CreateCompleteHdrSqs'
-          ),
-          {}
-        )
-      )
+    const functionName = await lambdaSharedLib.lambdaFunctionName(
+      _izContext,
+      targetFunction,
+      'Rbac'
     );
 
-  const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
-    _izContext,
-    nextTargetTopic,
-    'Rbac'
+    const forwardMessage = {
+      ...quotaKeys,
+      parentPassBackProperties: actionData,
+      callingFlowConfig
+    };
+
+    _izContext.logger.debug('[CreateLogicalLib] invoking RBAC quota sync', {
+      targetFunction,
+      functionName,
+      forwardMessage
+    });
+
+    try {
+      quotaResult = await lambda.invokeSync(
+        _izContext,
+        functionName,
+        forwardMessage
+      );
+    } catch (err) {
+      _izContext.logger.error(
+        `[CreateLogicalLib] error invoking ${targetFunction}:`,
+        err
+      );
+      if (targetFunction === 'ConfirmUsageHdrInv') {
+        try {
+          const cancelFunctionName = await lambdaSharedLib.lambdaFunctionName(
+            _izContext,
+            'CancelUsageHdrInv',
+            'Rbac'
+          );
+          await lambda.invokeSync(
+            _izContext,
+            cancelFunctionName,
+            forwardMessage
+          );
+        } catch (cancelErr) {
+          _izContext.logger.error(
+            '[CreateLogicalLib] error invoking CancelUsageHdrInv fallback:',
+            cancelErr
+          );
+        }
+      }
+      errorsFound.push(err.message || 'Quota confirmation failed');
+      if (actionData) {
+        actionData.status = 'error';
+        actionData.errorsFound = errorsFound;
+      }
+    }
+  }
+
+  const { message, messageAttributes } = buildCompletionPayload(
+    callingFlowConfig,
+    actionData
   );
 
-  _izContext.logger.debug('[CreateNodeCallback] forwarding to RBAC', {
-    nextTargetTopic,
-    TopicArn: topicArn,
-    forwardMessage
-  });
+  await publishCompletionMessage(_izContext, message, messageAttributes);
 
-  await sns.publishAsync(_izContext, {
-    Message: JSON.stringify(forwardMessage),
-    TopicArn: topicArn
-  });
+  return quotaResult;
 }
 
 // ── 4. CreateComplete_Main Helpers ───────────────────────────────────────────
@@ -1357,10 +1534,24 @@ export async function <%- flowTag %>LogicalLib(
             <%_ if (plan?.hasAfterHookSync) { _%>
             // ── Synchronous After Hooks ──
             <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv').forEach(hook => { _%>
-            <%_ if (hook.objType?.objectType) { _%>
-            if (objType.objectType === '<%= hook.objType.objectType %>') {
+            <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length === 1) { _%>
+            if (objType.objectType === '<%= hook.targetObjectTypes[0] %>') {
+            <%_ } else if (hook.targetObjectTypes && hook.targetObjectTypes.length > 1) { _%>
+            if (<%- JSON.stringify(hook.targetObjectTypes) %>.includes(objType.objectType)) {
             <%_ } _%>
             try {
+              let hookPayload_<%= hook.flowTag %> = {
+                objType,
+                objInstanceFull: {
+                  identifiers: identifiersForCreateData,
+                  fields: fieldsForHook
+                },
+                relationships: requestParams.relationships || [],
+                targetIdentifiers: requestParams.targetIdentifiers,
+                submittedByUserId: requestParams.submittedByUserId
+              };
+              //(<beforeSendHook_<%= hook.flowTag %>>)
+              //(</beforeSendHook_<%= hook.flowTag %>>)
               const hookResult = await lambda.invokeSync(
                 _izContext,
                 await lambdaSharedLib.lambdaFunctionName(
@@ -1368,16 +1559,7 @@ export async function <%- flowTag %>LogicalLib(
                   '<%= hook.flowTag %>'
                 ),
                 {
-                  requestParams: {
-                    objType,
-                    objInstanceFull: {
-                      identifiers: identifiersForCreateData,
-                      fields: fieldsForHook
-                    },
-                    relationships: requestParams.relationships || [],
-                    targetIdentifiers: requestParams.targetIdentifiers,
-                    submittedByUserId: requestParams.submittedByUserId
-                  },
+                  requestParams: hookPayload_<%= hook.flowTag %>,
                   callingFlowConfig
                 }
               );
@@ -1388,7 +1570,7 @@ export async function <%- flowTag %>LogicalLib(
               _izContext.logger.error('[<%- flowTag %>LogicalLib] Sync hook <%= hook.flowTag %> error:', hookErr);
               errorsFound.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
             }
-            <%_ if (hook.objType?.objectType) { _%>
+            <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
             }
             <%_ } _%>
             <%_ }) _%>
@@ -1397,20 +1579,25 @@ export async function <%- flowTag %>LogicalLib(
             <%_ if (plan?.hasAfterHookAsync) { _%>
             // ── Asynchronous After Hooks ──
             <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'ownTopic').forEach(hook => { _%>
-            <%_ if (hook.objType?.objectType) { _%>
-            if (objType.objectType === '<%= hook.objType.objectType %>') {
+            <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length === 1) { _%>
+            if (objType.objectType === '<%= hook.targetObjectTypes[0] %>') {
+            <%_ } else if (hook.targetObjectTypes && hook.targetObjectTypes.length > 1) { _%>
+            if (<%- JSON.stringify(hook.targetObjectTypes) %>.includes(objType.objectType)) {
             <%_ } _%>
-            const hookMsg_<%= hook.flowTag %> = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-              {
-                objType,
-                objInstanceFull: {
-                  identifiers: identifiersForCreateData,
-                  fields: fieldsForHook
-                },
-                relationships: requestParams.relationships || [],
-                targetIdentifiers: requestParams.targetIdentifiers,
-                submittedByUserId: requestParams.submittedByUserId
+            let hookPayload_<%= hook.flowTag %> = {
+              objType,
+              objInstanceFull: {
+                identifiers: identifiersForCreateData,
+                fields: fieldsForHook
               },
+              relationships: requestParams.relationships || [],
+              targetIdentifiers: requestParams.targetIdentifiers,
+              submittedByUserId: requestParams.submittedByUserId
+            };
+            //(<beforeSendHook_<%= hook.flowTag %>>)
+            //(</beforeSendHook_<%= hook.flowTag %>>)
+            const hookMsg_<%= hook.flowTag %> = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+              hookPayload_<%= hook.flowTag %>,
               callingFlowSharedLib.addParentCallingFlowConfig(
                 callingFlowConfig,
                 callingFlowSharedLib.createCallingFlowConfig(
@@ -1443,7 +1630,7 @@ export async function <%- flowTag %>LogicalLib(
               Message: JSON.stringify(hookMsg_<%= hook.flowTag %>),
               MessageAttributes: sns.createStringMessageAttributes(_izContext, {})
             });
-            <%_ if (hook.objType?.objectType) { _%>
+            <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
             }
             <%_ } _%>
             <%_ }) _%>