@izara_project/izara-core-library-asynchronous-flow 1.0.1 → 1.0.2

package/index.js

@@ -0,0 +1,58 @@
+/*
+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/>.
+*/
+
+'use strict';
+
+// Import the Asynchronous Flow shared library functions
+const asyncFlowSharedLib = require('./src/AsyncFlowSharedLib');
+
+// Export all the functions
+module.exports = {
+  // Identifier creation
+  createFieldNameUniqueRequestId: asyncFlowSharedLib.createFieldNameUniqueRequestId,
+  createConcatenatedAwaitingStepId: asyncFlowSharedLib.createConcatenatedAwaitingStepId,
+  createConcatenatedPendingStepId: asyncFlowSharedLib.createConcatenatedPendingStepId,
+  createAwaitingStepId: asyncFlowSharedLib.createAwaitingStepId,
+  createPendingStepId: asyncFlowSharedLib.createPendingStepId,
+  explodePendingStepId: asyncFlowSharedLib.explodePendingStepId,
+
+  // Awaiting Multiple Steps
+  createAwaitingMultipleStepsWithAdditionalAttributes: asyncFlowSharedLib.createAwaitingMultipleStepsWithAdditionalAttributes,
+  createAwaitingMultipleSteps: asyncFlowSharedLib.createAwaitingMultipleSteps,
+
+  // Awaiting Step
+  createAwaitingStep: asyncFlowSharedLib.createAwaitingStep,
+  findPendingStepIdsAwaitingStep: asyncFlowSharedLib.findPendingStepIdsAwaitingStep,
+  findPendingStepsAwaitingStep: asyncFlowSharedLib.findPendingStepsAwaitingStep,
+
+  // Checking and clearing steps
+  checkAllAwaitingStepsFinished: asyncFlowSharedLib.checkAllAwaitingStepsFinished,
+  clearAllAwaitingSteps: asyncFlowSharedLib.clearAllAwaitingSteps,
+  removeAwaitingStep: asyncFlowSharedLib.removeAwaitingStep,
+  removeAwaitingMultipleStep: asyncFlowSharedLib.removeAwaitingMultipleStep,
+  removeAwaitingStepWithCheckUniqueRequestId: asyncFlowSharedLib.removeAwaitingStepWithCheckUniqueRequestId,
+
+  // Request and cache processing
+  checkUniqueRequestProcessing: asyncFlowSharedLib.checkUniqueRequestProcessing,
+  checkTimeCacheComplete: asyncFlowSharedLib.checkTimeCacheComplete,
+  checkAndGetTimeCacheComplete: asyncFlowSharedLib.checkAndGetTimeCacheComplete,
+  checkCacheUniqueRequestId: asyncFlowSharedLib.checkCacheUniqueRequestId,
+
+  // Pagination and invocation helpers
+  validateStartKeyParam: asyncFlowSharedLib.validateStartKeyParam,
+  validateMultipleInvocations: asyncFlowSharedLib.validateMultipleInvocations
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-library-asynchronous-flow",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Shared asynchronous flow logic",
   "main": "index.js",
   "scripts": {
@@ -25,4 +25,4 @@
     "@izara_project/izara-shared": "^1.0.121",
     "aws-jwt-verify": "^4.0.1"
   }
-}
+}

package/src/AsyncFlowSharedLib.js

@@ -0,0 +1,864 @@
+/*
+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/>.
+*/
+
+'use strict';
+
+// Core libraries
+const { NoRetryError } = require('@izara_project/izara-core-library-core');
+const Logger = require('@izara_project/izara-core-library-logger');
+const dynamodbSharedLib = require('@izara_project/izara-core-library-dynamodb');
+const sqsSharedLib = require('@izara_project/izara-core-library-sqs');
+const triggeredCacheSharedLib = require('@izara_project/izara-core-library-triggeredCache');
+
+// External services
+const { sqs } = require('@izara_project/izara-core-library-external-request');
+
+module.exports.createFieldNameUniqueRequestId = (
+  prefix,
+  uniqueRequestIdFieldName = 'UniqueRequestId'
+) => {
+  return prefix + uniqueRequestIdFieldName;
+}
+
+module.exports.createConcatenatedAwaitingStepId = (
+  partitionKey,
+  sortId,
+  prefix = ""
+) => {
+  return prefix + partitionKey + "_" + sortId
+}
+
+module.exports.createConcatenatedPendingStepId = (
+  parentId,
+  childId
+) => {
+  return parentId + "_" + childId
+}
+
+module.exports.createAwaitingStepId = (
+  partitionKey,
+  prefix = ""
+) => {
+  return prefix + partitionKey
+}
+
+module.exports.createPendingStepId = (
+  identifierId,
+  prefix = ""
+) => {
+  return prefix + identifierId
+}
+
+module.exports.explodePendingStepId = (
+  pendingStepId,
+  prefix = ""
+) => {
+  if (prefix === "") {
+    return pendingStepId;
+  } else {
+    let identifierId = pendingStepId.slice(prefix.length)
+    // ** validate identifierId == prefix
+    if (identifierId == prefix) {
+      throw new NoRetryError("IdentifierId should not be like prefix.");
+    }
+
+    Logger.debug("return explode:", identifierId);
+    return identifierId;
+  }
+
+}
+
+//====================================== 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
+
+//not yet used ?
+module.exports.createAwaitingMultipleStepsWithAdditionalAttributes = async (
+  _izContext,
+  records, // array of object including properties: awaitingStepId / (optional) additionalAttributes
+  pendingStepId,
+  tableName = "AwaitingMultipleSteps",
+  byPendingTableName = "AwaitingMultipleStepByPending"
+) => {
+  _izContext.logger.debug("Lib:createAwaitingMultipleStepsWithAdditionalAttributes", {
+    records: records,
+    pendingStepId: pendingStepId,
+    tableName: tableName,
+    byPendingTableName: byPendingTableName
+  });
+  let promiseArray = []
+
+  for (let record of records) {
+
+    let attributesWhenCreate = {
+      awaitingStepId: record.awaitingStepId,
+      pendingStepId: pendingStepId,
+      timestamp: Date.now(),
+      ...record.additionalAttributes
+    }
+
+    promiseArray.push(
+      dynamodbSharedLib.putItem(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, tableName),
+        attributesWhenCreate
+      )
+    );
+    promiseArray.push(
+      dynamodbSharedLib.putItem(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, byPendingTableName),
+        {
+          pendingStepId: pendingStepId,
+          awaitingStepId: record.awaitingStepId,
+          timestamp: Date.now(),
+        }
+      ));
+
+  }
+
+  await Promise.all(promiseArray);
+
+}
+
+module.exports.createAwaitingMultipleSteps = async (
+  _izContext,
+  records, // array of awaitingStepIds
+  pendingStepId,
+  tableName = "AwaitingMultipleSteps",
+  byPendingTableName = "AwaitingMultipleStepByPending"
+) => {
+  _izContext.logger.debug("Lib:createAwaitingMultipleSteps", {
+    records: records,
+    pendingStepId: pendingStepId,
+    tableName: tableName,
+    byPendingTableName: byPendingTableName
+  });
+
+  // // 0001 ORG.
+  let promiseArray = []
+
+  for (let record of records) {
+
+    let attributesWhenCreate = {
+      awaitingStepId: record,
+      pendingStepId: pendingStepId,
+      timestamp: Date.now()
+    }
+    _izContext.logger.debug("putItem:AwaitingMultipleSteps +++++++", { awaitingStepId: attributesWhenCreate.awaitingStepId })
+    promiseArray.push(
+      dynamodbSharedLib.putItem(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, tableName),
+        attributesWhenCreate
+      )
+    );
+
+
+    _izContext.logger.debug("putItem:AwaitingMultipleStepByPending", { awaitingStepId: attributesWhenCreate.awaitingStepId })
+    promiseArray.push(
+      dynamodbSharedLib.putItem(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, byPendingTableName),
+        attributesWhenCreate
+      )
+    );
+
+    _izContext.logger.debug("check 0")
+
+  }
+  await Promise.all(promiseArray);
+
+}
+
+//====================================== 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
+
+module.exports.createAwaitingStep = async (
+  _izContext,
+  awaitingStepId,
+  pendingStepId,
+  tableName = "AwaitingStep",
+  additionalAttributes = {} // save in top level
+) => {
+
+  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]
+  }
+
+  await dynamodbSharedLib.putItem(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, tableName),
+    attributesWhenCreate
+  );
+}
+
+
+
+
+module.exports.findPendingStepIdsAwaitingStep = async (
+  _izContext,
+  awaitingStepId,
+  tableName = "AwaitingStep"
+) => {
+
+  let pendingStepIds = [];
+
+  let listPendingStepIds = await dynamodbSharedLib.query(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, tableName),
+    {
+      awaitingStepId: awaitingStepId
+    }
+  );
+
+  for (let idx = 0; idx < listPendingStepIds.Items.length; idx++) {
+    pendingStepIds.push(listPendingStepIds.Items[idx].pendingStepId)
+  }
+
+  return pendingStepIds
+}
+
+module.exports.findPendingStepsAwaitingStep = async (
+  _izContext,
+  awaitingStepId,
+  tableName = "AwaitingStep"
+) => {
+
+  let listPendingSteps = await dynamodbSharedLib.query(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, tableName),
+    {
+      awaitingStepId: awaitingStepId
+    }
+  );
+  _izContext.logger.debug("Record of awaitingStepId", listPendingSteps)
+  return listPendingSteps.Items;
+}
+
+
+
+module.exports.checkAllAwaitingStepsFinished = async (
+  _izContext,
+  pendingStepId,
+  currentAwaitingStepId = null,
+  tableName = 'AwaitingMultipleSteps',
+  byPendingTableName = "AwaitingMultipleStepByPending"
+  // indexName = ''
+) => {
+  _izContext.logger.debug("Lib:checkAllAwaitingStepsFinished", {
+    pendingStepId: pendingStepId,
+    currentAwaitingStepId: currentAwaitingStepId,
+    tableName: tableName,
+    byPendingTableName: byPendingTableName
+  });
+
+  if (currentAwaitingStepId) {
+
+    //* not need to save complete in AwaitingMultipleSteps Table but save in AwaitingMultipleStepByPending
+    // await dynamodbSharedLib.updateItem(
+    //   _izContext,
+    //   dynamodbSharedLib.tableName(tableName),
+    //   {
+    //     awaitingStepId: currentAwaitingStepId,
+    //     pendingStepId: pendingStepId
+    //   },
+    //   {
+    //     complete: true
+    //   },
+    // )
+
+    _izContext.logger.debug(`---- update ${byPendingTableName} table ----`);
+    await dynamodbSharedLib.updateItem(
+      _izContext,
+      await dynamodbSharedLib.tableName(_izContext, byPendingTableName),
+      {
+        pendingStepId: pendingStepId,
+        awaitingStepId: currentAwaitingStepId
+      },
+      {
+        complete: true
+      },
+    );
+
+  }
+  let listPendingStepIds = await dynamodbSharedLib.query(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, byPendingTableName),
+    {
+      pendingStepId: pendingStepId
+    },
+    {
+      limit: 50 // arbritrary limit so not pull too many results, need >2 because some others might be marked as "complete" = true
+    }
+  );
+  for (let idx = 0; idx < listPendingStepIds.Items.length; idx++) {
+
+    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;
+    }
+  }
+
+  return true;
+
+
+  // // mark currentAwaitingStepId as complete, this is done to protect against race condition in between checking all complete
+  // // and then removing the record, we need to let other requests know this record is complete and need to do this before
+  // // querying all remaining records, otherwise if have only two remaining requests they might both show as records remaining
+  // // (seeing each other) and not continue flow, then each deletes their record and no records remain to trigger next step.
+  // // can result in race condition where multiple requests see all records finished, code has to account for this, but should already do so for idempotence
+  // // add query that updates the currentAwaitingStepId to have attribute "complete" = true
+  // if (currentAwaitingStepId) {
+  //   await dynamodbSharedLib.updateItem(
+  //     _izContext,
+  //     dynamodbSharedLib.tableName(tableName),
+  //     {
+  //       awaitingStepId: currentAwaitingStepId,
+  //       pendingStepId: pendingStepId
+  //     },
+  //     {
+  //       complete: true
+  //     },
+  //   )
+  // }
+  // let listPendingStepIds = await dynamodbSharedLib.query(
+  //   _izContext,
+  //   dynamodbSharedLib.tableName(tableName),
+  //   {
+  //     pendingStepId: pendingStepId
+  //   },
+  //   {
+  //     indexName: dynamodbSharedLib.tableName(tableName + 'Index'),
+  //     limit: 50 // arbritrary limit so not pull too many results, need >2 because some others might be marked as "complete" = true
+  //   }
+  // );
+  // for (let idx = 0; idx < listPendingStepIds.Items.length; idx++) {
+
+  //   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;
+  //   }
+  // }
+
+  // return true;
+}
+
+module.exports.clearAllAwaitingSteps = async (
+  _izContext,
+  pendingStepId,
+  tableName = 'AwaitingMultipleSteps',
+  byPendingTableName = "AwaitingMultipleStepByPending"
+) => {
+  _izContext.logger.debug("Lib:clearAllAwaitingSteps", {
+    pendingStepId: pendingStepId,
+    tableName: tableName,
+    byPendingTableName: byPendingTableName
+  })
+
+  tableName = await dynamodbSharedLib.tableName(_izContext, tableName)
+
+  // ----- query items from GSI table
+  let listPendingStepIds = await dynamodbSharedLib.query(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, byPendingTableName),
+    {
+      pendingStepId: pendingStepId
+    },
+  );
+  _izContext.logger.debug('listPendingStepIds', listPendingStepIds);
+
+
+  let promiseArray = []
+
+  for (let idx = 0; idx < listPendingStepIds.Items.length; idx++) {
+
+    let keyValues = {
+      awaitingStepId: listPendingStepIds.Items[idx].awaitingStepId,
+      pendingStepId: listPendingStepIds.Items[idx].pendingStepId
+    }
+    _izContext.logger.debug('deleting ... ', keyValues);
+
+    _izContext.logger.debug(`delete item in dynamodb AwaitingMultipleSteps ==> awaitingStepId:${keyValues.awaitingStepId}`)
+    promiseArray.push(
+      dynamodbSharedLib.deleteItem(
+        _izContext,
+        tableName,
+        keyValues
+      ));
+    _izContext.logger.debug(`delete item in dynamodb AwaitingMultipleStepByPending ==> awaitingStepId:${keyValues.awaitingStepId}`)
+    promiseArray.push(
+      dynamodbSharedLib.deleteItem(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, byPendingTableName),
+        keyValues
+      ));
+
+  }
+
+  await Promise.all(promiseArray);
+
+  return true;
+}
+
+
+module.exports.removeAwaitingStep = async (
+  _izContext,
+  awaitingStepId,
+  pendingStepId,
+  tableName = "AwaitingStep"
+) => {
+
+  await dynamodbSharedLib.deleteItem(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, tableName),
+    {
+      awaitingStepId: awaitingStepId,
+      pendingStepId: pendingStepId
+    }
+  );
+}
+
+module.exports.removeAwaitingMultipleStep = async (
+  _izContext,
+  awaitingStepId,
+  pendingStepId,
+  tableName = "AwaitingMultipleSteps",
+  byPendingTableName = "AwaitingMultipleStepByPending"
+) => {
+  _izContext.logger.debug("Lib:removeAwaitingMultipleStep", {
+    awaitingStepId: awaitingStepId,
+    pendingStepId: pendingStepId,
+    tableName: tableName,
+    byPendingTableName: byPendingTableName
+  })
+
+  let promiseArray = []
+
+  let keyValues = {
+    awaitingStepId: awaitingStepId,
+    pendingStepId: pendingStepId
+  }
+  _izContext.logger.debug('deleting ... ', keyValues);
+
+  _izContext.logger.debug(`delete item in dynamodb AwaitingMultipleSteps ==> awaitingStepId:${keyValues.awaitingStepId}`)
+  promiseArray.push(
+    dynamodbSharedLib.deleteItem(
+      _izContext,
+      await dynamodbSharedLib.tableName(_izContext, tableName),
+      keyValues
+    ));
+
+  _izContext.logger.debug(`delete item in dynamodb AwaitingMultipleStepByPending ==> awaitingStepId:${keyValues.awaitingStepId}`)
+  promiseArray.push(
+    dynamodbSharedLib.deleteItem(
+      _izContext,
+      await dynamodbSharedLib.tableName(_izContext, byPendingTableName),
+      keyValues
+    ));
+
+  await Promise.all(promiseArray);
+
+}
+
+// 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
+module.exports.removeAwaitingStepWithCheckUniqueRequestId = async (
+  _izContext,
+  awaitingStepId,
+  pendingStepId,
+  checkUniqueRequestId,
+  prefix = "",
+  tableName = "AwaitingStep"
+) => {
+
+  // if logicalElements add queryElements.logicalElements
+  // set condition uniqueRequestId match with exists
+  const queryElementsCondition = {
+    additionalAttributes: {
+      checkUniqueRequestId: checkUniqueRequestId,
+    },
+    logicalElements: [
+      {
+        type: "logical",
+        comparison: "equals",
+        lhsAttribute: this.createFieldNameUniqueRequestId(prefix),
+        rhsReference: "checkUniqueRequestId"
+      },
+    ]
+  }
+
+  await dynamodbSharedLib.deleteItem(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, tableName),
+    {
+      awaitingStepId: awaitingStepId,
+      pendingStepId: pendingStepId
+    },
+    queryElementsCondition,
+    {
+      errorOnConditionalExpNotPass: false
+    }
+  );
+}
+
+
+
+//====================================== end AwaitingStep
+
+
+
+
+
+/**
+ * Checks if record has uniqueRequestId set, if not set to this requests uniqueRequestId and continue to process
+ * if already set check if matches this request uniqueRequestId, if yes continue to process, if not then stop processing
+ * status: "process"|"stop"|"recordNotFound"
+
+ * if unable to set uniqueRequestId (because other thread updated it) throw NoRetryError
+ * conditional update existingRecord set uniqueRequestId = _izContext.uniqueRequestId
+ * conditional check uniqueRequestId still not exist in case another thread added
+ * if conditional not pass "continue" and try again
+
+ * @returns [string] [returnStatus, existingRecord]
+ */
+module.exports.checkUniqueRequestProcessing = async (
+  _izContext,
+  tableName,
+  primaryKey,
+  prefix = '',
+  overwriteUniqueRequestId = null,
+  uniqueRequestIdFieldName = "UniqueRequestId" // if set will check/add this fieldname with _izContext.uniqueRequestId value
+) => {
+  try {
+
+    _izContext.logger.debug('current uniqueRequestId:', _izContext.uniqueRequestId)
+
+    let uniqueRequestId = _izContext.uniqueRequestId;
+    if (overwriteUniqueRequestId) {
+      uniqueRequestId = overwriteUniqueRequestId;
+    }
+
+    // add prefix
+    uniqueRequestIdFieldName = this.createFieldNameUniqueRequestId(
+      prefix,
+      uniqueRequestIdFieldName
+    );
+
+    //loop 3 times incase status changes, on 3rd iteration throw error (so checks 2 times)
+    for (let i = 1; i <= 3; i++) {
+      if (i == 3) {
+        throw new NoRetryError(`unable to set uniqueRequestId in table ${tableName}, record`, primaryKey);
+      }
+      //* get record from dynamo
+      let existingRecord = await dynamodbSharedLib.getItem(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, tableName),
+        primaryKey,
+      )
+      _izContext.logger.debug('existingRecord:', existingRecord);
+
+      let returnStatus = "process";
+
+      if (!existingRecord) {
+        // return ["recordNotFound", null]; // cannot return null, js cannot found object and throw error and dont know where it is?
+        return ["recordNotFound", {}];
+
+      } else if (!existingRecord[uniqueRequestIdFieldName]) {
+        // uniqueRequestId not yet exist
+
+        let updateAttributes = [
+          {
+            attributeName: uniqueRequestIdFieldName,
+            action: "set",
+            value: _izContext.uniqueRequestId,
+          },
+        ]
+        //* conditional check uniqueRequestId still not exist in case another thread added
+        const queryElementsWhenUpdate = {
+          logicalElements: [
+            {
+              type: "function",
+              function: "attribute_not_exists",
+              attribute: uniqueRequestIdFieldName,
+            }
+          ],
+          returnValues: 'ALL_NEW'
+        }
+        // // ----- main query ---------
+        let updateRecord = null;
+        try {
+          updateRecord = await dynamodbSharedLib.updateItem(
+            _izContext,
+            await dynamodbSharedLib.tableName(_izContext, tableName),
+            primaryKey,
+            updateAttributes,
+            queryElementsWhenUpdate,
+            { complexAttributes: true }, // force to complex
+          )
+
+        } catch (err) { // catch error when put and handle errors.
+          _izContext.logger.debug('updateItem storedCache expired err', err);
+          if (err.name == 'ConditionalCheckFailedException') {
+            continue;
+          } else { // e.g. ProvisionedThroughputExceededException
+            // throw new Error('Unhandled Error when putItem', err) // TT, if throw will stop
+            throw (err) // TT, if throw will stop
+          }
+        } //end catch err
+
+      } else if (existingRecord[uniqueRequestIdFieldName] !== uniqueRequestId) {
+
+        // when another request/uniqueRequestId need to stop process
+        returnStatus = "stop";
+      }
+      // if existingRecord[uniqueRequestIdFieldName] == uniqueRequestId then return "process"
+
+      return [returnStatus, existingRecord];
+
+    } // end loop 2 times
+    //should never get here
+    throw new NoRetryError('unexpected logic flow in checkUniqueRequestProcessing');
+
+  } catch (err) {
+    _izContext.logger.error('ERROR checkUniqueRequestProcessing:', err)
+    throw (err)
+  }
+};
+
+// ----- Helper funtion, common use case in triggerFlow ---------
+module.exports.checkTimeCacheComplete = async (
+  _izContext,
+  fullMainTableName,
+  keyValues,
+  timeCacheComplete,
+  prefix
+) => {
+  let [returnValue, newTimeCacheComplete, uniqueRequestId] = await this.checkAndGetTimeCacheComplete(
+    _izContext,
+    fullMainTableName,
+    keyValues,
+    timeCacheComplete,
+    prefix
+  );
+  return [returnValue, uniqueRequestId];
+}
+module.exports.checkAndGetTimeCacheComplete = async (
+  _izContext,
+  fullMainTableName,
+  keyValues,
+  timeCacheComplete,
+  prefix
+) => {
+  _izContext.logger.debug('event checkTimeCacheComplete', {
+    fullMainTableName: fullMainTableName,
+    keyValues: keyValues,
+    timeCacheComplete: timeCacheComplete,
+    prefix: prefix
+  });
+
+  let uniqueRequestIdFieldName = triggeredCacheSharedLib.createFieldNameUniqueRequestId(prefix);
+  let cacheCompleteFieldName = triggeredCacheSharedLib.createFieldNameCacheComplete(prefix);
+  let statusFieldName = triggeredCacheSharedLib.createFieldNameStatus(prefix);
+
+  let getTimeCacheComplete = await dynamodbSharedLib.getItem(
+    _izContext,
+    fullMainTableName,
+    keyValues
+  )
+  _izContext.logger.debug(`getTimeCacheComplete from ${fullMainTableName}: `, getTimeCacheComplete);
+
+  if (!getTimeCacheComplete) {
+    throw new NoRetryError(`cannot getTimeCacheComplete from ${fullMainTableName}`);
+  }
+
+  // check if exist and match with initail create not changing in flow.
+  if (!getTimeCacheComplete[uniqueRequestIdFieldName]
+    // || !getTimeCacheComplete[cacheCompleteFieldName]
+    || (getTimeCacheComplete[cacheCompleteFieldName]
+      && getTimeCacheComplete[cacheCompleteFieldName] !== timeCacheComplete
+      && getTimeCacheComplete[statusFieldName] != "complete")
+  ) {
+    return [false, getTimeCacheComplete[cacheCompleteFieldName]];
+  } else {
+    return [true, getTimeCacheComplete[cacheCompleteFieldName], getTimeCacheComplete[uniqueRequestIdFieldName]];
+  }
+
+
+}
+
+
+// ----- shared both stored cache and triggered cache, check uniqueRequestId changed ---------
+module.exports.checkCacheUniqueRequestId = async (
+  _izContext,
+  fullMainTableName,
+  keyValues,
+  checkUniqueRequestId,
+  uniqueRequestIdCompleteFieldName
+) => {
+
+  let cacheObject = await dynamodbSharedLib.getItem(
+    _izContext,
+    fullMainTableName,
+    keyValues
+  )
+  _izContext.logger.debug('cacheObject', cacheObject);
+
+  if (!cacheObject[uniqueRequestIdCompleteFieldName] || cacheObject[uniqueRequestIdCompleteFieldName] !== checkUniqueRequestId) {
+    return false
+  } else {
+    return true
+  }
+}
+
+
+
+
+
+
+// use shared findPendingStepIdsAwaitingStep
+// module.exports.findPendingStepIdsAwaitingStepM = async (
+//   _izContext,
+//   awaitingStepId,
+//   tableName = "AwaitingMultipleSteps"
+// ) => {
+
+//   let pendingStepIds = [];
+
+//   let listPendingStepIds = await dynamodbSharedLib.query(
+//     _izContext,
+//     dynamodbSharedLib.tableName(tableName),
+//     {
+//       awaitingStepId: awaitingStepId
+//     }
+//   );
+
+//   for (let idx = 0; idx < listPendingStepIds.Items.length; idx++) {
+//     pendingStepIds.push(listPendingStepIds.Items[idx].pendingStepId)
+//   }
+
+//   return pendingStepIds
+// }
+
+
+
+
+// use shared removeAwaitingStep
+// module.exports.removeAwaitingStep = async (
+//   _izContext,
+//   awaitingStepId,
+//   pendingStepId,
+//   tableName = "AwaitingMultipleSteps"
+// ) => {
+
+//   await dynamodbSharedLib.deleteItem(
+//     _izContext,
+//     dynamodbSharedLib.tableName(tableName),
+//     {
+//       awaitingStepId: awaitingStepId,
+//       pendingStepId: pendingStepId
+//     }
+//   );
+// }
+
+
+//====================================== end AwaitingMultipleSteps
+
+
+
+//====================================== end Multiple Lambda Invocations (Logic pagination of handling results)
+
+module.exports.validateStartKeyParam = (
+  _izContext,
+  startKey,
+  partitionKeyFieldName,
+  sortKeyFieldName = null
+) => {
+
+  if (startKey && Object.keys(startKey).length != 0) {
+    if (
+      startKey.constructor !== Object ||
+      !startKey[partitionKeyFieldName]
+    ) {
+      startKey = false; // we can type check for false to see if invalid
+    }
+    if (sortKeyFieldName !== null && sortKeyFieldName !== undefined && !startKey[sortKeyFieldName]) {
+      startKey = false;
+    }
+  } else {
+    startKey = null; // if empty set to null so lib functions process correctly (not want empty object)
+  }
+
+  return startKey;
+}
+
+
+module.exports.validateMultipleInvocations = async (
+  _izContext,
+  messageProperty,
+  passOnStartKey = {},
+  numberInvocation,
+  queueName
+) => {
+  _izContext.logger.debug("Lib:validateMultipleInvocations", {
+    messageProperty: messageProperty,
+    passOnStartKey: passOnStartKey,
+    numberInvocation: numberInvocation,
+    queueName: queueName
+  });
+  try {
+    const maxProcessInvocationCountImport = 20
+    if (numberInvocation >= maxProcessInvocationCountImport) {
+      _izContext.logger.error("numberInvocation exceeds maxProcessInvocationCountImport limit");
+      throw new NoRetryError("numberInvocation exceeds maxProcessInvocationCountImport limit");
+    };
+
+    if (passOnStartKey) {
+      messageProperty["startKey"] = passOnStartKey
+    };
+    messageProperty["numberInvocation"] = numberInvocation;
+
+    let messageReInvokeFunction = {
+      MessageBody: JSON.stringify(
+        messageProperty
+      ),
+      QueueUrl: await sqsSharedLib.sqsQueueUrl(_izContext, queueName)
+    };
+    _izContext.logger.debug(`Send mesage to Dsq:${queueName} `, messageReInvokeFunction);
+    await sqs.sendMessage(_izContext, messageReInvokeFunction);
+
+
+  } catch (err) {
+    throw (err)
+  }
+}