@izara_project/izara-core-library-asynchronous-flow 1.0.27 → 1.0.29

package/package.json

@@ -3,7 +3,7 @@
   "author": "Sven Mason <thebarbariansven@gmail.com>",
   "license": "AGPL-3.0-or-later",
   "homepage": "https://bitbucket.org/izara-core-libraries/izara-core-library-asynchronous-flow#readme",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "description": "Shared asynchronous flow logic",
   "type": "module",
   "main": "index.js",
@@ -31,5 +31,7 @@
     "@izara_project/izara-core-library-sqs": "^1.0.7"
   },
   "peerDependenciesMeta": {},
-  "dependencies": {}
+  "dependencies": {
+    "@izara_project/izara-shared-core": "^1.0.12"
+  }
 }

package/src/awaitingMultipleSteps.js

@@ -18,6 +18,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import { NoRetryError } from '@izara_project/izara-core-library-core';
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
 
+import { identifierUuid } from '@izara_project/izara-shared-core';
+
 //====================================== AwaitingMultipleSteps
 // AwaitingMultipleSteps is when a flow is awaiting multiple external flows before it can continue
 // One awaitingStepId can have multiple pendingStepIds that are awaiting it
@@ -192,6 +194,73 @@ export async function createAwaitingMultipleSteps(
   await Promise.all(promiseArray);
 }
 
+/**
+ * Create new awaiting multiple steps for a pending step.
+ * @async
+ * @param {IzContext} _izContext
+ * @param {string} pendingStepId
+ * @param {number} countAwaitingMultipleSteps
+ * @param {Object.<string, any>} [additionalAttributes={}] - Shared attributes stored for every step in AwaitingMultipleStepByPending.
+ *   The same object is applied to all steps (caller cannot know the generated UUIDs beforehand).
+ * @returns {Promise<string[]>} The list of awaiting step IDs created.
+ */
+export async function createNewAwaitingMultipleSteps(
+  _izContext,
+  pendingStepId,
+  countAwaitingMultipleSteps,
+  additionalAttributes = {}
+) {
+  _izContext.logger.debug('[Lib:AsyncFlow:createNewAwaitingMultipleSteps] Input: ', {
+    pendingStepId,
+    countAwaitingMultipleSteps,
+    additionalAttributes
+  });
+
+  const awaitingStepIds = Array.from({ length: countAwaitingMultipleSteps }, () => identifierUuid());
+
+  const promiseArray = [];
+
+  for (const awaitingStepId of awaitingStepIds) {
+    const attributesWhenCreate = {
+      awaitingStepId: awaitingStepId,
+      pendingStepId: pendingStepId,
+      complete: false,
+      errorsFound: [],
+    };
+    promiseArray.push(
+      dynamodbSharedLib.putItem(
+        _izContext,
+        dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
+        attributesWhenCreate
+      )
+    );
+
+    const attributesForPending = {
+      ...attributesWhenCreate,
+      additionalAttributes: additionalAttributes
+    };
+
+    promiseArray.push(
+      dynamodbSharedLib.putItem(
+        _izContext,
+        dynamodbSharedLib.tableName(
+          _izContext,
+          'AwaitingMultipleStepByPending'
+        ),
+        attributesForPending
+      )
+    );
+
+    _izContext.logger.debug('putItem:AwaitingMultipleStepByPending', {
+      awaitingStepId: attributesWhenCreate.awaitingStepId
+    });
+  }
+
+  await Promise.all(promiseArray);
+
+  return awaitingStepIds;
+}
+
 /**
  * Find all pendingStepIds that are waiting on a given awaitingStepId (multiple).
  * @async
@@ -348,56 +417,46 @@ export async function checkAllAwaitingStepsFinished(
   errorsFound = [],
   additionalAttributes = {}
 ) {
-
   await checkAllAwaitingStepsFinishedShared(
     _izContext,
     pendingStepId,
-    currentAwaitingStepId = null,
-    errorsFound = [],
-    additionalAttributes = {}
+    currentAwaitingStepId,
+    errorsFound,
+    additionalAttributes
   );
 
-  let listPendingStepIds = await dynamodbSharedLib.query(
+  const items = await dynamodbSharedLib.query(
     _izContext,
     dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
-    {
-      pendingStepId: pendingStepId
-    },
-    {
-      limit: 50 // arbitrary limit so not pull too many results, need >2 because some others might be marked as "complete" = true
-    }
+    { pendingStepId },
+    { limit: 50 }
   );
-  for (let idx = 0; idx < listPendingStepIds.Items.length; idx++) {
-    // if have error found return errorsFound
-    // wrap function
-
-    if (
-      currentAwaitingStepId &&
-      listPendingStepIds.Items[idx].awaitingStepId == currentAwaitingStepId
-    ) {
-      continue;
-    }
-    // if any record found not set to complete then there are steps not yet finished
-    if (!listPendingStepIds.Items[idx].complete) {
-      return false;
-    }
+
+  for (const item of items.Items) {
+    if (item.awaitingStepId === currentAwaitingStepId) continue;
+    if (!item.complete) return false;
   }
 
-  return true; // all passed
+  return true;
 }
 
 
 /**
  * Checks if all awaiting steps for a pending step are complete after marking the current one as complete.
- * If all steps are finished, it returns `true` and an object containing the `additionalAttributes` from each of the completed steps, indexed by their `awaitingStepId`.
- * If any other step is not yet complete, it returns `[false, null]`.
+ * If all steps are finished, returns an object with `isComplete: true` and the collected data.
+ * If any other step is not yet complete, returns `isComplete: false` with null data.
  * @async
  * @param {IzContext} _izContext
  * @param {string} pendingStepId
  * @param {string|null} [currentAwaitingStepId=null] - The step that has just finished.
  * @param {any[]} [errorsFound=[]]
  * @param {Attrs} [additionalAttributes={}]
- * @returns {Promise<[boolean, Record<string, any>|null]>} A tuple indicating completion status and the collected attributes, or null if not all steps are complete.
+ * @returns {Promise<{
+ *   isComplete: boolean,
+ *   collectedAttributes: Record<string, any>|null,
+ *   collectedErrors: any[],
+ *   sharedAdditionalAttributes: any|null
+ * }>}
  */
 export async function checkAllAwaitingStepsFinishedWithReturnParams(
   _izContext,
@@ -406,44 +465,66 @@ export async function checkAllAwaitingStepsFinishedWithReturnParams(
   errorsFound = [],
   additionalAttributes = {}
 ) {
+  _izContext.logger.debug('Lib:checkAllAwaitingStepsFinishedWithReturnParams', {
+    pendingStepId,
+    currentAwaitingStepId,
+    errorsFound,
+    additionalAttributes
+  });
 
   await checkAllAwaitingStepsFinishedShared(
     _izContext,
     pendingStepId,
-    currentAwaitingStepId = null,
-    errorsFound = [],
-    additionalAttributes = {}
+    currentAwaitingStepId,
+    errorsFound,
+    additionalAttributes
   );
 
   const awaitingStepItems = await dynamodbSharedLib.query(
     _izContext,
     dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
     { pendingStepId },
-    {
-      limit: 50
-    }
+    { limit: 50 }
   );
 
   _izContext.logger.debug('awaitingStepItems:::', awaitingStepItems);
 
-  const collectedAttributes = {};
-  const collectedErrors = [];
-
+  // Pass 1: check completeness of all other steps before collecting any data
   for (const item of awaitingStepItems.Items) {
     if (item.awaitingStepId !== currentAwaitingStepId && !item.complete) {
-      return [false, null, []];
+      return {
+        isComplete: false,
+        collectedAttributes: null,
+        collectedErrors: [],
+        sharedAdditionalAttributes: null
+      };
     }
+  }
 
+  // Pass 2: all steps are complete — collect errors and attributes
+  const collectedAttributes = {};
+  const collectedErrors = [];
+  let sharedAdditionalAttributes = null;
+
+  for (const item of awaitingStepItems.Items) {
     if (item.errorsFound?.length > 0) {
       collectedErrors.push(...item.errorsFound);
     }
 
     if (item.additionalAttributes) {
       collectedAttributes[item.awaitingStepId] = item.additionalAttributes;
+      if (sharedAdditionalAttributes === null) {
+        sharedAdditionalAttributes = item.additionalAttributes;
+      }
     }
   }
 
-  return [true, collectedAttributes, collectedErrors];
+  return {
+    isComplete: true,
+    collectedAttributes,
+    collectedErrors,
+    sharedAdditionalAttributes
+  };
 }