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

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

@@ -102,29 +102,33 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
         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;
-            }
-          }
-        }
-      }
+      // 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;
     }
 
+    if (requestParams.rbacTargetIdentifiers === undefined && targetIdentifiers) {
+      requestParams.rbacTargetIdentifiers = targetIdentifiers;
+    }
+
     _izContext.logger.debug(`[${process.env.iz_serviceTag}:<%- flowTag %>] Identity & Target Context Resolved:`, {
       submittedByUserId: requestParams.submittedByUserId,
       targetIdentifiers: requestParams.targetIdentifiers,
@@ -136,54 +140,165 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
   }
 
   requestParams.submittedByUserId = submittedByUserId;
-  return { objType, objectSchema };
+  return { objType, objectSchema, targetIdentifiers };
 }
 
 /**
- * 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];
+          }
+        }
+      }
+    }
+  }
+
+  // ── 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);
+      }
     }
   }
 
-  _izContext.logger.debug(
-    `[${process.env.iz_serviceTag}:<%- flowTag %>] Identifiers generated:`,
-    identifiers
-  );
+  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;
+    }
   }
 }
 
@@ -641,60 +756,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 ───────────────────────────────────────────
@@ -1344,6 +1492,7 @@ export async function <%- flowTag %>LogicalLib(
               }
             );
 
+            const fieldsForHook = { ...objInstanceFullForDynamoDb.fields };
             objInstanceFullForDynamoDb.fields = {};
 
             // Auto-provision owner TargetRole for DynamoDB-only
@@ -1352,6 +1501,111 @@ export async function <%- flowTag %>LogicalLib(
               identifiersForCreateData,
               requestParams
             });
+
+            <%_ if (plan?.hasAfterHookSync) { _%>
+            // ── Synchronous After Hooks ──
+            <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv').forEach(hook => { _%>
+            <%_ 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(
+                  _izContext,
+                  '<%= hook.flowTag %>'
+                ),
+                {
+                  requestParams: hookPayload_<%= hook.flowTag %>,
+                  callingFlowConfig
+                }
+              );
+              if (hookResult?.errorsFound?.length > 0 || hookResult?.status === 'error') {
+                errorsFound.push(...(hookResult.errorsFound || ['Hook <%= hook.flowTag %> failed']));
+              }
+            } catch (hookErr) {
+              _izContext.logger.error('[<%- flowTag %>LogicalLib] Sync hook <%= hook.flowTag %> error:', hookErr);
+              errorsFound.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
+            }
+            <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
+            }
+            <%_ } _%>
+            <%_ }) _%>
+            <%_ } _%>
+
+            <%_ if (plan?.hasAfterHookAsync) { _%>
+            // ── Asynchronous After Hooks ──
+            <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'ownTopic').forEach(hook => { _%>
+            <%_ 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)) {
+            <%_ } _%>
+            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(
+                  await lambdaSharedLib.lambdaFunctionName(
+                    _izContext,
+                    '<%- flowTag %>AfterHookCallbackHdrSqs'
+                  ),
+                  {
+                    actionData: {
+                      objType,
+                      objInstanceFull: {
+                        identifiers: identifiersForCreateData,
+                        fields: fieldsForHook
+                      },
+                      relationships: requestParams.relationships || [],
+                      targetIdentifiers: requestParams.targetIdentifiers,
+                      status: 'complete',
+                      errorsFound
+                    }
+                  }
+                )
+              )
+            );
+
+            await sns.publishAsync(_izContext, {
+              TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+                _izContext,
+                '<%= hook.flowTag %>_In'
+              ),
+              Message: JSON.stringify(hookMsg_<%= hook.flowTag %>),
+              MessageAttributes: sns.createStringMessageAttributes(_izContext, {})
+            });
+            <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
+            }
+            <%_ } _%>
+            <%_ }) _%>
+            <%_ } _%>
           }
 
           //(<afterCreateRecordDynamo>)
@@ -1505,11 +1759,13 @@ export async function <%- flowTag %>LogicalLib(
 
     // 7. Handle DynamoDB-only Complete Path
     if (allAwaitingStepsId.length === 0 && listOfObjectForCreates.length === 0) {
+      <%_ if (!plan?.hasAfterHookAsync) { _%>
       await handleDynamoDbOnlyComplete(_izContext, {
         objType,
         objInstanceFullForDynamoDb,
         callingFlowConfig
       });
+      <%_ } _%>
     }
 
     return {

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

@@ -171,6 +171,48 @@ export default async function CreateNodeCallbackMain(
           node,
           submittedByUserId
         });
+
+        <%_ if (plan?.hasAfterHookSync) { _%>
+        // ── Synchronous After Hooks ──
+        <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'lambdaSyncInv').forEach(hook => { _%>
+        <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length === 1) { _%>
+        if (returnValue.requestParams?.objType?.objectType === '<%= hook.targetObjectTypes[0] %>') {
+        <%_ } else if (hook.targetObjectTypes && hook.targetObjectTypes.length > 1) { _%>
+        if (<%- JSON.stringify(hook.targetObjectTypes) %>.includes(returnValue.requestParams?.objType?.objectType)) {
+        <%_ } _%>
+        try {
+          let hookPayload_<%= hook.flowTag %> = {
+            objType: returnValue.requestParams.objType,
+            objInstanceFull: node.objInstanceFull,
+            relationships: node.relationships || [],
+            targetIdentifiers: requestParams.targetIdentifiers,
+            submittedByUserId
+          };
+          //(<beforeSendHook_<%= hook.flowTag %>>)
+          //(</beforeSendHook_<%= hook.flowTag %>>)
+          const hookResult = await lambda.invokeSync(
+            _izContext,
+            await lambdaSharedLib.lambdaFunctionName(
+              _izContext,
+              '<%= hook.flowTag %>'
+            ),
+            {
+              requestParams: hookPayload_<%= hook.flowTag %>,
+              callingFlowConfig
+            }
+          );
+          if (hookResult?.errorsFound?.length > 0 || hookResult?.status === 'error') {
+            errorsFound.push(...(hookResult.errorsFound || ['Hook <%= hook.flowTag %> failed']));
+          }
+        } catch (hookErr) {
+          _izContext.logger.error('[CreateNodeCallback] Sync hook <%= hook.flowTag %> error:', hookErr);
+          errorsFound.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
+        }
+        <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
+        }
+        <%_ } _%>
+        <%_ }) _%>
+        <%_ } _%>
       }
 
       const callingFlowConfig =
@@ -198,6 +240,53 @@ export default async function CreateNodeCallbackMain(
         _izContext
       );
 
+      <%_ if (plan?.hasAfterHookAsync) { _%>
+      // ── Asynchronous After Hooks ──
+      <%_ plan.afterHooks.filter(h => h?.generatedCodeConfig?.invocationType === 'ownTopic').forEach(hook => { _%>
+      <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length === 1) { _%>
+      if (returnValue.requestParams?.objType?.objectType === '<%= hook.targetObjectTypes[0] %>') {
+      <%_ } else if (hook.targetObjectTypes && hook.targetObjectTypes.length > 1) { _%>
+      if (<%- JSON.stringify(hook.targetObjectTypes) %>.includes(returnValue.requestParams?.objType?.objectType)) {
+      <%_ } _%>
+      let hookPayload_<%= hook.flowTag %> = {
+        objType: returnValue.requestParams.objType,
+        objInstanceFull: node.objInstanceFull,
+        relationships: node.relationships || [],
+        targetIdentifiers: requestParams.targetIdentifiers,
+        submittedByUserId
+      };
+      //(<beforeSendHook_<%= hook.flowTag %>>)
+      //(</beforeSendHook_<%= hook.flowTag %>>)
+      const hookMsg_<%= hook.flowTag %> = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+        hookPayload_<%= hook.flowTag %>,
+        callingFlowSharedLib.addParentCallingFlowConfig(
+          callingFlowConfig,
+          callingFlowSharedLib.createCallingFlowConfig(
+            await lambdaSharedLib.lambdaFunctionName(
+              _izContext,
+              'CreateAfterHookCallbackHdrSqs'
+            ),
+            {
+              quotaKeys,
+              actionData
+            }
+          )
+        )
+      );
+
+      await sns.publishAsync(_izContext, {
+        TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+          _izContext,
+          '<%= hook.flowTag %>_In'
+        ),
+        Message: JSON.stringify(hookMsg_<%= hook.flowTag %>),
+        MessageAttributes: sns.createStringMessageAttributes(_izContext, {})
+      });
+      <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
+      }
+      <%_ } _%>
+      <%_ }) _%>
+      <%_ } else { _%>
       await forwardToQuotaConfirmation(_izContext, {
         status,
         errorsFound,
@@ -205,6 +294,7 @@ export default async function CreateNodeCallbackMain(
         actionData,
         callingFlowConfig
       });
+      <%_ } _%>
     }
 
     await asyncFlowSharedLib.removeAwaitingMultipleStep(