@izara_project/izara-core-library-asynchronous-flow 1.0.36 → 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,332 +21,251 @@ import snsSharedLib from '@izara_project/izara-core-library-sns';
 
 import { createParentFlowId } from './asyncFlowSharedLib.js';
 
-async function putAwaitingMultipleStepRecords(
+function _assertPendingStepId(pendingStepId) {
+  if (!pendingStepId) {
+    throw new NoRetryError('pendingStepId required');
+  }
+}
+
+async function _putAwaitingMultipleStepRecords(
   _izContext,
   records,
   pendingStepId,
   sharedAttributes = {}
 ) {
-  const multipleStepsTable = dynamodbSharedLib.tableName(
+  const tableSteps = dynamodbSharedLib.tableName(
     _izContext,
     'AwaitingMultipleSteps'
   );
-  const byPendingTable = dynamodbSharedLib.tableName(
+  const tablePending = dynamodbSharedLib.tableName(
     _izContext,
     'AwaitingMultipleStepByPending'
   );
 
   await Promise.all(
     records.flatMap(({ awaitingStepId, additionalAttributes }) => {
-      const baseAttrs = {
-        awaitingStepId,
-        pendingStepId,
-        ...sharedAttributes
-      };
+      const keys = { awaitingStepId, pendingStepId };
 
       return [
-        dynamodbSharedLib.putItem(_izContext, multipleStepsTable, baseAttrs),
-        dynamodbSharedLib.putItem(_izContext, byPendingTable, {
-          ...baseAttrs,
-          additionalAttributes
+        dynamodbSharedLib.putItem(_izContext, tableSteps, keys),
+        dynamodbSharedLib.putItem(_izContext, tablePending, {
+          ...keys,
+          ...sharedAttributes,
+          ...(additionalAttributes && { additionalAttributes })
         })
       ];
     })
   );
 }
 
-async function queryAwaitingMultipleSteps(_izContext, awaitingStepId) {
-  return dynamodbSharedLib.query(
+async function _queryPendingStepsByAwaitingStepId(_izContext, awaitingStepId) {
+  if (!awaitingStepId) {
+    throw new NoRetryError('awaitingStepId required');
+  }
+
+  const { Items } = await dynamodbSharedLib.query(
     _izContext,
     dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-    {
-      awaitingStepId
-    }
+    { awaitingStepId }
   );
+
+  return Items;
 }
 
-//====================================== 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 }
+async function _queryAwaitingStepsByPendingStepId(_izContext, pendingStepId) {
+  _assertPendingStepId(pendingStepId);
+
+  const { Items } = await dynamodbSharedLib.query(
+    _izContext,
+    dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
+    { pendingStepId },
+    { limit: 50 }
   );
 
-  const timestamp = Date.now();
-  await putAwaitingMultipleStepRecords(_izContext, records, pendingStepId, {
-    timestamp
-  });
+  return Items;
 }
 
-/**
- * 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 createAwaitingMultipleStep(
+//======================================
+// 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,
   pendingStepId,
-  prefix = '',
-  additionalAttributes = {}
+  options = {}
 ) {
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:createAwaitingMultipleStep] Input: ',
-    {
-      pendingStepId,
-      additionalAttributes
-    }
-  );
+  const {
+    records = [],
+    prefix = '',
+    additionalAttributes = {},
+    publishConfig = null
+  } = options;
+
+  _izContext.logger.debug('[Lib:AsyncFlow:createAwaitingMultipleSteps] Input', {
+    pendingStepId,
+    options
+  });
 
-  const parentFlowId = createParentFlowId(prefix);
-  const sharedAttributes = {
-    complete: false,
-    errorsFound: []
-  };
+  let finalRecords = records;
 
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:createAwaitingMultipleStep] sharedAttributes: ',
-    { awaitingStepId: parentFlowId, pendingStepId, ...sharedAttributes }
-  );
+  if (finalRecords.length === 0 && !publishConfig) {
+    finalRecords = [
+      {
+        awaitingStepId: createParentFlowId(prefix),
+        additionalAttributes
+      }
+    ];
+  }
 
-  await putAwaitingMultipleStepRecords(
-    _izContext,
-    [{ awaitingStepId: parentFlowId, additionalAttributes }],
-    pendingStepId,
-    sharedAttributes
-  );
+  if (publishConfig) {
+    const { messages, flowType = {} } = publishConfig;
+    const { flowTag, serviceTag } = flowType;
 
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:createAwaitingMultipleStep] Returning: ',
-    parentFlowId
-  );
+    if (!Array.isArray(messages)) {
+      throw new NoRetryError('messages must be an array');
+    }
 
-  return parentFlowId;
-}
+    if (!flowTag || !serviceTag) {
+      throw new NoRetryError('flowType must both flowTag serviceTag');
+    }
 
-/**
- * Find one pendingStepId waiting on a given awaitingStepId (multiple).
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @returns {Promise<string>}
- */
-export async function findPendingStepIdAwaitingMultipleSteps(
-  _izContext,
-  awaitingStepId
-) {
-  _izContext.logger.debug(
-    '[Lib:findPendingStepIdAwaitingMultipleSteps] Input parameters',
+    finalRecords = messages.map(message => {
+      const parentFlowId = createParentFlowId(prefix);
+
+      return {
+        awaitingStepId: parentFlowId,
+        additionalAttributes,
+        message: {
+          ...message,
+          parentFlowId
+        }
+      };
+    });
+  }
+
+  await _putAwaitingMultipleStepRecords(
+    _izContext,
+    finalRecords.map(({ awaitingStepId, additionalAttributes: itemAttrs }) => ({
+      awaitingStepId,
+      additionalAttributes: itemAttrs
+    })),
+    pendingStepId,
     {
-      awaitingStepId: awaitingStepId
+      complete: false,
+      errorsFound: []
     }
   );
 
-  if (!awaitingStepId) {
-    _izContext.logger.error(
-      '[Lib:findPendingStepIdAwaitingMultipleSteps] awaitingStepId is required'
+  if (publishConfig) {
+    const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      publishConfig.flowType.flowTag,
+      publishConfig.flowType.serviceTag
     );
-    throw new NoRetryError('awaitingStepId is required');
-  }
 
-  const listPendingSteps = await queryAwaitingMultipleSteps(
-    _izContext,
-    awaitingStepId
-  );
-  if (listPendingSteps.Items.length !== 1) {
-    _izContext.logger.error(
-      '[Lib:findPendingStepIdAwaitingMultipleSteps] 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');
   }
-  const pendingStepId = listPendingSteps.Items[0].pendingStepId;
 
-  _izContext.logger.debug(
-    '[Lib:findPendingStepIdAwaitingMultipleSteps] Pending step ID',
-    pendingStepId
-  );
+  return finalRecords[0]?.awaitingStepId;
+}
 
-  return pendingStepId;
+export async function createAwaitingMultipleStepsWithAdditionalAttributes(
+  _izContext,
+  records,
+  pendingStepId
+) {
+  return createAwaitingMultipleSteps(_izContext, pendingStepId, { records });
 }
 
-/**
- * Return the raw items waiting on a given awaitingStepId (multiple).
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @returns {Promise<AwaitingMultipleStepsItem[]>}
- */
-export async function findPendingStepsAwaitingMultipleSteps(
+export async function createAwaitingMultipleStep(
   _izContext,
-  awaitingStepId
+  pendingStepId,
+  prefix = '',
+  additionalAttributes = {}
 ) {
-  _izContext.logger.debug(
-    '[Lib:findPendingStepsAwaitingMultipleSteps] Input parameters',
-    {
-      awaitingStepId: awaitingStepId
+  return createAwaitingMultipleSteps(_izContext, pendingStepId, {
+    prefix,
+    additionalAttributes
+  });
+}
+
+export async function createAwaitingMultipleStepsWithAdditionalAttributesAndPublish(
+  _izContext,
+  messages,
+  prefix = '',
+  flowType = {},
+  additionalAttributes = {},
+  pendingStepId
+) {
+  return createAwaitingMultipleSteps(_izContext, pendingStepId, {
+    prefix,
+    additionalAttributes,
+    publishConfig: {
+      messages,
+      flowType
     }
-  );
+  });
+}
 
-  if (!awaitingStepId) {
-    _izContext.logger.error(
-      '[Lib:findPendingStepsAwaitingMultipleSteps] awaitingStepId is required'
-    );
-    throw new NoRetryError('awaitingStepId is required');
-  }
+export async function findPendingStepAwaitingMultipleSteps(
+  _izContext,
+  awaitingStepId
+) {
+  _izContext.logger.debug('[Lib:findPendingStepAwaitingMultipleSteps] Input', {
+    awaitingStepId
+  });
 
-  const listPendingSteps = await queryAwaitingMultipleSteps(
+  const items = await _queryPendingStepsByAwaitingStepId(
     _izContext,
     awaitingStepId
   );
 
-  _izContext.logger.debug(
-    '[Lib:findPendingStepsAwaitingMultipleSteps] Record of awaitingStepId',
-    listPendingSteps
-  );
-
-  return listPendingSteps.Items;
+  return items[0];
 }
 
-/**
- * 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(
+export async function findPendingStepsAwaitingMultipleSteps(
   _izContext,
   awaitingStepId
 ) {
-  _izContext.logger.debug(
-    '[Lib:findPendingStepAwaitingMultipleSteps] Input parameters',
-    {
-      awaitingStepId: awaitingStepId
-    }
-  );
-
-  if (!awaitingStepId) {
-    _izContext.logger.error(
-      '[Lib:findPendingStepAwaitingMultipleSteps] awaitingStepId is required'
-    );
-    throw new NoRetryError('awaitingStepId is required');
-  }
+  return _queryPendingStepsByAwaitingStepId(_izContext, awaitingStepId);
+}
 
-  const listPendingSteps = await queryAwaitingMultipleSteps(
+export async function findPendingStepIdAwaitingMultipleSteps(
+  _izContext,
+  awaitingStepId
+) {
+  const items = await _queryPendingStepsByAwaitingStepId(
     _izContext,
     awaitingStepId
   );
-
-  _izContext.logger.debug(
-    '[Lib:findPendingStepAwaitingMultipleSteps] Record of awaitingStepId',
-    listPendingSteps
-  );
-
-  if (listPendingSteps.Items.length !== 1) {
-    _izContext.logger.error(
-      '[Lib:findPendingStepAwaitingMultipleSteps] listPendingSteps not equals 1'
-    );
-    throw new NoRetryError('listPendingSteps not equals 1');
-  }
-
-  return listPendingSteps.Items[0];
+  return items[0]?.pendingStepId;
 }
 
-// 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(
   _izContext,
   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 _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} [returnValues={}]
- * @returns {Promise<{
- *   isComplete: boolean,
- *   collectedAttributes: Record<string, any>|null,
- *   collectedErrors: any[],
- *   sharedAdditionalAttributes: any|null
- * }>}
- */
 export async function checkAllAwaitingStepsFinishedWithReturnParams(
   _izContext,
   pendingStepId,
   currentAwaitingStepId = null,
   errorsFound = [],
   returnValues = {},
-  settings = {
-    checkIsAllError: true
-  }
+  settings = { checkIsAllError: true }
 ) {
   _izContext.logger.debug(
     '[Lib:checkAllAwaitingStepsFinishedWithReturnParams] Input parameters',
@@ -359,36 +277,35 @@ export async function checkAllAwaitingStepsFinishedWithReturnParams(
     }
   );
 
+  _assertPendingStepId(pendingStepId);
+
   if (currentAwaitingStepId) {
     await dynamodbSharedLib.updateItem(
       _izContext,
       dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleStepByPending'),
       {
-        pendingStepId: pendingStepId,
+        pendingStepId,
         awaitingStepId: currentAwaitingStepId
       },
       {
         complete: true,
-        errorsFound: errorsFound,
-        returnValues: returnValues
+        errorsFound,
+        returnValues
       }
     );
   }
 
-  const awaitingStepItems = await dynamodbSharedLib.query(
+  const awaitingStepItems = await _queryAwaitingStepsByPendingStepId(
     _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
-  const hasIncomplete = awaitingStepItems.Items.some(
+  const hasIncomplete = awaitingStepItems.some(
     item => item.awaitingStepId !== currentAwaitingStepId && !item.complete
   );
 
@@ -401,125 +318,72 @@ export async function checkAllAwaitingStepsFinishedWithReturnParams(
     };
   }
 
-  _izContext.logger.debug(
-    '[Lib:checkAllAwaitingStepsFinishedWithReturnParams] Pass 1: all steps are complete'
-  );
-
-  // Pass 2: all steps are complete — collect errors and attributes
   const collectedAttributes = {};
   let sharedReturnValues = null;
 
-  for (const item of awaitingStepItems.Items) {
-    if (item.returnValues) {
-      collectedAttributes[item.awaitingStepId] = item.returnValues;
-      sharedReturnValues ??= item.returnValues; // ponytail: use nullish coalescing
+  for (const item of awaitingStepItems) {
+    if (!item.returnValues) {
+      continue;
     }
+
+    collectedAttributes[item.awaitingStepId] = item.returnValues;
+    sharedReturnValues ??= item.returnValues;
   }
 
-  const collectedErrors = awaitingStepItems.Items.flatMap(item =>
+  const collectedErrors = awaitingStepItems.flatMap(item =>
     item.errorsFound?.length > 0
       ? [`Error found in step ${item.awaitingStepId}`, ...item.errorsFound]
       : []
   );
 
-  _izContext.logger.debug(
-    '[Lib:checkAllAwaitingStepsFinishedWithReturnParams] Pass 2: all steps are complete — collect errors and attributes'
-  );
-
   return {
     isComplete: true,
     collectedAttributes,
     collectedErrors,
     returnValues: sharedReturnValues,
-    additionalAttributes:
-      awaitingStepItems.Items[0]?.additionalAttributes || null,
+    additionalAttributes: awaitingStepItems[0]?.additionalAttributes || null,
     ...(settings.checkIsAllError && {
-      isAllError: awaitingStepItems.Items.every(
-        item => item.errorsFound?.length > 0
-      )
+      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 new 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,
@@ -527,154 +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 new NoRetryError(
-      '[Lib:removeAwaitingMultipleStep] awaitingStepId or pendingStepId is required'
+      '[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 new NoRetryError('messages must be an array');
-  }
 
-  const flowTag = flowType.flowTag;
-  const serviceTag = flowType.serviceTag;
-
-  if (flowTag === undefined || serviceTag === undefined) {
-    throw new 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
-  );
-
-  // Generate IDs and prepare messages
-  const messagesWithParentId = messages.map(message => {
-    const parentFlowId = createParentFlowId(prefix);
-    return { ...message, parentFlowId };
-  });
-
-  // 1. Wait for all DynamoDB records to be created first (to avoid race conditions)
-  await putAwaitingMultipleStepRecords(
-    _izContext,
-    messagesWithParentId.map(({ parentFlowId }) => ({
-      awaitingStepId: parentFlowId,
-      additionalAttributes
-    })),
-    pendingStepId,
-    {
-      complete: false,
-      errorsFound: []
-    }
-  );
-
-  // 2. Then publish messages concurrently
-  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);
 }