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

package/src/awaitingStep.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,50 +7,54 @@ 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';
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+
 import { createFieldNameUniqueRequestId } from './asyncFlowSharedLib.js';
 
-async function queryAwaitingSteps(_izContext, awaitingStepId) {
-  return dynamodbSharedLib.query(
+async function _findSinglePendingStep(_izContext, awaitingStepId) {
+  _izContext.logger.debug('[Lib:AsyncFlow:findSinglePendingStep] Input', {
+    awaitingStepId
+  });
+
+  if (!awaitingStepId) {
+    throw new NoRetryError('awaitingStepId is required');
+  }
+
+  const { Items } = await dynamodbSharedLib.query(
     _izContext,
     dynamodbSharedLib.tableName(_izContext, 'AwaitingStep'),
-    {
-      awaitingStepId
-    }
+    { awaitingStepId }
   );
+
+  if (Items.length !== 1) {
+    throw new NoRetryError('listPendingSteps not equals 1');
+  }
+
+  return Items[0];
 }
 
-//====================================== AwaitingStep //======================================
-// AwaitingStep is when a flow is awaiting one external flow, and will continue it's flow once that one external flow is complete
-// One awaitingStepId can have multiple pendingStepIds that are awaiting it
-// logic can prepend any prefix to awaitingStepId if want to be share one table and differentiate different external step ids
+//======================================
+// AwaitingStep
+//======================================
+// AwaitingStep flow awaiting one external flow, will continue its flow once one external flow completes.
+// One awaitingStepId can have multiple pendingStepIds awaiting it.
 
-/**
- * Create a single AwaitingStep record, optionally attaching additional attributes and callingFlowConfig.
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @param {string} pendingStepId
- * @param {Attrs} [additionalAttributes={}]
- * @param {Attrs} [callingFlowConfig={}]
- * @returns {Promise<void>}
- */
 export async function createAwaitingStep(
   _izContext,
   awaitingStepId,
   pendingStepId,
-  additionalAttributes = {}, // save in top level
-  callingFlowConfig = {} // optional
+  additionalAttributes = {},
+  callingFlowConfig = {}
 ) {
-  _izContext.logger.debug('[Lib:AsyncFlow:createAwaitingStep] Input: ', {
+  _izContext.logger.debug('[Lib:AsyncFlow:createAwaitingStep] Input', {
     awaitingStepId,
     pendingStepId,
     additionalAttributes,
@@ -59,19 +62,15 @@ export async function createAwaitingStep(
   });
 
   const attributesWhenCreate = {
-    awaitingStepId: awaitingStepId,
-    pendingStepId: pendingStepId,
+    awaitingStepId,
+    pendingStepId,
     timestamp: Date.now(),
-    uniqueRequestId: _izContext.uniqueRequestId
+    uniqueRequestId: _izContext.uniqueRequestId,
+    ...additionalAttributes
   };
-  // loop if not empty
-  for (const additionalAttribute in additionalAttributes) {
-    attributesWhenCreate[additionalAttribute] =
-      additionalAttributes[additionalAttribute]; // each  additionalAttributes
-  }
 
   if (Object.keys(callingFlowConfig).length > 0) {
-    Object.assign(attributesWhenCreate, { callingFlowConfig });
+    attributesWhenCreate.callingFlowConfig = callingFlowConfig;
   }
 
   await dynamodbSharedLib.putItem(
@@ -81,174 +80,49 @@ export async function createAwaitingStep(
   );
 }
 
-/**
- * Find all pendingStepIds that are waiting on a given awaitingStepId (single).
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @returns {Promise<string[]>}
- */
-export async function findPendingStepIdsAwaitingStep(
+export async function findPendingStepIdAwaitingStep(
   _izContext,
   awaitingStepId
 ) {
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:findPendingStepIdsAwaitingStep] Input: ',
-    {
-      awaitingStepId
-    }
-  );
-
-  if (!awaitingStepId) {
-    throw new NoRetryError('awaitingStepId is required');
-  }
-
-  const listPendingStepIds = await queryAwaitingSteps(_izContext, awaitingStepId);
-  return listPendingStepIds.Items.map(item => item.pendingStepId);
-}
-
-/**
- * Return the raw items waiting on a given awaitingStepId (single).
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @returns {Promise<AwaitingStepItem[]>}
- */
-export async function findPendingStepsAwaitingStep(_izContext, awaitingStepId) {
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:findPendingStepsAwaitingStep] Input: ',
-    {
-      awaitingStepId
-    }
-  );
-
-  if (!awaitingStepId) {
-    throw new NoRetryError('awaitingStepId is required');
-  }
-
-  const listPendingSteps = await queryAwaitingSteps(_izContext, awaitingStepId);
-  _izContext.logger.debug('Record of awaitingStepId', listPendingSteps);
-  return listPendingSteps.Items;
+  const item = await _findSinglePendingStep(_izContext, awaitingStepId);
+  return item.pendingStepId;
 }
 
-/**
- * Fetch exactly one pending step for a given awaitingStepId (throws if not 1).
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @returns {Promise<AwaitingStepItem>}
- * @throws {NoRetryError} if there is not exactly one item
- */
-export async function findPendingStepAwaitingStep(_izContext, awaitingStepId) {
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:findPendingStepAwaitingStep] Input: ',
-    {
-      awaitingStepId
-    }
-  );
-
-  if (!awaitingStepId) {
-    throw new NoRetryError('awaitingStepId is required');
-  }
-
-  const listPendingSteps = await queryAwaitingSteps(_izContext, awaitingStepId);
-
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:findPendingStepAwaitingStep] Found records: ',
-    listPendingSteps
-  );
-
-  if (listPendingSteps.Items.length !== 1) {
-    throw new NoRetryError('listPendingSteps not equals 1');
-  }
-  return listPendingSteps.Items[0];
+export async function findPendingStep(_izContext, awaitingStepId) {
+  return _findSinglePendingStep(_izContext, awaitingStepId);
 }
 
-//  for get callingFlow save in awaitingStep and remove property callingFlow in awaitingStep
-/**
- * Get one awaiting step by id and also extract (and remove) its callingFlowConfig (if present).
- * Returns a tuple: [AwaitingStepItemWithoutCallingFlow, callingFlowConfig|null].
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @returns {Promise<[AwaitingStepItem, Attrs|null]>}
- */
 export async function findPendingStepAwaitingStepWithCallingFlow(
   _izContext,
   awaitingStepId
 ) {
-  _izContext.logger.debug(
-    '[Lib:AsyncFlow:findPendingStepAwaitingStepWithCallingFlow] Input: ',
-    {
-      awaitingStepId
-    }
-  );
-
-  if (!awaitingStepId) {
-    throw new NoRetryError('awaitingStepId is required');
-  }
-
-  let callingFlowConfig = null;
-  let awaitingStep = await findPendingStepAwaitingStep(
-    _izContext,
-    awaitingStepId
-  );
-
-  // callingFlowConfig.
-  // cleaning object awaitingStep not have callingFlowConfig after return.
-  if (awaitingStep.hasOwnProperty('callingFlowConfig')) {
-    callingFlowConfig = awaitingStep.callingFlowConfig;
-    delete awaitingStep.callingFlowConfig;
-    _izContext.logger.debug('after delete awaitingStep', awaitingStep);
-  }
+  const awaitingStep = await findPendingStep(_izContext, awaitingStepId);
+  const { callingFlowConfig = null, ...restAwaitingStep } = awaitingStep;
 
-  return [awaitingStep, callingFlowConfig];
+  return [restAwaitingStep, callingFlowConfig];
 }
 
-/**
- * Remove a single AwaitingStep record (single dependency table).
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @param {string} pendingStepId
- * @returns {Promise<void>}
- */
 export async function removeAwaitingStep(
   _izContext,
   awaitingStepId,
   pendingStepId
 ) {
-  _izContext.logger.debug('[Lib:AsyncFlow:removeAwaitingStep] Input: ', {
+  _izContext.logger.debug('[Lib:AsyncFlow:removeAwaitingStep] Input', {
     awaitingStepId,
     pendingStepId
   });
 
   if (!awaitingStepId || !pendingStepId) {
-    throw new NoRetryError('awaitingStepId and pendingStepId are required');
+    throw new NoRetryError('awaitingStepId pendingStepId required');
   }
 
   await dynamodbSharedLib.deleteItem(
     _izContext,
     dynamodbSharedLib.tableName(_izContext, 'AwaitingStep'),
-    {
-      awaitingStepId: awaitingStepId,
-      pendingStepId: pendingStepId
-    }
+    { awaitingStepId, pendingStepId }
   );
 }
 
-// only works with AwaitingStep, does not work with AwaitingMultipleSteps, need to make new function that checks conditional pass? If pass delete from byPending table too
-/**
- * Remove an AwaitingStep item only if its stored UniqueRequestId matches `checkUniqueRequestId`.
- * Uses a conditional expression; will not error if the condition fails.
- * @async
- * @param {IzContext} _izContext
- * @param {string} awaitingStepId
- * @param {string} pendingStepId
- * @param {string} checkUniqueRequestId
- * @param {string} [prefix=""] - Optional prefix for UniqueRequestId field name
- * @returns {Promise<void>}
- */
 export async function removeAwaitingStepWithCheckUniqueRequestId(
   _izContext,
   awaitingStepId,
@@ -257,27 +131,18 @@ export async function removeAwaitingStepWithCheckUniqueRequestId(
   prefix = ''
 ) {
   _izContext.logger.debug(
-    '[Lib:AsyncFlow:removeAwaitingStepWithCheckUniqueRequestId] Input: ',
-    {
-      awaitingStepId,
-      pendingStepId,
-      checkUniqueRequestId,
-      prefix
-    }
+    '[Lib:AsyncFlow:removeAwaitingStepWithCheckUniqueRequestId] Input',
+    { awaitingStepId, pendingStepId, checkUniqueRequestId, prefix }
   );
 
   if (!awaitingStepId || !pendingStepId || !checkUniqueRequestId) {
     throw new NoRetryError(
-      'awaitingStepId, pendingStepId and checkUniqueRequestId are required'
+      'awaitingStepId, pendingStepId checkUniqueRequestId required'
     );
   }
 
-  // if logicalElements add queryElements.logicalElements
-  // set condition uniqueRequestId match with exists
   const queryElementsCondition = {
-    additionalAttributes: {
-      checkUniqueRequestId: checkUniqueRequestId
-    },
+    additionalAttributes: { checkUniqueRequestId },
     logicalElements: [
       {
         type: 'logical',
@@ -291,13 +156,8 @@ export async function removeAwaitingStepWithCheckUniqueRequestId(
   await dynamodbSharedLib.deleteItem(
     _izContext,
     dynamodbSharedLib.tableName(_izContext, 'AwaitingStep'),
-    {
-      awaitingStepId: awaitingStepId,
-      pendingStepId: pendingStepId
-    },
+    { awaitingStepId, pendingStepId },
     queryElementsCondition,
-    {
-      errorOnConditionalExpNotPass: false
-    }
+    { errorOnConditionalExpNotPass: false }
   );
 }