@izara_project/izara-core-library-asynchronous-flow 1.0.20 → 1.0.21

package/src/awaitingStep.js

@@ -0,0 +1,244 @@
+/*
+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
+published by the Free Software Foundation, either version 3 of the
+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
+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/>.
+*/
+
+import { NoRetryError } from '@izara_project/izara-core-library-core';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import { createFieldNameUniqueRequestId } from './asyncFlowSharedLib.js';
+
+//====================================== 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
+
+/**
+ * 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
+) {
+  _izContext.logger.debug('Lib createAwaitingStep:', {
+    awaitingStepId,
+    pendingStepId,
+    additionalAttributes,
+    callingFlowConfig
+  });
+
+  let attributesWhenCreate = {
+    awaitingStepId: awaitingStepId,
+    pendingStepId: pendingStepId,
+    timestamp: Date.now(),
+    uniqueRequestId: _izContext.uniqueRequestId
+  };
+  // loop if not empty
+  for (let additionalAttribute in additionalAttributes) {
+    attributesWhenCreate[additionalAttribute] =
+      additionalAttributes[additionalAttribute]; // each  additionalAttributes
+  }
+  if (Object.keys(callingFlowConfig).length > 0) {
+    Object.assign(attributesWhenCreate, { callingFlowConfig });
+  }
+
+  await dynamodbSharedLib.putItem(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, 'AwaitingStep'),
+    attributesWhenCreate
+  );
+}
+
+/**
+ * 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(
+  _izContext,
+  awaitingStepId
+) {
+  let pendingStepIds = [];
+
+  let listPendingStepIds = await dynamodbSharedLib.query(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, 'AwaitingStep'),
+    {
+      awaitingStepId: awaitingStepId
+    }
+  );
+
+  for (let idx = 0; idx < listPendingStepIds.Items.length; idx++) {
+    pendingStepIds.push(listPendingStepIds.Items[idx].pendingStepId);
+  }
+
+  return pendingStepIds;
+}
+
+/**
+ * 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) {
+  let listPendingSteps = await dynamodbSharedLib.query(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, 'AwaitingStep'),
+    {
+      awaitingStepId: awaitingStepId
+    }
+  );
+  _izContext.logger.debug('Record of awaitingStepId', listPendingSteps);
+  return listPendingSteps.Items;
+}
+
+/**
+ * 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) {
+  let listPendingSteps = await dynamodbSharedLib.query(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, 'AwaitingStep'),
+    {
+      awaitingStepId: awaitingStepId
+    }
+  );
+  _izContext.logger.debug('Record of awaitingStepId', listPendingSteps);
+
+  if (listPendingSteps.Items.length !== 1) {
+    throw new NoRetryError('listPendingSteps not equals 1');
+  }
+  return listPendingSteps.Items[0];
+}
+
+//  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
+) {
+  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);
+  }
+
+  return [awaitingStep, 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
+) {
+  await dynamodbSharedLib.deleteItem(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, 'AwaitingStep'),
+    {
+      awaitingStepId: awaitingStepId,
+      pendingStepId: 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,
+  pendingStepId,
+  checkUniqueRequestId,
+  prefix = ''
+) {
+  // if logicalElements add queryElements.logicalElements
+  // set condition uniqueRequestId match with exists
+  const queryElementsCondition = {
+    additionalAttributes: {
+      checkUniqueRequestId: checkUniqueRequestId
+    },
+    logicalElements: [
+      {
+        type: 'logical',
+        comparison: 'equals',
+        lhsAttribute: createFieldNameUniqueRequestId(prefix),
+        rhsReference: 'checkUniqueRequestId'
+      }
+    ]
+  };
+
+  await dynamodbSharedLib.deleteItem(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, 'AwaitingStep'),
+    {
+      awaitingStepId: awaitingStepId,
+      pendingStepId: pendingStepId
+    },
+    queryElementsCondition,
+    {
+      errorOnConditionalExpNotPass: false
+    }
+  );
+}