@izara_project/izara-core-library-asynchronous-flow 1.0.35 → 1.0.37

package/src/awaitingMultipleSteps.js

@@ -1,5 +1,4 @@
-/*
-Copyright (C) 2021 Sven Mason <http://izara.io>
+/* Copyright (C) 2021 Sven Mason <http://izara.io>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License as
@@ -8,11 +7,11 @@ License, or (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU Affero General Public License for more details.
 
 You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
+along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { NoRetryError } from '@izara_project/izara-core-library-core';
@@ -22,558 +21,251 @@ import snsSharedLib from '@izara_project/izara-core-library-sns';
 
 import { createParentFlowId } from './asyncFlowSharedLib.js';
 
-//====================================== 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
-// One pendingStepId can have multiple awaitingStepIds it is awaiting
-// logic can prepend any prefix to awaitingStepId if want to be share one table and differentiate different external step ids
-
-/**
- * Create multiple awaiting records with optional per-record additional attributes.
- * Writes to both "AwaitingMultipleSteps" and "AwaitingMultipleStepByPending".
- * @async
- * @param {IzContext} _izContext
- * @param {AwaitingMultiInputRecord[]} records
- * @param {string} pendingStepId
- * @returns {Promise<void>}
- */
-export async function createAwaitingMultipleStepsWithAdditionalAttributes(
-  _izContext,
-  records, // array of object including properties: awaitingStepId / (optional) additionalAttributes
-  pendingStepId
-) {
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:createAwaitingMultipleStepsWithAdditionalAttributes] Input: ',
-    {
-      records,
-      pendingStepId
-    }
-  );
-
-  const promiseArray = [];
-
-  for (const record of records) {
-    const attributesWhenCreate = {
-      awaitingStepId: record.awaitingStepId,
-      pendingStepId: pendingStepId,
-      timestamp: Date.now(),
-      ...record.additionalAttributes
-    };
-
-    promiseArray.push(
-      dynamodbSharedLib.putItem(
-        _izContext,
-        dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-        attributesWhenCreate
-      )
-    );
-    promiseArray.push(
-      dynamodbSharedLib.putItem(
-        _izContext,
-        dynamodbSharedLib.tableName(
-          _izContext,
-          'AwaitingMultipleStepByPending'
-        ),
-        {
-          pendingStepId: pendingStepId,
-          awaitingStepId: record.awaitingStepId,
-          timestamp: Date.now()
-        }
-      )
-    );
+function _assertPendingStepId(pendingStepId) {
+  if (!pendingStepId) {
+    throw new NoRetryError('pendingStepId required');
   }
-
-  await Promise.all(promiseArray);
 }
 
-/**
- * Batch initializes multiple pending steps in DynamoDB.
- * Records status in both the primary tracking table and the pending-relation table.
- * * @async
- * @param {Object} _izContext - The system context providing logger and shared utilities.
- * @param {Array<Object>} records - Array of step objects to be initialized.
- * @param {string} records[].awaitingStepId - The unique identifier for the specific step.
- * @param {Object} [records[].additionalAttributes] - Optional metadata to store with the step.
- * @param {string} pendingStepId - The parent ID linking all related steps together.
- * @returns {Promise<void>}
- */
-export async function initAwaitingStepsWithAttrs(
+async function _putAwaitingMultipleStepRecords(
   _izContext,
   records,
-  pendingStepId
-) {
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:initAwaitingStepsWithAttrs] Input: ',
-    {
-      records,
-      pendingStepId
-    }
-  );
-
-  const timestamp = Date.now();
-  const promiseArray = [];
-
-  for (const record of records) {
-    promiseArray.push(
-      dynamodbSharedLib.putItem(
-        _izContext,
-        dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-        {
-          awaitingStepId: record.awaitingStepId,
-          pendingStepId,
-          timestamp
-        }
-      )
-    );
-    promiseArray.push(
-      dynamodbSharedLib.putItem(
-        _izContext,
-        dynamodbSharedLib.tableName(
-          _izContext,
-          'AwaitingMultipleStepByPending'
-        ),
-        {
-          pendingStepId,
-          awaitingStepId: record.awaitingStepId,
-          timestamp,
-          ...record.additionalAttributes
-        }
-      )
-    );
-  }
-
-  await Promise.all(promiseArray);
-}
-
-/**
- * Create multiple awaiting records given an array of awaitingStepIds.
- * Writes to both "AwaitingMultipleSteps" and "AwaitingMultipleStepByPending".
- * @async
- * @param {IzContext} _izContext
- * @param {string[]} records - array of awaitingStepIds
- * @param {string} pendingStepId
- * @returns {Promise<void>}
- */
-export async function createAwaitingMultipleSteps(
-  _izContext,
-  records, // array of awaitingStepIds
-  pendingStepId
-) {
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:createAwaitingMultipleSteps] Input: ',
-    {
-      records: records,
-      pendingStepId: pendingStepId
-    }
-  );
-
-  const promiseArray = [];
-
-  for (const record of records) {
-    const attributesWhenCreate = {
-      awaitingStepId: record,
-      pendingStepId: pendingStepId,
-      timestamp: Date.now()
-    };
-    _izContext.logger.debug(
-      '[Lib:AsyncFlow:createAwaitingMultipleSteps] attributesWhenCreate: ',
-      attributesWhenCreate
-    );
-    promiseArray.push(
-      dynamodbSharedLib.putItem(
-        _izContext,
-        dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-        attributesWhenCreate
-      )
-    );
-
-    _izContext.logger.debug(
-      '[Lib:AsyncFlow:createAwaitingMultipleSteps] putItem:AwaitingMultipleStepByPending',
-      {
-        awaitingStepId: attributesWhenCreate.awaitingStepId
-      }
-    );
-
-    promiseArray.push(
-      dynamodbSharedLib.putItem(
-        _izContext,
-        dynamodbSharedLib.tableName(
-          _izContext,
-          'AwaitingMultipleStepByPending'
-        ),
-        attributesWhenCreate
-      )
-    );
-  }
-
-  await Promise.all(promiseArray);
-}
-
-/**
- * Create new awaiting multiple steps for a pending step.
- * @async
- * @param {IzContext} _izContext
- * @param {string} pendingStepId
- * @param {string[]} parendIds
- * @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 awaiting  step ID created.
- */
-export async function createNewAwaitingMultipleStep(
-  _izContext,
   pendingStepId,
-  prefix = '',
-  additionalAttributes = {}
+  sharedAttributes = {}
 ) {
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:createNewAwaitingMultipleStep] Input: ',
-    {
-      pendingStepId,
-      additionalAttributes
-    }
-  );
-
-  const parentFlowId = createParentFlowId(prefix);
-
-  const attributesWhenCreate = {
-    awaitingStepId: parentFlowId,
-    pendingStepId: pendingStepId,
-    complete: false,
-    errorsFound: []
-  };
-
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:createNewAwaitingMultipleStep] attributesWhenCreate: ',
-    attributesWhenCreate
-  );
-
-  await dynamodbSharedLib.putItem(
+  const tableSteps = dynamodbSharedLib.tableName(
     _izContext,
-    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-    attributesWhenCreate
+    'AwaitingMultipleSteps'
   );
-
-  const attributesForPending = {
-    ...attributesWhenCreate,
-    additionalAttributes: additionalAttributes
-  };
-
-  await dynamodbSharedLib.putItem(
+  const tablePending = dynamodbSharedLib.tableName(
     _izContext,
-    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
-    attributesForPending
+    'AwaitingMultipleStepByPending'
   );
 
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:createNewAwaitingMultipleStep] Returning: ',
-    parentFlowId
+  await Promise.all(
+    records.flatMap(({ awaitingStepId, additionalAttributes }) => {
+      const keys = { awaitingStepId, pendingStepId };
+
+      return [
+        dynamodbSharedLib.putItem(_izContext, tableSteps, keys),
+        dynamodbSharedLib.putItem(_izContext, tablePending, {
+          ...keys,
+          ...sharedAttributes,
+          ...(additionalAttributes && { additionalAttributes })
+        })
+      ];
+    })
   );
-
-  return parentFlowId;
 }
 
-/**
- * Find all pendingStepIds that are waiting on a given awaitingStepId (multiple).
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @returns {Promise<string[]>}
- */
-export async function findPendingStepIdsAwaitingMultipleSteps(
-  _izContext,
-  awaitingStepId
-) {
-  _izContext.logger.debug(
-    '[Lib:findPendingStepIdsAwaitingMultipleSteps] Input parameters',
-    {
-      awaitingStepId: awaitingStepId
-    }
-  );
-
+async function _queryPendingStepsByAwaitingStepId(_izContext, awaitingStepId) {
   if (!awaitingStepId) {
-    _izContext.logger.error(
-      '[Lib:findPendingStepIdsAwaitingMultipleSteps] awaitingStepId is required'
-    );
-    throw new NoRetryError('awaitingStepId is required');
+    throw new NoRetryError('awaitingStepId required');
   }
 
-  const pendingStepIds = [];
-
-  const listPendingStepIds = await dynamodbSharedLib.query(
+  const { Items } = await dynamodbSharedLib.query(
     _izContext,
     dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-    {
-      awaitingStepId: awaitingStepId
-    }
+    { awaitingStepId }
   );
 
-  for (const item of listPendingStepIds.Items) {
-    pendingStepIds.push(item.pendingStepId);
-  }
+  return Items;
+}
 
-  _izContext.logger.debug(
-    '[Lib:findPendingStepIdsAwaitingMultipleSteps] Pending step IDs',
-    pendingStepIds
+async function _queryAwaitingStepsByPendingStepId(_izContext, pendingStepId) {
+  _assertPendingStepId(pendingStepId);
+
+  const { Items } = await dynamodbSharedLib.query(
+    _izContext,
+    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
+    { pendingStepId },
+    { limit: 50 }
   );
 
-  return pendingStepIds;
+  return Items;
 }
 
-/**
- * Return the raw items waiting on a given awaitingStepId (multiple).
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @returns {Promise<AwaitingMultipleStepsItem[]>}
- */
-export async function findPendingStepsAwaitingMultipleSteps(
+//======================================
+// AwaitingMultipleSteps
+//======================================
+// AwaitingMultipleSteps flow awaits multiple external flows before continuing.
+// One awaitingStepId can have multiple pendingStepIds awaiting it.
+// One pendingStepId can have multiple awaitingStepIds awaiting it.
+
+export async function createAwaitingMultipleSteps(
   _izContext,
-  awaitingStepId
+  pendingStepId,
+  options = {}
 ) {
-  _izContext.logger.debug(
-    '[Lib:findPendingStepsAwaitingMultipleSteps] Input parameters',
-    {
-      awaitingStepId: awaitingStepId
-    }
-  );
+  const {
+    records = [],
+    prefix = '',
+    additionalAttributes = {},
+    publishConfig = null
+  } = options;
+
+  _izContext.logger.debug('[Lib:AsyncFlow:createAwaitingMultipleSteps] Input', {
+    pendingStepId,
+    options
+  });
 
-  if (!awaitingStepId) {
-    _izContext.logger.error(
-      '[Lib:findPendingStepsAwaitingMultipleSteps] awaitingStepId is required'
-    );
-    throw new NoRetryError('awaitingStepId is required');
-  }
+  let finalRecords = records;
 
-  const listPendingSteps = await dynamodbSharedLib.query(
-    _izContext,
-    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-    {
-      awaitingStepId: awaitingStepId
-    }
-  );
+  if (finalRecords.length === 0 && !publishConfig) {
+    finalRecords = [
+      {
+        awaitingStepId: createParentFlowId(prefix),
+        additionalAttributes
+      }
+    ];
+  }
 
-  _izContext.logger.debug(
-    '[Lib:findPendingStepsAwaitingMultipleSteps] Record of awaitingStepId',
-    listPendingSteps
-  );
+  if (publishConfig) {
+    const { messages, flowType = {} } = publishConfig;
+    const { flowTag, serviceTag } = flowType;
 
-  return listPendingSteps.Items;
-}
+    if (!Array.isArray(messages)) {
+      throw new NoRetryError('messages must be an array');
+    }
 
-/**
- * Fetch exactly one pending step for a given awaitingStepId (throws if not 1).
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @returns {Promise<AwaitingMultipleStepsItem>}
- * @throws {NoRetryError} if there is not exactly one item
- */
-export async function findPendingStepAwaitingMultipleSteps(
-  _izContext,
-  awaitingStepId
-) {
-  _izContext.logger.debug(
-    '[Lib:findPendingStepAwaitingMultipleSteps] Input parameters',
-    {
-      awaitingStepId: awaitingStepId
+    if (!flowTag || !serviceTag) {
+      throw new NoRetryError('flowType must both flowTag serviceTag');
     }
-  );
 
-  if (!awaitingStepId) {
-    _izContext.logger.error(
-      '[Lib:findPendingStepAwaitingMultipleSteps] awaitingStepId is required'
-    );
-    throw new NoRetryError('awaitingStepId is required');
+    finalRecords = messages.map(message => {
+      const parentFlowId = createParentFlowId(prefix);
+
+      return {
+        awaitingStepId: parentFlowId,
+        additionalAttributes,
+        message: {
+          ...message,
+          parentFlowId
+        }
+      };
+    });
   }
 
-  const listPendingSteps = await dynamodbSharedLib.query(
+  await _putAwaitingMultipleStepRecords(
     _izContext,
-    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
+    finalRecords.map(({ awaitingStepId, additionalAttributes: itemAttrs }) => ({
+      awaitingStepId,
+      additionalAttributes: itemAttrs
+    })),
+    pendingStepId,
     {
-      awaitingStepId: awaitingStepId
+      complete: false,
+      errorsFound: []
     }
   );
 
-  _izContext.logger.debug(
-    '[Lib:findPendingStepAwaitingMultipleSteps] Record of awaitingStepId',
-    listPendingSteps
-  );
+  if (publishConfig) {
+    const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      publishConfig.flowType.flowTag,
+      publishConfig.flowType.serviceTag
+    );
 
-  if (listPendingSteps.Items.length !== 1) {
-    _izContext.logger.error(
-      '[Lib:findPendingStepAwaitingMultipleSteps] listPendingSteps not equals 1'
+    await Promise.all(
+      finalRecords.map(({ message }) =>
+        sns.publishAsync(_izContext, {
+          TopicArn: `${topicArn}_In`,
+          Message: JSON.stringify(message),
+          MessageAttributes: {}
+        })
+      )
     );
-    throw new NoRetryError('listPendingSteps not equals 1');
   }
 
-  return listPendingSteps.Items[0];
+  return finalRecords[0]?.awaitingStepId;
 }
 
-// Use case:
-// Use only after checkAllAwaitingStepsFinished
-// Do NOT delete records in both tables (AwaitingMultipleSteps, AwaitingMultipleStepByPending) if AwaitingMultipleSteps is not yet finished
-// Delete records from both tables only when checkAllAwaitingStepsFinished = true
-// Example usage: flow validateCart lambda ProcessCartOrderFromTraversal
-/**
- * Given a pendingStepId, return all awaiting steps (by the ByPending table).
- * Use only after confirming all awaiting steps are finished, and clean up both tables accordingly.
- * @async
- * @param {IzContext} _izContext
- * @param {string} pendingStepId
- * @returns {Promise<AwaitingMultipleStepByPendingItem[]>}
- */
-export async function findAwaitingMultipleStepByPending(
+export async function createAwaitingMultipleStepsWithAdditionalAttributes(
   _izContext,
+  records,
   pendingStepId
 ) {
-  _izContext.logger.debug(
-    '[Lib:findAwaitingMultipleStepByPending] Input parameters',
-    {
-      pendingStepId: pendingStepId
-    }
-  );
-
-  if (!pendingStepId) {
-    _izContext.logger.error(
-      '[Lib:findAwaitingMultipleStepByPending] pendingStepId is required'
-    );
-    throw new NoRetryError('pendingStepId is required');
-  }
-
-  const listAwaitingSteps = await dynamodbSharedLib.query(
-    _izContext,
-    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
-    {
-      pendingStepId: pendingStepId
-    }
-  );
-  _izContext.logger.debug(
-    '[Lib:findAwaitingMultipleStepByPending] Record of AwaitingMultipleStepByPending',
-    listAwaitingSteps
-  );
-
-  return listAwaitingSteps.Items;
+  return createAwaitingMultipleSteps(_izContext, pendingStepId, { records });
 }
 
-/**
- * Updates the completion status of a specific awaiting step within a multiple-step pending process.
- * Marks the given awaiting step as complete and stores any encountered errors or additional attributes.
- *
- * @param {Object} _izContext - The execution context object containing logger and other utilities.
- * @param {string} pendingStepId - The unique identifier of the parent pending step.
- * @param {string|null} [currentAwaitingStepId=null] - The unique identifier of the specific awaiting step being processed. If null, no update is performed.
- * @param {Array<Object|string>} [errorsFound=[]] - An array of errors encountered during the step's execution.
- * @param {Object} [additionalAttributes={}] - Any extra data to save along with the completion status.
- * @returns {Promise<void>} Resolves when the update operation is complete.
- */
-export async function checkAllAwaitingStepsFinishedShared(
+export async function createAwaitingMultipleStep(
   _izContext,
   pendingStepId,
-  currentAwaitingStepId = null,
-  errorsFound = [],
+  prefix = '',
   additionalAttributes = {}
 ) {
-  _izContext.logger.debug(
-    '[Lib:checkAllAwaitingStepsFinishedShared] Input parameters',
-    {
-      pendingStepId: pendingStepId,
-      currentAwaitingStepId: currentAwaitingStepId,
-      errorsFound: errorsFound
-    }
-  );
-
-  if (currentAwaitingStepId) {
-    await dynamodbSharedLib.updateItem(
-      _izContext,
-      dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
-      {
-        pendingStepId: pendingStepId,
-        awaitingStepId: currentAwaitingStepId
-      },
-      {
-        complete: true,
-        errorsFound: errorsFound,
-        additionalAttributes: additionalAttributes
-      }
-    );
-  }
+  return createAwaitingMultipleSteps(_izContext, pendingStepId, {
+    prefix,
+    additionalAttributes
+  });
 }
 
-/**
- * Same as checkAllAwaitingStepsFinished but writes errors/additionalAttributes to the *_ByPending row.
- * @async
- * @param {IzContext} _izContext
- * @param {string} pendingStepId
- * @param {string|null} [currentAwaitingStepId=null]
- * @param {any[]} [errorsFound=[]]
- * @param {Attrs} [additionalAttributes={}]
- * @returns {Promise<boolean>}
- */
-export async function checkAllAwaitingStepsFinished(
+export async function createAwaitingMultipleStepsWithAdditionalAttributesAndPublish(
   _izContext,
-  pendingStepId,
-  currentAwaitingStepId = null,
-  errorsFound = [],
-  additionalAttributes = {}
+  messages,
+  prefix = '',
+  flowType = {},
+  additionalAttributes = {},
+  pendingStepId
 ) {
-  _izContext.logger.debug(
-    '[Lib:checkAllAwaitingStepsFinished] Input parameters',
-    {
-      pendingStepId: pendingStepId,
-      currentAwaitingStepId: currentAwaitingStepId,
-      errorsFound: errorsFound
+  return createAwaitingMultipleSteps(_izContext, pendingStepId, {
+    prefix,
+    additionalAttributes,
+    publishConfig: {
+      messages,
+      flowType
     }
-  );
+  });
+}
 
-  await checkAllAwaitingStepsFinishedShared(
-    _izContext,
-    pendingStepId,
-    currentAwaitingStepId,
-    errorsFound,
-    additionalAttributes
-  );
+export async function findPendingStepAwaitingMultipleSteps(
+  _izContext,
+  awaitingStepId
+) {
+  _izContext.logger.debug('[Lib:findPendingStepAwaitingMultipleSteps] Input', {
+    awaitingStepId
+  });
 
-  const items = await dynamodbSharedLib.query(
+  const items = await _queryPendingStepsByAwaitingStepId(
     _izContext,
-    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
-    { pendingStepId },
-    { limit: 50 }
+    awaitingStepId
   );
 
-  for (const item of items.Items) {
-    if (item.awaitingStepId === currentAwaitingStepId) continue;
-    if (!item.complete) return false;
-  }
+  return items[0];
+}
 
-  _izContext.logger.debug(
-    '[Lib:checkAllAwaitingStepsFinished] All steps are complete'
+export async function findPendingStepsAwaitingMultipleSteps(
+  _izContext,
+  awaitingStepId
+) {
+  return _queryPendingStepsByAwaitingStepId(_izContext, awaitingStepId);
+}
+
+export async function findPendingStepIdAwaitingMultipleSteps(
+  _izContext,
+  awaitingStepId
+) {
+  const items = await _queryPendingStepsByAwaitingStepId(
+    _izContext,
+    awaitingStepId
   );
-  return true;
+  return items[0]?.pendingStepId;
+}
+
+export async function findAwaitingMultipleStepByPending(
+  _izContext,
+  pendingStepId
+) {
+  return _queryAwaitingStepsByPendingStepId(_izContext, pendingStepId);
 }
 
-/**
- * Checks if all awaiting steps for a pending step are complete after marking the current one as complete.
- * 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<{
- *   isComplete: boolean,
- *   collectedAttributes: Record<string, any>|null,
- *   collectedErrors: any[],
- *   sharedAdditionalAttributes: any|null
- * }>}
- */
 export async function checkAllAwaitingStepsFinishedWithReturnParams(
   _izContext,
   pendingStepId,
   currentAwaitingStepId = null,
   errorsFound = [],
-  additionalAttributes = {}
+  returnValues = {},
+  settings = { checkIsAllError: true }
 ) {
   _izContext.logger.debug(
     '[Lib:checkAllAwaitingStepsFinishedWithReturnParams] Input parameters',
@@ -581,159 +273,117 @@ export async function checkAllAwaitingStepsFinishedWithReturnParams(
       pendingStepId,
       currentAwaitingStepId,
       errorsFound,
-      additionalAttributes
+      returnValues
     }
   );
 
-  if (!pendingStepId || !currentAwaitingStepId) {
-    throw NoRetryError(
-      '[Lib:checkAllAwaitingStepsFinishedWithReturnParams] pendingStepId or currentAwaitingStepId is required'
+  _assertPendingStepId(pendingStepId);
+
+  if (currentAwaitingStepId) {
+    await dynamodbSharedLib.updateItem(
+      _izContext,
+      dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
+      {
+        pendingStepId,
+        awaitingStepId: currentAwaitingStepId
+      },
+      {
+        complete: true,
+        errorsFound,
+        returnValues
+      }
     );
   }
 
-  await checkAllAwaitingStepsFinishedShared(
+  const awaitingStepItems = await _queryAwaitingStepsByPendingStepId(
     _izContext,
-    pendingStepId,
-    currentAwaitingStepId,
-    errorsFound,
-    additionalAttributes
-  );
-
-  const awaitingStepItems = await dynamodbSharedLib.query(
-    _izContext,
-    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
-    { pendingStepId },
-    { limit: 50 }
+    pendingStepId
   );
 
   _izContext.logger.debug(
-    '[Lib:checkAllAwaitingStepsFinishedWithReturnParams] awaitingStepItems:::',
+    '[Lib:checkAllAwaitingStepsFinishedWithReturnParams] awaitingStepItems',
     awaitingStepItems
   );
 
-  // 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 {
-        isComplete: false,
-        collectedAttributes: null,
-        collectedErrors: [],
-        sharedAdditionalAttributes: null
-      };
-    }
-  }
-
-  _izContext.logger.debug(
-    '[Lib:checkAllAwaitingStepsFinishedWithReturnParams] Pass 1: all steps are complete'
+  const hasIncomplete = awaitingStepItems.some(
+    item => item.awaitingStepId !== currentAwaitingStepId && !item.complete
   );
 
-  // Pass 2: all steps are complete — collect errors and attributes
+  if (hasIncomplete) {
+    return {
+      isComplete: false,
+      collectedAttributes: null,
+      collectedErrors: [],
+      returnValues: null
+    };
+  }
+
   const collectedAttributes = {};
-  const collectedErrors = [];
-  let sharedAdditionalAttributes = null;
+  let sharedReturnValues = null;
 
-  for (const item of awaitingStepItems.Items) {
-    if (item.errorsFound?.length > 0) {
-      collectedErrors.push(...item.errorsFound);
+  for (const item of awaitingStepItems) {
+    if (!item.returnValues) {
+      continue;
     }
 
-    if (item.additionalAttributes) {
-      collectedAttributes[item.awaitingStepId] = item.additionalAttributes;
-      if (sharedAdditionalAttributes === null) {
-        sharedAdditionalAttributes = item.additionalAttributes;
-      }
-    }
+    collectedAttributes[item.awaitingStepId] = item.returnValues;
+    sharedReturnValues ??= item.returnValues;
   }
 
-  _izContext.logger.debug(
-    '[Lib:checkAllAwaitingStepsFinishedWithReturnParams] Pass 2: all steps are complete — collect errors and attributes'
+  const collectedErrors = awaitingStepItems.flatMap(item =>
+    item.errorsFound?.length > 0
+      ? [`Error found in step ${item.awaitingStepId}`, ...item.errorsFound]
+      : []
   );
 
   return {
     isComplete: true,
     collectedAttributes,
     collectedErrors,
-    sharedAdditionalAttributes
+    returnValues: sharedReturnValues,
+    additionalAttributes: awaitingStepItems[0]?.additionalAttributes || null,
+    ...(settings.checkIsAllError && {
+      isAllError: awaitingStepItems.every(item => item.errorsFound?.length > 0)
+    })
   };
 }
 
-/**
- * Remove all awaiting records for a given pendingStepId from both tables.
- * @async
- * @param {IzContext} _izContext
- * @param {string} pendingStepId
- * @returns {Promise<boolean>} true if delete flow processed
- */
 export async function clearAllAwaitingSteps(_izContext, pendingStepId) {
   _izContext.logger.debug('[Lib:clearAllAwaitingSteps] Input parameters', {
-    pendingStepId: pendingStepId
+    pendingStepId
   });
 
-  if (!pendingStepId) {
-    throw NoRetryError('[Lib:clearAllAwaitingSteps] pendingStepId is required');
-  }
-
-  // ----- query items from GSI table
-  const listPendingStepIds = await dynamodbSharedLib.query(
+  const listPendingStepIds = await _queryAwaitingStepsByPendingStepId(
     _izContext,
-    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
-    {
-      pendingStepId: pendingStepId
-    }
+    pendingStepId
   );
-  _izContext.logger.debug(
-    '[Lib:clearAllAwaitingSteps] listPendingStepIds',
-    listPendingStepIds
+  const tableSteps = dynamodbSharedLib.tableName(
+    _izContext,
+    'AwaitingMultipleSteps'
+  );
+  const tablePending = dynamodbSharedLib.tableName(
+    _izContext,
+    'AwaitingMultipleStepByPending'
   );
 
-  const promiseArray = [];
-
-  for (let idx = 0; idx < listPendingStepIds.Items.length; idx++) {
-    _izContext.logger.debug(`delete item in dynamodb AwaitingMultipleSteps`);
-    promiseArray.push(
-      dynamodbSharedLib.deleteItem(
-        _izContext,
-        dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-        {
-          awaitingStepId: listPendingStepIds.Items[idx].awaitingStepId,
-          pendingStepId: listPendingStepIds.Items[idx].pendingStepId
-        }
-      )
-    );
-
-    _izContext.logger.debug(
-      '[Lib:clearAllAwaitingSteps] delete item in dynamodb AwaitingMultipleStepByPending'
-    );
-    promiseArray.push(
-      dynamodbSharedLib.deleteItem(
-        _izContext,
-        dynamodbSharedLib.tableName(
-          _izContext,
-          'AwaitingMultipleStepByPending'
-        ),
-        {
-          pendingStepId: listPendingStepIds.Items[idx].pendingStepId,
-          awaitingStepId: listPendingStepIds.Items[idx].awaitingStepId
-        }
-      )
-    );
-  }
-
-  await Promise.all(promiseArray);
+  await Promise.all(
+    listPendingStepIds.flatMap(
+      ({ awaitingStepId, pendingStepId: itemPendingStepId }) => [
+        dynamodbSharedLib.deleteItem(_izContext, tableSteps, {
+          awaitingStepId,
+          pendingStepId: itemPendingStepId
+        }),
+        dynamodbSharedLib.deleteItem(_izContext, tablePending, {
+          awaitingStepId,
+          pendingStepId: itemPendingStepId
+        })
+      ]
+    )
+  );
 
   return true;
 }
 
-/**
- * Remove items for AwaitingMultipleSteps and (conditionally) AwaitingMultipleStepByPending.
- * If errorsFound is empty, delete from ByPending table as well.
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @param {string} pendingStepId
- * @param {any[]} [errorsFound=[]]
- * @returns {Promise<void>}
- */
 export async function removeAwaitingMultipleStep(
   _izContext,
   awaitingStepId,
@@ -741,148 +391,38 @@ export async function removeAwaitingMultipleStep(
   errorsFound = []
 ) {
   _izContext.logger.debug('[Lib:removeAwaitingMultipleStep] Input parameters', {
-    awaitingStepId: awaitingStepId,
-    pendingStepId: pendingStepId,
-    errorsFound: errorsFound
+    awaitingStepId,
+    pendingStepId,
+    errorsFound
   });
 
   if (!awaitingStepId || !pendingStepId) {
-    throw NoRetryError(
-      '[Lib:removeAwaitingMultipleStep] awaitingStepId or pendingStepId is required'
+    throw new NoRetryError(
+      '[Lib:removeAwaitingMultipleStep] awaitingStepId or pendingStepId required'
     );
   }
 
-  const promiseArray = [];
-
-  const keyValues = {
-    awaitingStepId: awaitingStepId,
-    pendingStepId: pendingStepId
-  };
-
-  const keyValuesForByPending = {
-    pendingStepId: pendingStepId,
-    awaitingStepId: awaitingStepId
-  };
-  _izContext.logger.debug('deleting ... ', {
-    keyValues,
-    keyValuesForByPending
-  });
-
-  _izContext.logger.debug(
-    '[Lib:removeAwaitingMultipleStep] delete item in dynamodb AwaitingMultipleSteps',
-    {
-      awaitingStepId: keyValues.awaitingStepId,
-      pendingStepId: keyValues.pendingStepId
-    }
-  );
-  promiseArray.push(
+  const keys = { awaitingStepId, pendingStepId };
+  const promises = [
     dynamodbSharedLib.deleteItem(
       _izContext,
       dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-      keyValues
+      keys
     )
-  );
+  ];
 
-  if (errorsFound.length == 0) {
-    _izContext.logger.debug(
-      `delete item in dynamodb AwaitingMultipleStepByPending ==> awaitingStepId:${keyValues.awaitingStepId}`
-    );
-    promiseArray.push(
+  if (errorsFound.length === 0) {
+    promises.push(
       dynamodbSharedLib.deleteItem(
         _izContext,
         dynamodbSharedLib.tableName(
           _izContext,
           'AwaitingMultipleStepByPending'
         ),
-        keyValuesForByPending
+        keys
       )
     );
   }
-  await Promise.all(promiseArray);
-}
-
-/**
- * Creates multiple awaiting steps with additional attributes and publishes corresponding messages to an SNS topic.
- * Each message is augmented with a new `parentFlowId` representing its awaiting step before being published.
- *
- * @param {Object} _izContext - The execution context object containing logger and other utilities.
- * @param {Array<Object>} messages - An array of messages to be augmented and published.
- * @param {string} [prefix=''] - An optional prefix used when generating new awaiting step IDs.
- * @param {Object} [flowType={}] - Defines the target SNS topic. Must contain `flowTag` and `serviceTag`.
- * @param {string} flowType.flowTag - The flow tag identifier.
- * @param {string} flowType.serviceTag - The service tag identifier.
- * @param {Object} [additionalAttributes={}] - Additional attributes to save with each new awaiting step.
- * @param {string} pendingStepId - The unique identifier of the parent pending step that waits for these new steps.
- * @returns {Promise<void>} Resolves when all awaiting steps are created and messages are published.
- * @throws {Error} Throws a NoRetryError if `messages` is not an array, or if `flowType` is missing `flowTag` or `serviceTag`.
- */
-export async function createAwaitingMultipleStepsWithAdditionalAttributesAndPublish(
-  _izContext,
-  messages,
-  prefix = '',
-  flowType = {},
-  additionalAttributes = {},
-  pendingStepId
-) {
-  _izContext.logger.debug(
-    '[Lib:asyncFlow:createAwaitingMultipleStepsWithAdditionalAttributesAndPublish] Input parameters',
-    {
-      messages,
-      prefix,
-      flowType,
-      additionalAttributes,
-      pendingStepId
-    }
-  );
-
-  if (!Array.isArray(messages)) {
-    throw NoRetryError('messages must be an array');
-  }
 
-  const flowTag = flowType.flowTag;
-  const serviceTag = flowType.serviceTag;
-
-  if (flowTag === undefined || serviceTag === undefined) {
-    throw NoRetryError('flowType must have both flowTag and serviceTag');
-  }
-
-  const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
-    _izContext,
-    flowType.flowTag,
-    flowType.serviceTag
-  );
-
-  _izContext.logger.debug(
-    '[Lib:asyncFlow:createAwaitingMultipleStepsWithAdditionalAttributesAndPublish] Topic Arn',
-    topicArn
-  );
-
-  const messagesWithParentId = await Promise.all(
-    messages.map(async message => {
-      const parentFlowId = await createNewAwaitingMultipleStep(
-        _izContext,
-        pendingStepId,
-        prefix,
-        additionalAttributes
-      );
-      return {
-        ...message,
-        parentFlowId
-      };
-    })
-  );
-
-  await Promise.all(
-    messagesWithParentId.map(message =>
-      sns.publishAsync(_izContext, {
-        TopicArn: `${topicArn}_In`,
-        Message: JSON.stringify(message),
-        MessageAttributes: {}
-      })
-    )
-  );
-
-  _izContext.logger.debug(
-    '[Lib:asyncFlow:createAwaitingMultipleStepsWithAdditionalAttributesAndPublish] Exit point'
-  );
+  await Promise.all(promises);
 }