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

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

@@ -23,29 +23,29 @@ function empty(value) {
   );
 }
 
-function validateInput(returnValue, status, graphServiceTag, errorsFound) {
+function validateInput(returnValue, status, graphServiceTag, foundErrors) {
   if (!returnValue?.queryResult)
-    errorsFound.push(
+    foundErrors.push(
       'message is not have property queryResult, should be not happen'
     );
   if (!returnValue?.requestParams?.objType)
-    errorsFound.push(
+    foundErrors.push(
       'message is not have property objType, should be not happen'
     );
   if (!returnValue?.requestParams?.objInstanceFull)
-    errorsFound.push(
+    foundErrors.push(
       'message is not have property objInstance, should be not objInstance'
     );
-  if (status === 'error' && errorsFound.length === 0)
-    errorsFound.push(
-      '[invalid]status is error not have errorsFound form graphService'
+  if (status === 'error' && foundErrors.length === 0)
+    foundErrors.push(
+      '[invalid]status is error not have foundErrors form graphService'
     );
-  if (status === 'complete' && errorsFound.length > 0)
-    errorsFound.push(
-      '[Invalid] status is complete should be not have errorsFound'
+  if (status === 'complete' && foundErrors.length > 0)
+    foundErrors.push(
+      '[Invalid] status is complete should be not have foundErrors'
     );
   if (graphServiceTag == null)
-    errorsFound.push('[Invalid] graphServerTag is not empty string');
+    foundErrors.push('[Invalid] graphServerTag is not empty string');
 }
 
 export default async function UpdateComplete(
@@ -62,14 +62,14 @@ export default async function UpdateComplete(
     const {
       returnValue,
       status,
-      errorsFound = [],
+      foundErrors = [],
       graphServiceTag,
       parentFlowId
     } = requestParams;
     if (empty(returnValue?.requestParams))
       throw new NoRetryError('message not an object');
-    validateInput(returnValue, status, graphServiceTag, errorsFound);
-    if (errorsFound.length > 0) errorsFound.push(errorsFound.join(','));
+    validateInput(returnValue, status, graphServiceTag, foundErrors);
+    if (foundErrors.length > 0) foundErrors.push(foundErrors.join(','));
 
     const awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
       parentFlowId,
@@ -88,14 +88,14 @@ export default async function UpdateComplete(
       _izContext.logger.warn(
         `No pending step found for awaitingStepId: ${awaitingStepId}`
       );
-      return { returnValue, status, errorsFound };
+      return { returnValue, status, foundErrors };
     }
     const result =
       await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithReturnParams(
         _izContext,
         pending.pendingStepId,
         awaitingStepId,
-        errorsFound
+        foundErrors
       );
     _izContext.logger.debug(
       '[UpdateComplete] all awaiting steps result',
@@ -154,7 +154,7 @@ export default async function UpdateComplete(
         parentFlowId: parentFlowId || returnValue?.parentFlowId,
         existsNode,
         status,
-        errorsFound
+        foundErrors
       };
 
       <%_ if (plan?.hasAfterHookSync) { _%>
@@ -185,12 +185,12 @@ export default async function UpdateComplete(
             callingFlowConfig
           }
         );
-        if (hookResult?.errorsFound?.length > 0 || hookResult?.status === 'error') {
-          errorsFound.push(...(hookResult.errorsFound || ['Hook <%= hook.flowTag %> failed']));
+        if (hookResult?.foundErrors?.length > 0 || hookResult?.status === 'error') {
+          foundErrors.push(...(hookResult.foundErrors || ['Hook <%= hook.flowTag %> failed']));
         }
       } catch (hookErr) {
         _izContext.logger.error('[UpdateComplete] Sync hook <%= hook.flowTag %> error:', hookErr);
-        errorsFound.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
+        foundErrors.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
       }
       <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
       }
@@ -277,9 +277,9 @@ export default async function UpdateComplete(
       _izContext,
       awaitingStepId,
       pending.pendingStepId,
-      errorsFound
+      foundErrors
     );
-    return { returnValue, status, errorsFound };
+    return { returnValue, status, foundErrors };
   } catch (error) {
     _izContext.logger.error('[UpdateComplete] error:', error);
     throw error;

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

@@ -77,11 +77,11 @@ export default async function <%- flowTag %>(
       callingFlowConfig
     });
 
-    const errorsFound = [];
+    const foundErrors = [];
 
     // ── Resolve Schema & Identity ─────────────────────────────────────────────
     const { objType, objectSchema, targetIdentifiers } =
-      await resolveSchemaAndIdentity(_izContext, requestParams, errorsFound);
+      await resolveSchemaAndIdentity(_izContext, requestParams, foundErrors);
 
     // ── Build identifiers used by asynchronous processing ────────────────────
     const identifiers = requestParams.objInstanceFull?.identifiers;
@@ -110,7 +110,7 @@ export default async function <%- flowTag %>(
     //       value !== undefined &&
     //       targetIdentifiers[key] !== value
     //     ) {
-    //       errorsFound.push(
+    //       foundErrors.push(
     //         `targetIdentifiers.${key} must match objInstanceFull.identifiers.${key}`
     //       );
     //     }
@@ -120,12 +120,12 @@ export default async function <%- flowTag %>(
     //(<validateBeforeUpdate>)
     //(</validateBeforeUpdate>)
 
-    if (errorsFound.length > 0)
+    if (foundErrors.length > 0)
       return await <%- flowTag %>LogicalLib(
         _izContext,
         requestParams,
         callingFlowConfig,
-        errorsFound
+        foundErrors
       );
 
     <%_
@@ -184,12 +184,12 @@ export default async function <%- flowTag %>(
       );
 
       if (resultPermissionCheck && resultPermissionCheck.permission !== true) {
-        errorsFound.push('Permission denied');
+        foundErrors.push('Permission denied');
         return await <%- flowTag %>LogicalLib(
           _izContext,
           requestParams,
           callingFlowConfig,
-          errorsFound
+          foundErrors
         );
       }
 
@@ -249,10 +249,10 @@ export default async function <%- flowTag %>(
           flowTag: '<%= config.flowTag %>',
           returnValue
         });
-        if (returnValue?.errorsFound?.length > 0) {
-          errorsFound.push(...returnValue.errorsFound);
+        if (returnValue?.foundErrors?.length > 0) {
+          foundErrors.push(...returnValue.foundErrors);
         } else if (returnValue?.status === 'error') {
-          errorsFound.push('Error from <%= config.flowTag %>');
+          foundErrors.push('Error from <%= config.flowTag %>');
         } else {
           if (returnValue?.fields && requestParams?.objInstanceFull?.fields) {
             Object.assign(requestParams.objInstanceFull.fields, returnValue.fields);
@@ -270,16 +270,16 @@ export default async function <%- flowTag %>(
           '[<%- flowTag %>] Sync hook <%= config.flowTag %> error:',
           hookErr
         );
-        errorsFound.push(hookErr.message || 'Hook <%= config.flowTag %> failed');
+        foundErrors.push(hookErr.message || 'Hook <%= config.flowTag %> failed');
       }
       <%_ } _%>
 
-      if (errorsFound.length > 0) {
+      if (foundErrors.length > 0) {
         return await <%- flowTag %>LogicalLib(
           _izContext,
           requestParams,
           callingFlowConfig,
-          errorsFound
+          foundErrors
         );
       }
       <%_ } _%>
@@ -362,7 +362,7 @@ export default async function <%- flowTag %>(
         _izContext,
         requestParams,
         callingFlowConfig,
-        errorsFound
+        foundErrors
       );
       <%_ } _%>
     }
@@ -376,7 +376,7 @@ export default async function <%- flowTag %>(
       _izContext,
       requestParams,
       callingFlowConfig,
-      errorsFound
+      foundErrors
     );
   } catch (err) {
     _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>] error:`, err);

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

@@ -67,10 +67,10 @@ const PREFIX = {
  * Loads ObjectSchema and resolves submittedByUserId and targetIdentifiers
  * @param {Object} _izContext - Izara context object
  * @param {Object} requestParams - Incoming request parameters
- * @param {Array<string>} errorsFound - Array to collect validation errors
+ * @param {Array<string>} foundErrors - Array to collect validation errors
  * @returns {Promise<{ objType: string, objectSchema: Object }>}
  */
-export async function resolveSchemaAndIdentity(_izContext, requestParams, errorsFound) {
+export async function resolveSchemaAndIdentity(_izContext, requestParams, foundErrors) {
   const objType = createObjType(requestParams.objectType);
   const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
     _izContext,
@@ -97,10 +97,10 @@ export async function resolveSchemaAndIdentity(_izContext, requestParams, errors
     }
 
     if (!submittedByUserId) {
-      errorsFound.push('Not have submittedByUserId');
+      foundErrors.push('Not have submittedByUserId');
     }
     if (objectSchema.hasOwnProperty('belongTo') && !targetIdentifiers) {
-      errorsFound.push('not have targetIdentifiers');
+      foundErrors.push('not have targetIdentifiers');
     }
 
     requestParams.submittedByUserId = submittedByUserId;
@@ -153,7 +153,7 @@ export async function collectRbacAwaitingResults(_izContext, requestParams) {
       _izContext,
       rbacPendingStepId,
       currentAwaitingStepId,
-      requestParams.errorsFound,
+      requestParams.foundErrors,
       {
         returnValue: requestParams.returnValue,
         rbacType
@@ -170,7 +170,7 @@ export async function collectRbacAwaitingResults(_izContext, requestParams) {
   const {
     isComplete,
     collectedReturnValueByAwaitingStepId,
-    collectedErrors: errorsFound = [],
+    collectedErrors: foundErrors = [],
     additionalAttributes
   } = rbacAwaitingStepsResult;
 
@@ -214,7 +214,7 @@ export async function collectRbacAwaitingResults(_izContext, requestParams) {
     isComplete: true,
     rbacResults,
     originalRequestParams,
-    collectedErrors: errorsFound
+    collectedErrors: foundErrors
   };
 }
 
@@ -224,13 +224,13 @@ export async function collectRbacAwaitingResults(_izContext, requestParams) {
  * @param {Object} options - Validation options
  * @returns {Promise<{ hasError: boolean, errorResult?: Object, rbacCallbackResults: Object }>}
  */
-export async function assertRbacPermission(_izContext, { rbacResults, originalRequestParams, errorsFound }) {
+export async function assertRbacPermission(_izContext, { rbacResults, originalRequestParams, foundErrors }) {
   const rbacCallbackResults = {};
   let hasError = false;
 
   for (const [type, result] of Object.entries(rbacResults || {})) {
     if (result && result.error) {
-      errorsFound.push(result.error);
+      foundErrors.push(result.error);
       hasError = true;
     } else {
       rbacCallbackResults[type] = result;
@@ -246,7 +246,7 @@ export async function assertRbacPermission(_izContext, { rbacResults, originalRe
   }
 
   if (!isAllowed) {
-    errorsFound.push('Permission denied');
+    foundErrors.push('Permission denied');
   }
 
   _izContext.logger.debug(
@@ -254,13 +254,13 @@ export async function assertRbacPermission(_izContext, { rbacResults, originalRe
     {
       rbacCallbackResults,
       isAllowed,
-      errorsFound
+      foundErrors
     }
   );
 
-  if (hasError || errorsFound.length > 0) {
+  if (hasError || foundErrors.length > 0) {
     const errorResult = {
-      errorsFound,
+      foundErrors,
       status: 'rejected',
       requestParams: originalRequestParams
     };
@@ -322,13 +322,13 @@ export async function resolveObjectSchemas(_izContext, objectType) {
  * @param {Object} requestParams - Request parameters
  * @param {Object} objectSchema - Object schema
  * @param {Object} versionedDataIds - Versioned data IDs map
- * @param {Array<string>} errorsFound - Array to collect validation errors
+ * @param {Array<string>} foundErrors - Array to collect validation errors
  */
 export function validateVersionedDataIds(
   requestParams,
   objectSchema,
   versionedDataIds,
-  errorsFound
+  foundErrors
 ) {
   const versionedDataIdsKeys = Object.keys(versionedDataIds || {});
   if (versionedDataIdsKeys.length === 0) {
@@ -364,17 +364,17 @@ export function validateVersionedDataIds(
   );
 
   if (missingVersionedDataIdLabels.length > 0) {
-    errorsFound.push(
+    foundErrors.push(
       `missing versionedDataIds of versionedDataLabel '${missingVersionedDataIdLabels.join(', ')}'`
     );
   }
   if (missingDataVersionedDataLabels.length > 0) {
-    errorsFound.push(
+    foundErrors.push(
       `missing data of versionedDataLabels '${missingDataVersionedDataLabels.join(', ')}'`
     );
   }
   if (Object.keys(updateMainNodeData).length > 0) {
-    errorsFound.push('cannot update mainNode if have versionedDataIds');
+    foundErrors.push('cannot update mainNode if have versionedDataIds');
   }
 }
 
@@ -598,7 +598,7 @@ export async function handleUpdateError(
     fields,
     versionedDataIds,
     callingFlowConfig,
-    errorsFound
+    foundErrors
   }
 ) {
   const updateNodeCompleteMessage =
@@ -609,7 +609,7 @@ export async function handleUpdateError(
         objInstanceFull: { identifiers, fields },
         versionedDataIds,
         status: 'error',
-        errorsFound
+        foundErrors
       }
     );
 
@@ -671,15 +671,15 @@ export async function publishCompletionMessage(_izContext, message, messageAttri
  * @param {Object} _izContext - Context object with logger
  * @param {Object} requestParams - { objectType, objInstanceFull, versionedDataIds, additionalParams }
  * @param {Object} callingFlowConfig - Calling flow configuration
- * @param {Array<string>} errorsFound - Array of preceding errors
+ * @param {Array<string>} foundErrors - Array of preceding errors
  * @param {Object} phaseResults - Results from preceding phases
- * @returns {Promise<Object>} Result with objType, objInstanceFull, versionedDataIds, status, errorsFound
+ * @returns {Promise<Object>} Result with objType, objInstanceFull, versionedDataIds, status, foundErrors
  */
 export async function <%- flowTag %>LogicalLib(
   _izContext,
   requestParams,
   callingFlowConfig = {},
-  errorsFound = [],
+  foundErrors = [],
   phaseResults = {}
 ) {
   try {
@@ -725,21 +725,21 @@ export async function <%- flowTag %>LogicalLib(
       requestParams,
       objectSchema,
       versionedDataIds,
-      errorsFound
+      foundErrors
     );
 
     //(<validateBeforeUpdate>)
     //(</validateBeforeUpdate>)
 
     // 3. Early exit on errors
-    if (errorsFound.length > 0) {
+    if (foundErrors.length > 0) {
       return await handleUpdateError(_izContext, {
         objType,
         identifiers,
         fields,
         versionedDataIds,
         callingFlowConfig,
-        errorsFound
+        foundErrors
       });
     }
 
@@ -882,11 +882,11 @@ export async function <%- flowTag %>LogicalLib(
           }
         );
         if (
-          hookResult?.errorsFound?.length > 0 ||
+          hookResult?.foundErrors?.length > 0 ||
           hookResult?.status === 'error'
         ) {
-          errorsFound.push(
-            ...(hookResult.errorsFound || ['Hook <%= hook.flowTag %> failed'])
+          foundErrors.push(
+            ...(hookResult.foundErrors || ['Hook <%= hook.flowTag %> failed'])
           );
         }
       } catch (hookErr) {
@@ -894,7 +894,7 @@ export async function <%- flowTag %>LogicalLib(
           '[<%- flowTag %>LogicalLib] Sync hook <%= hook.flowTag %> error:',
           hookErr
         );
-        errorsFound.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
+        foundErrors.push(hookErr.message || 'Hook <%= hook.flowTag %> failed');
       }
       <%_ if (hook.targetObjectTypes && hook.targetObjectTypes.length > 0) { _%>
       }
@@ -943,7 +943,7 @@ export async function <%- flowTag %>LogicalLib(
                   targetIdentifiers: requestParams.targetIdentifiers,
                   parentFlowId: requestParams.parentFlowId,
                   status: 'complete',
-                  errorsFound
+                  foundErrors
                 }
               }
             )
@@ -973,7 +973,7 @@ export async function <%- flowTag %>LogicalLib(
     }
 
     let resultStatus = 'complete';
-    if (errorsFound.length > 0) {
+    if (foundErrors.length > 0) {
       resultStatus = 'error';
     }
 
@@ -984,7 +984,7 @@ export async function <%- flowTag %>LogicalLib(
         versionedDataIds
       },
       status: resultStatus,
-      errorsFound
+      foundErrors
     };
   } catch (err) {
     _izContext.logger.error(`[${process.env.iz_serviceTag}:<%- flowTag %>LogicalLib] error:`, err);

package/src/emit/custom/customFlowPaths.js

@@ -0,0 +1,149 @@
+import {
+  flowDsqSteps,
+  flowExtTopicSteps,
+  generatedDsqFlows,
+  generatedOwnTopicFlows,
+  supportedCustomFlows,
+  upperFirst,
+  flowHasRbac
+} from './customFlows.js';
+
+export const YAML_PATH = 'app/sls_yaml/generatedCode/source/flow-schema.yml';
+
+export function isS3Only(flow) {
+  return flow.event.length === 1 && flow.event[0] === 's3';
+}
+
+export function needsProcessMain(flow) {
+  const isOwnTopicTransport =
+    flow.event.includes('ownTopic') ||
+    (flow.event.includes('generateCode') &&
+      flow.generatedCodeConfig?.invocationType === 'ownTopic');
+  return (
+    !isS3Only(flow) &&
+    !isOwnTopicTransport &&
+    flow.event.some((event) => event !== 'ownTopic' && event !== 's3')
+  );
+}
+
+export function ownTopicRootPaths(flow, objects = []) {
+  const tag = upperFirst(flow.flowTag);
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  const paths = [
+    `${source}/${tag}_Main.js`,
+    `${source}/${tag}_HdrSqs.js`,
+    `${source}/${tag}_WbsMain.js`,
+    `${source}/${tag}_HdrWbs.js`
+  ];
+  if (flowHasRbac(flow, objects)) {
+    paths.push(
+      `${source}/${tag}RbacCallback_Main.js`,
+      `${source}/${tag}RbacCallback_HdrSqs.js`
+    );
+  }
+  return paths;
+}
+
+export function flowPaths(flow, objects = []) {
+  const tag = upperFirst(flow.flowTag);
+  const process = tag;
+  const source = `app/src/generatedCode/FlowSchemas/${tag}/source`;
+  const paths = [];
+  if (needsProcessMain(flow)) {
+    paths.push(`${source}/${process}_Main.js`);
+  }
+  if (flowHasRbac(flow, objects)) {
+    paths.push(
+      `${source}/${tag}RbacCallback_Main.js`,
+      `${source}/${tag}RbacCallback_HdrSqs.js`
+    );
+  }
+  if (flow.event.includes('extTopic') && !flow.event.includes('ownTopic')) {
+    paths.push(`${source}/${process}_HdrSqs.js`);
+  }
+  if (flow.event.includes('dsq')) {
+    paths.push(`${source}/${process}_HdrDsq.js`);
+  }
+  if (
+    flow.event.includes('lambdaSyncInv') ||
+    flow.event.includes('eventBridge') ||
+    (flow.event.includes('generateCode') &&
+      flow.generatedCodeConfig?.invocationType === 'lambdaSyncInv')
+  ) {
+    paths.push(`${source}/${process}_HdrInv.js`);
+  }
+  if (flow.event.includes('lambdaSyncApi')) {
+    paths.push(`${source}/${process}_HdrApi.js`);
+  }
+  if (
+    flow.event.includes('ownTopic') ||
+    (flow.event.includes('generateCode') &&
+      flow.generatedCodeConfig?.invocationType === 'ownTopic')
+  ) {
+    paths.push(...ownTopicRootPaths(flow, objects));
+  }
+  if (flow.event.includes('s3')) {
+    const s3Actions = [
+      'ConfirmAfterUpload',
+      'CreateObject',
+      'CreatePreSignUrl',
+      'ProcessAfterUpload',
+      'ReservedLimit'
+    ];
+    for (const action of s3Actions) {
+      let handler = 'HdrSqs';
+      if (action === 'CreateObject') {
+        handler = 'HdrWbs';
+      } else if (action === 'ProcessAfterUpload') {
+        handler = 'HdrS3';
+      }
+      paths.push(
+        `${source}/${tag}${action}_Main.js`,
+        `${source}/${tag}${action}_${handler}.js`
+      );
+    }
+  }
+  return paths;
+}
+
+export function customFlowApplicationManagedPaths(
+  flows,
+  { objects = [] } = {}
+) {
+  const customFlowList = supportedCustomFlows(flows);
+  const generatedRoots = generatedOwnTopicFlows(flows);
+  const generatedDsqs = generatedDsqFlows(flows);
+  const extSteps = flowExtTopicSteps(flows);
+  const dsqSteps = flowDsqSteps(flows);
+
+  return [
+    ...customFlowList.flatMap((flow) => flowPaths(flow, objects)),
+    ...generatedRoots.flatMap((flow) => ownTopicRootPaths(flow, objects)),
+    ...extSteps.flatMap(({ flowTag, stepName }) => {
+      const source = `app/src/generatedCode/FlowSchemas/${flowTag}/source`;
+      return [
+        `${source}/${flowTag}${stepName}_Main.js`,
+        `${source}/${flowTag}${stepName}_HdrSqs.js`
+      ];
+    }),
+    ...dsqSteps.flatMap(({ flowTag, stepName, step }) => {
+      const source = `app/src/generatedCode/FlowSchemas/${flowTag}/source`;
+      let stepEvents = [];
+      if (Array.isArray(step.event)) {
+        stepEvents = step.event;
+      }
+      const files = [`${source}/${flowTag}${stepName}_HdrDsq.js`];
+      if (!stepEvents.includes('extTopic')) {
+        files.unshift(`${source}/${flowTag}${stepName}_Main.js`);
+      }
+      return files;
+    }),
+    ...(customFlowList.length > 0 ||
+    generatedRoots.length > 0 ||
+    generatedDsqs.length > 0 ||
+    extSteps.length > 0 ||
+    dsqSteps.length > 0
+      ? [YAML_PATH]
+      : [])
+  ];
+}