@izara_project/izara-core-library-dynamodb 1.0.13 → 1.0.14

package/src/DynamoDBSharedLib.js

@@ -34,7 +34,7 @@ const MAX_RECURSION_LEVEL = 20;
 const dynamodb = DynamoDBDocument.from(new DynamoDB(), {
   marshallOptions: {
     removeUndefinedValues: true
-  },
+  }
 });
 
 // Commented imports and alternatives
@@ -42,7 +42,6 @@ const dynamodb = DynamoDBDocument.from(new DynamoDB(), {
 // const dynamodb = DynamoDBDocument.from(new DynamoDB());
 // const dynamodb = require('@izara_project/izara-core-library-external-request').dynamodb
 
-
 /**
  * create table name
  * @param {Object} _izContext
@@ -67,21 +66,18 @@ function tableName(_izContext, tableName, serviceTag = null) {
  */
 function arrayToStringSet(stringSetArray) {
   try {
-
     // let stringSet = dynamodb.createSet(stringSetArray) // not need async/await
     let stringSet = new Set(stringSetArray);
     if (!stringSet) {
       throw new Error('Cannot create stringSet');
     }
     return stringSet;
-
   } catch (e) {
     console.error('error arrayToStringSet:', e);
-    throw (e);
+    throw e;
   }
 }
 
-
 /**
  * Marshalls StringSet from dynamo get/query into an array
  * @param {Object} stringSet
@@ -92,7 +88,6 @@ function stringSetToArray(stringSet) {
   return cloneDeep(stringSet.values);
 }
 
-
 function removeUndefined(attributes) {
   return unmarshall(marshall(attributes, { removeUndefinedValues: true }));
 }
@@ -104,14 +99,15 @@ function correlationIdValues(_izContext) {
   });
 }
 
-
 // ----- Helper function for reformConditionExpression
-function validateSideHand(logicalElement, prefixSide) { // helper function
+function validateSideHand(logicalElement, prefixSide) {
+  // helper function
   // _izContext.logger.debug('logicalElement in prefixSide', prefixSide);
 
   let checkSides = [];
   // check duplicated properties side (want to throw noRetry)
-  for (let side in logicalElement) { // method
+  for (let side in logicalElement) {
+    // method
     // _izContext.logger.debug('side ', side);
     // if ([`${prefixSide}Attribute`, `${prefixSide}Reference`, `${prefixSide}Value`].includes(side)) {
     if ([`${prefixSide}Attribute`, `${prefixSide}Reference`].includes(side)) {
@@ -119,7 +115,8 @@ function validateSideHand(logicalElement, prefixSide) { // helper function
     }
   }
 
-  if (checkSides.length == 1) { // if more than one will error
+  if (checkSides.length == 1) {
+    // if more than one will error
     let sideHandResult = logicalElement[checkSides[0]];
     // add : if side type is reference for ExpressionAttributeValues
     // NOTE not sure about Attribute, will pull values from exist data db
@@ -130,7 +127,9 @@ function validateSideHand(logicalElement, prefixSide) { // helper function
     }
     // ***** if side is "lhsReference" not logic to handle for now, so will be throw err *****
     else if (checkSides[0] == 'lhsReference') {
-      throw new NoRetryError(`"${checkSides[0]}" should not be set to Reference type for now!`);
+      throw new NoRetryError(
+        `"${checkSides[0]}" should not be set to Reference type for now!`
+      );
       // logicalElement[checkSides[0]] = '#' + logicalElement[checkSides[0]] // will add logic later
     }
     // if (checkSides[0].includes('Attribute')) {
@@ -139,23 +138,27 @@ function validateSideHand(logicalElement, prefixSide) { // helper function
 
     // return logicalElement[checkSides[0]] // return values eg. :product | product | 3
     return sideHandResult; // return values eg. :product | product | 3
-
   } else if (checkSides.length == 0) {
     throw new NoRetryError(`"${prefixSide}_" does not set!`);
-
   } else {
-    throw new NoRetryError(`"${prefixSide}" side-hand logic duplicated set, should set only one per side!`);
+    throw new NoRetryError(
+      `"${prefixSide}" side-hand logic duplicated set, should set only one per side!`
+    );
   }
-
-}; // end validateSideHand
+} // end validateSideHand
 
 // ----- Helper function for query dynamodb
 function reformConditionExpression(_izContext, queryElements) {
   // _izContext.logger.debug('queryElements', queryElements);
   // ----- add ConditionExpression to payload if queryElements has prop logicalElements
-  let conditionExpression, expressionAttributeValues = null;
+  let conditionExpression,
+    expressionAttributeValues = null;
   if (queryElements && queryElements.hasOwnProperty('logicalElements')) {
-    conditionExpression = processLogicalElements(_izContext, queryElements.logicalElements, 1);
+    conditionExpression = processLogicalElements(
+      _izContext,
+      queryElements.logicalElements,
+      1
+    );
   }
 
   // ----- add ExpressionAttributeValues to payload
@@ -165,7 +168,9 @@ function reformConditionExpression(_izContext, queryElements) {
     // change structure to syntax dynamo
     /*NOTE: handler function will be validate ExpressionAttributeValues by themself,
      that should will be in CondiEx and if not have CondiEx and we set ExAttr will be error */
-    for (let [propName, propVal] of Object.entries(queryElements.additionalAttributes)) {
+    for (let [propName, propVal] of Object.entries(
+      queryElements.additionalAttributes
+    )) {
       expressionAttributeValues[`:${propName}`] = propVal;
     }
   }
@@ -194,13 +199,18 @@ function processLogicalElements(_izContext, logicalElements, level) {
   */
 
   try {
-
     if (level > MAX_RECURSION_LEVEL) {
-      throw new Error(`exceeded maximum recursion level for property checks: ` + MAX_RECURSION_LEVEL);
+      throw new Error(
+        `exceeded maximum recursion level for property checks: ` +
+          MAX_RECURSION_LEVEL
+      );
     }
 
     let conditionalExpression = '';
-    _izContext.logger.debug('initial conditionalExpression :', conditionalExpression);
+    _izContext.logger.debug(
+      'initial conditionalExpression :',
+      conditionalExpression
+    );
     _izContext.logger.debug('initial logicalElements', logicalElements);
 
     // validate logicalElements is array before running resursion
@@ -220,42 +230,42 @@ function processLogicalElements(_izContext, logicalElements, level) {
     }
 
     // main looping check each logical element
-    for (const logicalElement of logicalElements) { // first-loop(outer)
+    for (const logicalElement of logicalElements) {
+      // first-loop(outer)
       // _izContext.logger.debug('logicalElement:', logicalElement);
 
       // -------- Check types: logical --------
 
       if (logicalElement.type == 'logical') {
         if (logicalElement.hasOwnProperty('comparison')) {
-
           // _izContext.logger.debug("I'm in logical comparison");
           let subConditionalExpression = null;
 
           let leftSide = validateSideHand(logicalElement, 'lhs'); //
 
           if (logicalElement.comparison == 'between') {
-            let betweenStartSide = validateSideHand(logicalElement, 'betweenStart');
+            let betweenStartSide = validateSideHand(
+              logicalElement,
+              'betweenStart'
+            );
             let betweenEndSide = validateSideHand(logicalElement, 'betweenEnd');
             // _izContext.logger.debug('betweenEndSide ff', betweenEndSide);
 
             subConditionalExpression = `${leftSide} between ${betweenStartSide} and ${betweenEndSide}`;
-
-          } else { // others comparison
+          } else {
+            // others comparison
 
             let rightSide = validateSideHand(logicalElement, 'rhs');
 
             if (logicalElement.comparison == 'equals') {
               // _izContext.logger.debug("I'm in equals comparison");
               subConditionalExpression = `${leftSide} = ${rightSide}`;
-
             } else if (logicalElement.comparison == 'notEquals') {
               // _izContext.logger.debug("I'm in notEquals comparison");
               subConditionalExpression = `${leftSide} <> ${rightSide}`;
-
             } else if (logicalElement.comparison == 'greaterThan') {
               // _izContext.logger.debug("I'm in greaterThan comparison");
               subConditionalExpression = `${leftSide} > ${rightSide}`;
-
             } else if (logicalElement.comparison == 'lessThan') {
               // _izContext.logger.debug("I'm in lessThan comparison");
               subConditionalExpression = `${leftSide} < ${rightSide}`;
@@ -268,9 +278,10 @@ function processLogicalElements(_izContext, logicalElements, level) {
 
           // conditionalExpression += subConditionalExpression; // close sub-group
           conditionalExpression += '(' + subConditionalExpression + ')'; // close sub-group // NEED TO SYNTAX
-
         } else {
-          throw new NoRetryError('Invalided "logical" type, logical type should have comparison.');
+          throw new NoRetryError(
+            'Invalided "logical" type, logical type should have comparison.'
+          );
         }
       }
 
@@ -283,11 +294,16 @@ function processLogicalElements(_izContext, logicalElements, level) {
             conditionalExpression += ' or ';
           } else if (logicalElement.operator.toLowerCase() == 'and') {
             conditionalExpression += ' and ';
-          } else { // and operator
-            throw new NoRetryError('logicalOperator invalided, should be or/and');
+          } else {
+            // and operator
+            throw new NoRetryError(
+              'logicalOperator invalided, should be or/and'
+            );
           }
         } else {
-          throw new NoRetryError('Invalided "operator" type, operator type should have logicalOperator.');
+          throw new NoRetryError(
+            'Invalided "operator" type, operator type should have logicalOperator.'
+          );
         }
       } // end logicalOperator
 
@@ -302,58 +318,81 @@ function processLogicalElements(_izContext, logicalElements, level) {
 
           // throw error if not have only one side.
           if (!logicalElement.hasOwnProperty('attribute')) {
-            throw new NoRetryError('side-hand logic Invalid, should set "attribute".');
+            throw new NoRetryError(
+              'side-hand logic Invalid, should set "attribute".'
+            );
           }
 
-          if (logicalElement.function.toLowerCase() == 'begins_with' || logicalElement.function.toLowerCase() == 'beginswith') {
+          if (
+            logicalElement.function.toLowerCase() == 'begins_with' ||
+            logicalElement.function.toLowerCase() == 'beginswith'
+          ) {
             let substr = validateSideHand(logicalElement, 'substr');
 
             conditionalExpression += `begins_with (${logicalElement.attribute}, ${substr})`;
-          }
-          else if (logicalElement.function.toLowerCase() == 'attribute_exists' || logicalElement.function.toLowerCase() == 'attributeexists') {
+          } else if (
+            logicalElement.function.toLowerCase() == 'attribute_exists' ||
+            logicalElement.function.toLowerCase() == 'attributeexists'
+          ) {
             conditionalExpression += `attribute_exists (${logicalElement.attribute})`;
-          }
-          else if (logicalElement.function.toLowerCase() == 'attribute_not_exists' || logicalElement.function.toLowerCase() == 'attributenotexists') {
+          } else if (
+            logicalElement.function.toLowerCase() == 'attribute_not_exists' ||
+            logicalElement.function.toLowerCase() == 'attributenotexists'
+          ) {
             conditionalExpression += `attribute_not_exists (${logicalElement.attribute})`;
           } else {
-            throw new NoRetryError('Invalided "function" type, function type should be begins_with/ attribute_exists/ attribute_not_exists .');
+            throw new NoRetryError(
+              'Invalided "function" type, function type should be begins_with/ attribute_exists/ attribute_not_exists .'
+            );
           }
-
         } else {
-          throw new NoRetryError('Invalided "function" type, function type should have function.');
+          throw new NoRetryError(
+            'Invalided "function" type, function type should have function.'
+          );
         }
       } // end function
 
       // ----- Check types: group []( need to recursed) -----
       else if (logicalElement.type == 'group') {
-        if (logicalElement.hasOwnProperty('elements') && Array.isArray(logicalElement.elements) && logicalElement.elements.length != 0) {
+        if (
+          logicalElement.hasOwnProperty('elements') &&
+          Array.isArray(logicalElement.elements) &&
+          logicalElement.elements.length != 0
+        ) {
           // _izContext.logger.debug("I'm going in recursion");
 
           conditionalExpression += '(';
-          conditionalExpression += processLogicalElements(_izContext, logicalElement.elements, level + 1); // ***recursion***
+          conditionalExpression += processLogicalElements(
+            _izContext,
+            logicalElement.elements,
+            level + 1
+          ); // ***recursion***
           conditionalExpression += ')'; // close sub-group
-
-        } else { // end group types
-          throw new NoRetryError('Invalided "group" type, group type should have property elements[].');
+        } else {
+          // end group types
+          throw new NoRetryError(
+            'Invalided "group" type, group type should have property elements[].'
+          );
         }
       }
 
       // -----  end check all types -----
-      else { // Out of types, error
-        throw new NoRetryError('Invalided config "type", logicalElement type should be "logical", "logicalOperator" or "group".');
+      else {
+        // Out of types, error
+        throw new NoRetryError(
+          'Invalided config "type", logicalElement type should be "logical", "logicalOperator" or "group".'
+        );
       }
-
     } // end loop logicalElement
 
     // _izContext.logger.debug('conditionalExpression before return:', conditionalExpression);
     return conditionalExpression;
-
-  } catch (err) { // just catch for debug not create new error
+  } catch (err) {
+    // just catch for debug not create new error
     console.warn('unhandled error', err);
     throw err;
   }
-}; // module processLogicalElements
-
+} // module processLogicalElements
 
 /**
  * Executes a GetItem query to DynamoDB
@@ -366,10 +405,15 @@ function processLogicalElements(_izContext, logicalElements, level) {
  *
  * @returns {object} single record return value from the query, or Null if none found
  */
-async function getItem(_izContext, tableName, keyValues, queryElements = {}, settings = {}) {
-
+async function getItem(
+  _izContext,
+  tableName,
+  keyValues,
+  queryElements = {},
+  settings = {}
+) {
   try {
-    console.log("getItems: ", {
+    console.log('getItems: ', {
       tableName,
       keyValues,
       queryElements,
@@ -379,44 +423,60 @@ async function getItem(_izContext, tableName, keyValues, queryElements = {}, set
     let payload = {
       TableName: tableName,
       Key: keyValues,
-      ReturnConsumedCapacity: "TOTAL" // NONE(default) | TOTAL | INDEXES
+      ReturnConsumedCapacity: 'TOTAL' // NONE(default) | TOTAL | INDEXES
     };
 
     // if (queryElements) { // add queryElements to payload if exist
     // NOTE: getItem NOT supported for GSI/LSI
-    if (queryElements && queryElements.constructor === Object && Object.keys(queryElements).length != 0) { // varidate object not null, not empty, and is object.
+    if (
+      queryElements &&
+      queryElements.constructor === Object &&
+      Object.keys(queryElements).length != 0
+    ) {
+      // varidate object not null, not empty, and is object.
       for (const element in queryElements) {
         //waiting for use case...
         // payload[element] = queryElements[element]
       }
     }
-    _izContext.logger.debug("payload before get items", payload);
+    _izContext.logger.debug('payload before get items', payload);
 
     const getItem = await dynamodb.get(payload); // ===== main query
 
     // const getItem = await izaraDynamodb.get(payload).promise(); // ===== main query
 
     // if record not found Null will be returned unless errorOnNoRecordFound set to true which will throw error
-    if (!getItem.Item) { // if return undefined (NOTE---dynamodb will return .Item value or Item undifined)
-      if (settings && settings.hasOwnProperty('errorOnNoRecordFound') && settings.errorOnNoRecordFound == true) {
-        if (settings.hasOwnProperty('retryOnErrorNoRecordFound') && settings.retryOnErrorNoRecordFound == true) {
+    if (!getItem.Item) {
+      // if return undefined (NOTE---dynamodb will return .Item value or Item undifined)
+      if (
+        settings &&
+        settings.hasOwnProperty('errorOnNoRecordFound') &&
+        settings.errorOnNoRecordFound == true
+      ) {
+        if (
+          settings.hasOwnProperty('retryOnErrorNoRecordFound') &&
+          settings.retryOnErrorNoRecordFound == true
+        ) {
           throw new Error('retryOnErrorNoRecordFound'); // TT
         }
         throw new NoRetryError('errorOnNoRecordFound', payload); // TF
       }
       return null; // FF
     } else {
-      await captureCapacityUsed(_izContext, getItem.ConsumedCapacity, 'read', 'get');
+      await captureCapacityUsed(
+        _izContext,
+        getItem.ConsumedCapacity,
+        'read',
+        'get'
+      );
     }
 
     return getItem.Item; // retuen Item, beware some function get value and use get.Item
-
   } catch (err) {
     console.warn('warning', err);
     throw err;
   }
-}; // end module getItem
-
+} // end module getItem
 
 /**
  * Executes a Query on DynamoDB
@@ -435,26 +495,38 @@ async function getItem(_izContext, tableName, keyValues, queryElements = {}, set
  *
  * @returns {object[], object} array of records from .Items in query result, and queryInfo object with properties such as LastEvaluatedKey
  */
-async function query(_izContext, tableName, partitionKeyValue, queryElements = {}, settings = {}) {
-
+async function query(
+  _izContext,
+  tableName,
+  partitionKeyValue,
+  queryElements = {},
+  settings = {}
+) {
   try {
-
     // validate partitionKeyValue, should have only one?
-    if (typeof partitionKeyValue !== 'object' || Object.keys(partitionKeyValue).length !== 1) {
+    if (
+      typeof partitionKeyValue !== 'object' ||
+      Object.keys(partitionKeyValue).length !== 1
+    ) {
       throw new NoRetryError('partitionKeyValue should be "object" type.');
     }
 
-    let attributeReservedNames = ['partitionKeyValue', 'betweenStartValue', 'betweenEndValue'];
+    let attributeReservedNames = [
+      'partitionKeyValue',
+      'betweenStartValue',
+      'betweenEndValue'
+    ];
 
     // ------------ set payload ---------------
     let payload = {
       TableName: tableName, // require
       // KeyConditionExpression: '',
       KeyConditionExpression: `${Object.keys(partitionKeyValue)[0]} = :partitionKeyValue`, // require partition key
-      ExpressionAttributeValues: {},  // require  value of partition key
-      ReturnConsumedCapacity: "TOTAL" // NONE(default) | TOTAL | INDEXES
+      ExpressionAttributeValues: {}, // require  value of partition key
+      ReturnConsumedCapacity: 'TOTAL' // NONE(default) | TOTAL | INDEXES
     };
-    payload.ExpressionAttributeValues[`:partitionKeyValue`] = partitionKeyValue[Object.keys(partitionKeyValue)[0]];
+    payload.ExpressionAttributeValues[`:partitionKeyValue`] =
+      partitionKeyValue[Object.keys(partitionKeyValue)[0]];
 
     // ---- sortKeyCondition ----
     /* NOTE: KeyConditionExpression
@@ -474,7 +546,9 @@ async function query(_izContext, tableName, partitionKeyValue, queryElements = {
       if (queryElements.sortKeyCondition.hasOwnProperty('comparison')) {
         //validate sortKeyCondition
         if (typeof queryElements.sortKeyCondition.comparison !== 'string') {
-          throw new NoRetryError('comparison set in sortKeyCondition but type is not string');
+          throw new NoRetryError(
+            'comparison set in sortKeyCondition but type is not string'
+          );
         }
         if (!queryElements.sortKeyCondition.name) {
           throw new NoRetryError('sortKeyCondition name property is required');
@@ -492,79 +566,110 @@ async function query(_izContext, tableName, partitionKeyValue, queryElements = {
           // }
           // sortKeyName BETWEEN :sortkeyval1 AND :sortkeyval2
           payload.KeyConditionExpression += `${queryElements.sortKeyCondition.name} BETWEEN :betweenStartValue AND :betweenEndValue`;
-          payload.ExpressionAttributeValues[`:betweenStartValue`] = queryElements.sortKeyCondition.betweenStartValue;
-          payload.ExpressionAttributeValues[`:betweenEndValue`] = queryElements.sortKeyCondition.betweenEndValue;
-
-
-        } else { // others comparisons eg. < > <> = , has one side-hand
+          payload.ExpressionAttributeValues[`:betweenStartValue`] =
+            queryElements.sortKeyCondition.betweenStartValue;
+          payload.ExpressionAttributeValues[`:betweenEndValue`] =
+            queryElements.sortKeyCondition.betweenEndValue;
+        } else {
+          // others comparisons eg. < > <> = , has one side-hand
 
           // check does not use attributeReservedNames
-          if (attributeReservedNames.includes(queryElements.sortKeyCondition.name)) {
-            throw new NoRetryError(`sortKeyCondition.name cannot be a attributeReservedName (${queryElements.sortKeyCondition.name})`);
-          };
+          if (
+            attributeReservedNames.includes(queryElements.sortKeyCondition.name)
+          ) {
+            throw new NoRetryError(
+              `sortKeyCondition.name cannot be a attributeReservedName (${queryElements.sortKeyCondition.name})`
+            );
+          }
 
           let subKeyConditionalExpression = null;
-          if (queryElements.sortKeyCondition.comparison == 'begins_with') { // begins_with ( sortKeyName, :sortkeyval ) ***CANNOT USE WITH NUMBER TYPE
+          if (queryElements.sortKeyCondition.comparison == 'begins_with') {
+            // begins_with ( sortKeyName, :sortkeyval ) ***CANNOT USE WITH NUMBER TYPE
             if (typeof queryElements.sortKeyCondition.value !== 'string') {
               // throw new NoRetryError('begins_with operand "value" required the string to search for.')
               // queryElements.sortKeyCondition.value = Number(queryElements.sortKeyCondition.value)
-              queryElements.sortKeyCondition.value = String(queryElements.sortKeyCondition.value); /// if not string ???
+              queryElements.sortKeyCondition.value = String(
+                queryElements.sortKeyCondition.value
+              ); /// if not string ???
             }
             subKeyConditionalExpression = `begins_with ( ${queryElements.sortKeyCondition.name}, :${queryElements.sortKeyCondition.name} )`;
-          }
-          else if (queryElements.sortKeyCondition.comparison == 'equals') { // sortKeyName = :sortkeyval
+          } else if (queryElements.sortKeyCondition.comparison == 'equals') {
+            // sortKeyName = :sortkeyval
             subKeyConditionalExpression = `${queryElements.sortKeyCondition.name} = :${queryElements.sortKeyCondition.name}`;
-          }
-          else if (queryElements.sortKeyCondition.comparison == 'notEquals') {
+          } else if (queryElements.sortKeyCondition.comparison == 'notEquals') {
             subKeyConditionalExpression = `${queryElements.sortKeyCondition.name} <> :${queryElements.sortKeyCondition.name}`;
-          }
-          else if (queryElements.sortKeyCondition.comparison == 'greaterThan') {
+          } else if (
+            queryElements.sortKeyCondition.comparison == 'greaterThan'
+          ) {
             subKeyConditionalExpression = `${queryElements.sortKeyCondition.name} > :${queryElements.sortKeyCondition.name}`;
-          }
-          else if (queryElements.sortKeyCondition.comparison == 'lessThan') {
+          } else if (queryElements.sortKeyCondition.comparison == 'lessThan') {
             subKeyConditionalExpression = `${queryElements.sortKeyCondition.name} < :${queryElements.sortKeyCondition.name}`;
-          }
-          else if (queryElements.sortKeyCondition.comparison == 'lessThanOrEqual') {
+          } else if (
+            queryElements.sortKeyCondition.comparison == 'lessThanOrEqual'
+          ) {
             subKeyConditionalExpression = `${queryElements.sortKeyCondition.name} <= :${queryElements.sortKeyCondition.name}`;
-          }
-          else if (queryElements.sortKeyCondition.comparison == 'greaterThanOrEqual') {
+          } else if (
+            queryElements.sortKeyCondition.comparison == 'greaterThanOrEqual'
+          ) {
             subKeyConditionalExpression = `${queryElements.sortKeyCondition.name} >= :${queryElements.sortKeyCondition.name}`;
           } else {
             //unrecognised comparison
-            throw new NoRetryError('Unrecognised comparison in sortKeyCondition ' + queryElements.sortKeyCondition.comparison);
+            throw new NoRetryError(
+              'Unrecognised comparison in sortKeyCondition ' +
+                queryElements.sortKeyCondition.comparison
+            );
           }
 
           payload.KeyConditionExpression += subKeyConditionalExpression;
-          payload.ExpressionAttributeValues[`:${queryElements.sortKeyCondition.name}`] = queryElements.sortKeyCondition.value;
-
-        }; // end all comparisons
+          payload.ExpressionAttributeValues[
+            `:${queryElements.sortKeyCondition.name}`
+          ] = queryElements.sortKeyCondition.value;
+        } // end all comparisons
       } else {
-        throw new NoRetryError('sortKeyCondition should have "comparison" property.');
+        throw new NoRetryError(
+          'sortKeyCondition should have "comparison" property.'
+        );
       }
     } // end sortKeyCondition
 
     // NOTE ***** we need to choose projectionExpression or select, not both! *****
-    if (queryElements.projectionExpression && queryElements.select != 'SPECIFIC_ATTRIBUTES') {
-      throw new NoRetryError('invalid setting, choose projectionExpression or select, or set projectionExpression with select is "SPECIFIC_ATTRIBUTES" ');
+    if (
+      queryElements.projectionExpression &&
+      queryElements.select != 'SPECIFIC_ATTRIBUTES'
+    ) {
+      throw new NoRetryError(
+        'invalid setting, choose projectionExpression or select, or set projectionExpression with select is "SPECIFIC_ATTRIBUTES" '
+      );
     }
 
     // ---- projectionExpression : Return the specific attribute that we want ----
     // projection-expression "Description, RelatedItems[0], ProductReviews.FiveStar"
-    if (queryElements.projectionExpression && Array.isArray(queryElements.projectionExpression) && queryElements.projectionExpression.length !== 0) {
-      payload.ProjectionExpression = queryElements.projectionExpression.join(', ');
+    if (
+      queryElements.projectionExpression &&
+      Array.isArray(queryElements.projectionExpression) &&
+      queryElements.projectionExpression.length !== 0
+    ) {
+      payload.ProjectionExpression =
+        queryElements.projectionExpression.join(', ');
     }
 
     // ---- select : Return the specific item attributes, the count of matching items, or in the case of an index----
-    if (queryElements.select) { // ALL_ATTRIBUTES | ALL_PROJECTED_ATTRIBUTES | COUNT
+    if (queryElements.select) {
+      // ALL_ATTRIBUTES | ALL_PROJECTED_ATTRIBUTES | COUNT
 
       _izContext.logger.debug('queryElements.select', queryElements.select);
       queryElements.select = queryElements.select.toUpperCase();
-      if (queryElements.select == 'ALL_ATTRIBUTES' || queryElements.select == 'ALL_PROJECTED_ATTRIBUTES'
-        || queryElements.select == 'COUNT' || queryElements.select == 'SPECIFIC_ATTRIBUTES'
+      if (
+        queryElements.select == 'ALL_ATTRIBUTES' ||
+        queryElements.select == 'ALL_PROJECTED_ATTRIBUTES' ||
+        queryElements.select == 'COUNT' ||
+        queryElements.select == 'SPECIFIC_ATTRIBUTES'
       ) {
         payload.Select = queryElements.select;
       } else {
-        throw new NoRetryError('select invalid, should be "ALL_ATTRIBUTES" | "ALL_PROJECTED_ATTRIBUTES" | "COUNT" | "SPECIFIC_ATTRIBUTES".');
+        throw new NoRetryError(
+          'select invalid, should be "ALL_ATTRIBUTES" | "ALL_PROJECTED_ATTRIBUTES" | "COUNT" | "SPECIFIC_ATTRIBUTES".'
+        );
       }
     }
 
@@ -601,27 +706,41 @@ async function query(_izContext, tableName, partitionKeyValue, queryElements = {
     _izContext.logger.debug('payload before query', payload);
 
     // ---- numPagesToRequest default = 1 page(hit limit at 1 Mb per page)
-    if (!settings.hasOwnProperty('numPagesToRequest') || settings.numPagesToRequest == 1) {
+    if (
+      !settings.hasOwnProperty('numPagesToRequest') ||
+      settings.numPagesToRequest == 1
+    ) {
       // main query if not set numPagesToRequest, default is 1 page.
       _izContext.logger.debug('CASE: numPagesToRequest = 1');
 
       const returnValue = await dynamodb.query(payload);
-      _izContext.logger.debug("query status: ", returnValue['$metadata']);
-      await captureCapacityUsed(_izContext, returnValue.ConsumedCapacity, 'read', 'query');
+      _izContext.logger.debug('query status: ', returnValue['$metadata']);
+      await captureCapacityUsed(
+        _izContext,
+        returnValue.ConsumedCapacity,
+        'read',
+        'query'
+      );
       return returnValue; // return in syntax dynamodb
-    } else { // *** require numPagesToRequest
+    } else {
+      // *** require numPagesToRequest
       _izContext.logger.debug('CASE: numPagesToRequest > 1');
 
       // ---- ExclusiveStartKey and Pagination ----
-      const getAllData = async (payload) => {
+      const getAllData = async payload => {
         const _getAllData = async (payload, startKey) => {
           if (startKey) {
             payload.ExclusiveStartKey = startKey; // if LastEvaluatedKey existing
           }
           queryPage++;
           let data = dynamodb.query(payload); // ---- main query
-          _izContext.logger.debug("query status: ", data['$metadata']);
-          await captureCapacityUsed(_izContext, data.ConsumedCapacity, 'read', 'query');
+          _izContext.logger.debug('query status: ', data['$metadata']);
+          await captureCapacityUsed(
+            _izContext,
+            data.ConsumedCapacity,
+            'read',
+            'query'
+          );
           return data;
         };
 
@@ -633,7 +752,8 @@ async function query(_izContext, tableName, partitionKeyValue, queryElements = {
         let count = 0;
         let scannedCount = 0;
 
-        do { // execute block do before check condition in first time, if condition true do it again and again.
+        do {
+          // execute block do before check condition in first time, if condition true do it again and again.
           const result = await _getAllData(payload, lastEvaluatedKey); // call function
           // _izContext.logger.debug('result: ', result);
           // _izContext.logger.debug('queryPage: ', queryPage);
@@ -644,15 +764,19 @@ async function query(_izContext, tableName, partitionKeyValue, queryElements = {
           lastEvaluatedKey = result.LastEvaluatedKey; // replace LastEvaluatedKey for check condiion
           lastEvaluatedKeyReturnValue = result.LastEvaluatedKey;
 
-          if (result.hasOwnProperty('Items')) { // will be work with select setting
+          if (result.hasOwnProperty('Items')) {
+            // will be work with select setting
             rows = rows.concat(result.Items); // need to concat array, cannot use push(will be nested array)
           }
-          if (queryPage >= settings.numPagesToRequest) { // if set numPagesToRequest, limit query = numPagesToRequest will stop query
+          if (queryPage >= settings.numPagesToRequest) {
+            // if set numPagesToRequest, limit query = numPagesToRequest will stop query
             lastEvaluatedKey = null; // out of loop, set condition is false
           }
 
           if (queryPage === 1000) {
-            throw new NoRetryError('too many paginated database results, 1000 limit reached, stopped execution in dynamodb.query');
+            throw new NoRetryError(
+              'too many paginated database results, 1000 limit reached, stopped execution in dynamodb.query'
+            );
           }
         } while (lastEvaluatedKey); // check condition after do block
         return {
@@ -668,10 +792,7 @@ async function query(_izContext, tableName, partitionKeyValue, queryElements = {
     _izContext.logger.warn('warning', err);
     throw new Error('Unhandled Error, query: ', err);
   }
-};
-
-
-
+}
 
 /**
  * Executes a Query on DynamoDB and get only Items
@@ -688,8 +809,13 @@ async function query(_izContext, tableName, partitionKeyValue, queryElements = {
  *
  * @returns {object[], object} array of records from .Items in query result, and queryInfo object with properties such as LastEvaluatedKey
  */
-async function queryResults(_izContext, tableName, partitionKeyValue, queryElements = {}, settings = {}) {
-
+async function queryResults(
+  _izContext,
+  tableName,
+  partitionKeyValue,
+  queryElements = {},
+  settings = {}
+) {
   const queryResults = await query(
     _izContext,
     tableName,
@@ -698,9 +824,7 @@ async function queryResults(_izContext, tableName, partitionKeyValue, queryEleme
     settings
   );
   return queryResults.Items;
-};
-
-
+}
 
 /**
  * Executes a PutItem query on DynamoDB
@@ -735,60 +859,76 @@ async function putItem(
       TableName: tableName,
       Item: {}, // Item: attributes,
       ReturnValues: 'NONE', // NONE(default) | ALL_OLD
-      ReturnConsumedCapacity: "TOTAL" // NONE(default) | TOTAL | INDEXES
+      ReturnConsumedCapacity: 'TOTAL' // NONE(default) | TOTAL | INDEXES
     };
 
     // set payload: ReturnValues
-    if (queryElements.hasOwnProperty('returnValues') && queryElements.returnValues.toLocaleUpperCase() == 'ALL_OLD') {
+    if (
+      queryElements.hasOwnProperty('returnValues') &&
+      queryElements.returnValues.toLocaleUpperCase() == 'ALL_OLD'
+    ) {
       payload.ReturnValues = queryElements.returnValues.toLocaleUpperCase();
     }
     // set payload: ConditionExpression and/or ExpressionAttributeValues
-    const [conditionExpression, expressionAttributeValues] = reformConditionExpression(_izContext, queryElements);
+    const [conditionExpression, expressionAttributeValues] =
+      reformConditionExpression(_izContext, queryElements);
     if (conditionExpression) payload.ConditionExpression = conditionExpression;
-    if (expressionAttributeValues) payload.ExpressionAttributeValues = expressionAttributeValues;
+    if (expressionAttributeValues)
+      payload.ExpressionAttributeValues = expressionAttributeValues;
 
     _izContext.logger.debug('conditionExpression', payload.ConditionExpression);
-    _izContext.logger.debug('expressionAttributeValues', payload.ExpressionAttributeValues);
+    _izContext.logger.debug(
+      'expressionAttributeValues',
+      payload.ExpressionAttributeValues
+    );
 
     // ckeck complexAttributes and validate attributes
     if (settings.complexAttributes) {
       if (Array.isArray(attributes) && attributes.length !== 0) {
-
         // -- add _izContext to attributes
         attributes.push({
-          attributeName: "izContext",
+          attributeName: 'izContext',
           value: correlationIdValues(_izContext)
         });
 
         // for (let idx = 0; idx < attributes.length; idx++) { // for loop more performance than for of
         for (let idx = 0, len = attributes.length; idx < len; idx++) {
-          if (attributes[idx].action.toUpperCase() !== 'REMOVE' && attributes[idx].value === undefined) {
+          if (
+            attributes[idx].action.toUpperCase() !== 'REMOVE' &&
+            attributes[idx].value === undefined
+          ) {
             continue;
           }
 
           // _izContext.logger.debug('attributes[idx]', attributes[idx]);
           // if stringSet >> createStringSet >> put
           if (attributes[idx].isStringSet) {
-
-            if (!Array.isArray(attributes[idx].value) || attributes[idx].value.length === 0) { // validate attributes value
-              throw new NoRetryError('attributes value should be array and not empty.');
+            if (
+              !Array.isArray(attributes[idx].value) ||
+              attributes[idx].value.length === 0
+            ) {
+              // validate attributes value
+              throw new NoRetryError(
+                'attributes value should be array and not empty.'
+              );
             }
             attributes[idx].value = arrayToStringSet(attributes[idx].value);
           }
-          payload.Item[`${attributes[idx].attributeName}`] = attributes[idx].value;
-
-        }// end for loop
+          payload.Item[`${attributes[idx].attributeName}`] =
+            attributes[idx].value;
+        } // end for loop
       } else {
-        throw new NoRetryError('complexAttributes setting is true, attributes should be array and not empty.');
+        throw new NoRetryError(
+          'complexAttributes setting is true, attributes should be array and not empty.'
+        );
       }
-
-    } else { // if not set (default), will attributes keyVslue to Item
+    } else {
+      // if not set (default), will attributes keyVslue to Item
       _izContext.logger.debug('payload complex is false', payload);
 
       // payload.Item = attributes
       payload.Item = removeUndefined(attributes);
-      payload.Item["izContext"] = correlationIdValues(_izContext);
-
+      payload.Item['izContext'] = correlationIdValues(_izContext);
     }
 
     _izContext.logger.debug('payload before putItem', payload);
@@ -802,38 +942,51 @@ async function putItem(
         return payload; // stop process in here not send to dymanodb
       }
 
-      const returnValue = await dynamodb.put(payload);  // ---- main query
-      _izContext.logger.debug("putItem status: ", returnValue['$metadata']);
-      await captureCapacityUsed(_izContext, returnValue.ConsumedCapacity, 'write', 'put');
+      const returnValue = await dynamodb.put(payload); // ---- main query
+      _izContext.logger.debug('putItem status: ', returnValue['$metadata']);
+      await captureCapacityUsed(
+        _izContext,
+        returnValue.ConsumedCapacity,
+        'write',
+        'put'
+      );
       if (payload.ReturnValues !== 'NONE' && returnValue.Attributes) {
         return returnValue.Attributes;
       }
-
-    } catch (err) { // catch error when put and handle errors.
+    } catch (err) {
+      // catch error when put and handle errors.
 
       _izContext.logger.debug('err', err);
-      if (err.name == 'ConditionalCheckFailedException') { // if return undefined (NOTE---dynamodb will return .Item value or Item undifined)
-        if (settings && settings.hasOwnProperty('errorOnConditionalExpNotPass') && settings.errorOnConditionalExpNotPass == true) {
-          if (settings.hasOwnProperty('retryOnErrorConditionalExpNotPass') && settings.retryOnErrorConditionalExpNotPass == true) {
+      if (err.name == 'ConditionalCheckFailedException') {
+        // if return undefined (NOTE---dynamodb will return .Item value or Item undifined)
+        if (
+          settings &&
+          settings.hasOwnProperty('errorOnConditionalExpNotPass') &&
+          settings.errorOnConditionalExpNotPass == true
+        ) {
+          if (
+            settings.hasOwnProperty('retryOnErrorConditionalExpNotPass') &&
+            settings.retryOnErrorConditionalExpNotPass == true
+          ) {
             console.error(err.name + ': ' + err.message);
             throw new Error('ConditionalExpNotPass'); // TT, if throw will stop
           }
           console.error(err.name + ': ' + err.message);
           throw new NoRetryError('ConditionalExpNotPass'); // TF
         }
-      } else { // e.g. ProvisionedThroughputExceededException
+      } else {
+        // e.g. ProvisionedThroughputExceededException
         // throw new Error('Unhandled Error when putItem', err) // TT, if throw will stop
-        throw (err); // TT, if throw will stop
+        throw err; // TT, if throw will stop
       }
     } //end catch err
-
-  } catch (err) { // catch unhandled error
+  } catch (err) {
+    // catch unhandled error
     console.log('err', err);
     _izContext.logger.error(err.name + ': ' + err.message);
     throw err; // TT, if throw will stop
   }
-}; // end module putItem
-
+} // end module putItem
 
 /**
  * Updates an item in DynamoDB (simple or complex mode).
@@ -875,7 +1028,9 @@ async function updateItem(
   queryElements,
   settings
 ) {
-  _izContext.logger.debug('iam in updateItem', { queryElements: queryElements });
+  _izContext.logger.debug('iam in updateItem', {
+    queryElements: queryElements
+  });
 
   try {
     if (!queryElements) {
@@ -887,12 +1042,12 @@ async function updateItem(
 
     // --- initial payload
     let payload = {
-      TableName: tableName,              // required
-      Key: keyValues,                    // required
-      UpdateExpression: '',              // will be built later
-      ExpressionAttributeValues: {},     // placeholders for update/condition values
-      ReturnValues: 'NONE',              // NONE | ALL_OLD | UPDATED_OLD | ALL_NEW | UPDATED_NEW
-      ReturnConsumedCapacity: 'TOTAL'    // NONE(default) | TOTAL | INDEXES
+      TableName: tableName, // required
+      Key: keyValues, // required
+      UpdateExpression: '', // will be built later
+      ExpressionAttributeValues: {}, // placeholders for update/condition values
+      ReturnValues: 'NONE', // NONE | ALL_OLD | UPDATED_OLD | ALL_NEW | UPDATED_NEW
+      ReturnConsumedCapacity: 'TOTAL' // NONE(default) | TOTAL | INDEXES
     };
 
     // optional ReturnValues override
@@ -912,7 +1067,8 @@ async function updateItem(
     // ----- merge ConditionExpression + names/values from queryElements (primary path)
     const merged = reformConditionExpression(_izContext, queryElements);
     const conditionExpression = merged && merged[0] ? merged[0] : '';
-    const expressionAttributeValuesFromCE = merged && merged[1] ? merged[1] : null;
+    const expressionAttributeValuesFromCE =
+      merged && merged[1] ? merged[1] : null;
 
     if (conditionExpression) {
       payload.ConditionExpression = conditionExpression;
@@ -922,7 +1078,10 @@ async function updateItem(
     if (
       !payload.ConditionExpression &&
       queryElements &&
-      Object.prototype.hasOwnProperty.call(queryElements, 'conditionExpression') &&
+      Object.prototype.hasOwnProperty.call(
+        queryElements,
+        'conditionExpression'
+      ) &&
       queryElements.conditionExpression
     ) {
       payload.ConditionExpression = String(queryElements.conditionExpression);
@@ -935,11 +1094,17 @@ async function updateItem(
         const k = entriesCE[i][0];
         const v = entriesCE[i][1];
         if (
-          Object.prototype.hasOwnProperty.call(payload.ExpressionAttributeValues, k) &&
-          JSON.stringify(payload.ExpressionAttributeValues[k]) !== JSON.stringify(v)
+          Object.prototype.hasOwnProperty.call(
+            payload.ExpressionAttributeValues,
+            k
+          ) &&
+          JSON.stringify(payload.ExpressionAttributeValues[k]) !==
+            JSON.stringify(v)
         ) {
           throw new NoRetryError(
-            'Placeholder ' + k + ' duplicated with different value (from ConditionExpression merge).'
+            'Placeholder ' +
+              k +
+              ' duplicated with different value (from ConditionExpression merge).'
           );
         }
         payload.ExpressionAttributeValues[k] = v;
@@ -962,11 +1127,17 @@ async function updateItem(
         const k = entriesQE[i][0];
         const v = entriesQE[i][1];
         if (
-          Object.prototype.hasOwnProperty.call(payload.ExpressionAttributeValues, k) &&
-          JSON.stringify(payload.ExpressionAttributeValues[k]) !== JSON.stringify(v)
+          Object.prototype.hasOwnProperty.call(
+            payload.ExpressionAttributeValues,
+            k
+          ) &&
+          JSON.stringify(payload.ExpressionAttributeValues[k]) !==
+            JSON.stringify(v)
         ) {
           throw new NoRetryError(
-            'Placeholder ' + k + ' duplicated with different value (from queryElements merge).'
+            'Placeholder ' +
+              k +
+              ' duplicated with different value (from queryElements merge).'
           );
         }
         payload.ExpressionAttributeValues[k] = v;
@@ -977,8 +1148,10 @@ async function updateItem(
        1) Group expressions by action (SET/REMOVE/ADD/DELETE)
        2) Build UpdateExpression in fixed order: SET → REMOVE → ADD → DELETE
     */
-    if (Object.prototype.hasOwnProperty.call(settings, 'complexAttributes') &&
-      settings.complexAttributes === true) {
+    if (
+      Object.prototype.hasOwnProperty.call(settings, 'complexAttributes') &&
+      settings.complexAttributes === true
+    ) {
       if (Array.isArray(attributes) && attributes.length !== 0) {
         // always include izContext as SET
         attributes.push({
@@ -994,22 +1167,37 @@ async function updateItem(
 
           // default action is SET
           let action = 'SET';
-          if (Object.prototype.hasOwnProperty.call(item, 'action') && item.action) {
+          if (
+            Object.prototype.hasOwnProperty.call(item, 'action') &&
+            item.action
+          ) {
             action = String(item.action).toUpperCase();
           }
 
           // skip non-REMOVE entries that have no value or valueReference
-          if (action !== 'REMOVE' &&
+          if (
+            action !== 'REMOVE' &&
             !Object.prototype.hasOwnProperty.call(item, 'value') &&
-            !Object.prototype.hasOwnProperty.call(item, 'valueReference')) {
+            !Object.prototype.hasOwnProperty.call(item, 'valueReference')
+          ) {
             continue;
           }
 
-          if (action !== 'SET' && action !== 'REMOVE' && action !== 'ADD' && action !== 'DELETE') {
-            throw new NoRetryError('"action" should be one of: set | remove | add | delete');
+          if (
+            action !== 'SET' &&
+            action !== 'REMOVE' &&
+            action !== 'ADD' &&
+            action !== 'DELETE'
+          ) {
+            throw new NoRetryError(
+              '"action" should be one of: set | remove | add | delete'
+            );
           }
 
-          const valueReference = Object.prototype.hasOwnProperty.call(item, 'valueReference')
+          const valueReference = Object.prototype.hasOwnProperty.call(
+            item,
+            'valueReference'
+          )
             ? item.valueReference
             : item.attributeName;
 
@@ -1017,77 +1205,115 @@ async function updateItem(
           let addSide = null;
           let subtractSide = null;
 
-          try { addSide = validateSideHand(item, 'add'); } catch (e1) { }
-          try { subtractSide = validateSideHand(item, 'subtract'); } catch (e2) { }
+          try {
+            addSide = validateSideHand(item, 'add');
+          } catch (e1) {}
+          try {
+            subtractSide = validateSideHand(item, 'subtract');
+          } catch (e2) {}
 
           // listAppend/add/subtract must only be used with SET
-          if ((Object.prototype.hasOwnProperty.call(item, 'listAppend') && item.listAppend === true) ||
-            addSide || subtractSide) {
+          if (
+            (Object.prototype.hasOwnProperty.call(item, 'listAppend') &&
+              item.listAppend === true) ||
+            addSide ||
+            subtractSide
+          ) {
             if (action !== 'SET') {
               throw new NoRetryError(
-                JSON.stringify(item) + ': listAppend / add_ / subtract_ must be used with "SET" action.'
+                JSON.stringify(item) +
+                  ': listAppend / add_ / subtract_ must be used with "SET" action.'
               );
             }
           }
 
           // build expression
-          if (Object.prototype.hasOwnProperty.call(item, 'listAppend') && item.listAppend === true) {
+          if (
+            Object.prototype.hasOwnProperty.call(item, 'listAppend') &&
+            item.listAppend === true
+          ) {
             if (!Array.isArray(item.value)) {
               throw new NoRetryError('listAppend value must be an array.');
             }
             expression =
               item.attributeName +
-              ' = list_append(if_not_exists(' + item.attributeName +
-              ', :iz_list_append_empty_list), :' + valueReference + ')';
-
-            if (Object.prototype.hasOwnProperty.call(payload.ExpressionAttributeValues, ':iz_list_append_empty_list')) {
-              const existing = payload.ExpressionAttributeValues[':iz_list_append_empty_list'];
+              ' = list_append(if_not_exists(' +
+              item.attributeName +
+              ', :iz_list_append_empty_list), :' +
+              valueReference +
+              ')';
+
+            if (
+              Object.prototype.hasOwnProperty.call(
+                payload.ExpressionAttributeValues,
+                ':iz_list_append_empty_list'
+              )
+            ) {
+              const existing =
+                payload.ExpressionAttributeValues[':iz_list_append_empty_list'];
               if (Array.isArray(existing) && existing.length !== 0) {
                 throw new NoRetryError(
                   'iz_list_append_empty_list already exists and conflicts with auto-generated placeholder.'
                 );
               }
             }
-            payload.ExpressionAttributeValues[':iz_list_append_empty_list'] = [];
-
+            payload.ExpressionAttributeValues[':iz_list_append_empty_list'] =
+              [];
           } else if (addSide) {
-            if (typeof payload.ExpressionAttributeValues[addSide] !== 'number') {
+            if (
+              typeof payload.ExpressionAttributeValues[addSide] !== 'number'
+            ) {
               throw new NoRetryError('add_ value should be a number.');
             }
-            expression = item.attributeName + ' = ' + item.attributeName + ' + ' + addSide;
-
+            expression =
+              item.attributeName + ' = ' + item.attributeName + ' + ' + addSide;
           } else if (subtractSide) {
-            if (typeof payload.ExpressionAttributeValues[subtractSide] !== 'number') {
+            if (
+              typeof payload.ExpressionAttributeValues[subtractSide] !==
+              'number'
+            ) {
               throw new NoRetryError('subtract_ value should be a number.');
             }
-            expression = item.attributeName + ' = ' + item.attributeName + ' - ' + subtractSide;
-
+            expression =
+              item.attributeName +
+              ' = ' +
+              item.attributeName +
+              ' - ' +
+              subtractSide;
           } else if (action === 'ADD') {
             if (typeof item.value !== 'number' && !Array.isArray(item.value)) {
-              throw new NoRetryError('ADD action supports only number and set data types.');
+              throw new NoRetryError(
+                'ADD action supports only number and set data types.'
+              );
             }
             expression = item.attributeName + ' :' + valueReference;
-
           } else if (action === 'REMOVE') {
-            if (Object.prototype.hasOwnProperty.call(item, 'valueReference') ||
-              Object.prototype.hasOwnProperty.call(item, 'value')) {
-              throw new NoRetryError('REMOVE action requires only attribute path.');
+            if (
+              Object.prototype.hasOwnProperty.call(item, 'valueReference') ||
+              Object.prototype.hasOwnProperty.call(item, 'value')
+            ) {
+              throw new NoRetryError(
+                'REMOVE action requires only attribute path.'
+              );
             }
             expression = item.attributeName;
-
           } else if (action === 'DELETE') {
             expression = item.attributeName + ' :' + valueReference;
-
-          } else { // SET (default)
+          } else {
+            // SET (default)
             expression = item.attributeName + ' = :' + valueReference;
           }
 
           // attach value placeholders
-          if (Object.prototype.hasOwnProperty.call(item, 'isStringSet') && item.isStringSet === true) {
+          if (
+            Object.prototype.hasOwnProperty.call(item, 'isStringSet') &&
+            item.isStringSet === true
+          ) {
             item.value = arrayToStringSet(item.value);
           }
           if (Object.prototype.hasOwnProperty.call(item, 'value')) {
-            payload.ExpressionAttributeValues[':' + valueReference] = item.value;
+            payload.ExpressionAttributeValues[':' + valueReference] =
+              item.value;
           }
 
           if (!Object.prototype.hasOwnProperty.call(attributeSets, action)) {
@@ -1101,7 +1327,10 @@ async function updateItem(
         payload.UpdateExpression = '';
         for (let i = 0; i < ORDER.length; i++) {
           const act = ORDER[i];
-          if (Object.prototype.hasOwnProperty.call(attributeSets, act) && attributeSets[act].length > 0) {
+          if (
+            Object.prototype.hasOwnProperty.call(attributeSets, act) &&
+            attributeSets[act].length > 0
+          ) {
             const block = act + ' ' + attributeSets[act].join(', ');
             payload.UpdateExpression = payload.UpdateExpression
               ? payload.UpdateExpression + ' ' + block
@@ -1109,11 +1338,11 @@ async function updateItem(
           }
         }
         payload.UpdateExpression = payload.UpdateExpression.trim();
-
       } else {
-        throw new NoRetryError('complexAttributes=true requires attributes as non-empty array.');
+        throw new NoRetryError(
+          'complexAttributes=true requires attributes as non-empty array.'
+        );
       }
-
     } else {
       // simple mode: default SET for flat key-value pairs
       payload.UpdateExpression = 'SET';
@@ -1121,38 +1350,54 @@ async function updateItem(
 
       for (const attribute in attributes) {
         if (Object.prototype.hasOwnProperty.call(attributes, attribute)) {
-          payload.UpdateExpression += ' ' + attribute + ' = :' + attribute + ',';
-          payload.ExpressionAttributeValues[':' + attribute] = attributes[attribute];
+          payload.UpdateExpression +=
+            ' ' + attribute + ' = :' + attribute + ',';
+          payload.ExpressionAttributeValues[':' + attribute] =
+            attributes[attribute];
         }
       }
 
       // always append izContext
       payload.UpdateExpression += ' izContext = :izContext,';
-      payload.ExpressionAttributeValues[':izContext'] = correlationIdValues(_izContext);
+      payload.ExpressionAttributeValues[':izContext'] =
+        correlationIdValues(_izContext);
 
       payload.UpdateExpression = payload.UpdateExpression.slice(0, -1);
     }
 
     // ensure izContext exists (even in complex mode)
-    if (!Object.prototype.hasOwnProperty.call(payload.ExpressionAttributeValues, ':izContext')) {
-      payload.ExpressionAttributeValues[':izContext'] = correlationIdValues(_izContext);
+    if (
+      !Object.prototype.hasOwnProperty.call(
+        payload.ExpressionAttributeValues,
+        ':izContext'
+      )
+    ) {
+      payload.ExpressionAttributeValues[':izContext'] =
+        correlationIdValues(_izContext);
       if (!/^SET\b/.test(payload.UpdateExpression)) {
         payload.UpdateExpression =
-          'SET izContext = :izContext' + (payload.UpdateExpression ? ' ' + payload.UpdateExpression : '');
+          'SET izContext = :izContext' +
+          (payload.UpdateExpression ? ' ' + payload.UpdateExpression : '');
       } else if (!/(\b|\s)izContext(\s|=|,)/.test(payload.UpdateExpression)) {
         payload.UpdateExpression = payload.UpdateExpression.replace(
           /^SET\s+/,
-          function (m) { return m + 'izContext = :izContext, '; }
+          function (m) {
+            return m + 'izContext = :izContext, ';
+          }
         );
       }
     }
 
     // ---------- prune unused placeholders (#..., :...) ----------
     let exprJoin = '';
-    if (payload.ConditionExpression) exprJoin += ' ' + String(payload.ConditionExpression);
-    if (payload.UpdateExpression) exprJoin += ' ' + String(payload.UpdateExpression);
-    if (payload.ProjectionExpression) exprJoin += ' ' + String(payload.ProjectionExpression);
-    if (payload.KeyConditionExpression) exprJoin += ' ' + String(payload.KeyConditionExpression);
+    if (payload.ConditionExpression)
+      exprJoin += ' ' + String(payload.ConditionExpression);
+    if (payload.UpdateExpression)
+      exprJoin += ' ' + String(payload.UpdateExpression);
+    if (payload.ProjectionExpression)
+      exprJoin += ' ' + String(payload.ProjectionExpression);
+    if (payload.KeyConditionExpression)
+      exprJoin += ' ' + String(payload.KeyConditionExpression);
 
     if (payload.ExpressionAttributeNames) {
       const nameKeys = Object.keys(payload.ExpressionAttributeNames);
@@ -1187,16 +1432,25 @@ async function updateItem(
     // ---- call DynamoDB
     try {
       const returnValue = await dynamodb.update(payload);
-      _izContext.logger.debug('updateItem status', { metadata: returnValue['$metadata'] });
-      await captureCapacityUsed(_izContext, returnValue.ConsumedCapacity, 'write', 'update');
+      _izContext.logger.debug('updateItem status', {
+        metadata: returnValue['$metadata']
+      });
+      await captureCapacityUsed(
+        _izContext,
+        returnValue.ConsumedCapacity,
+        'write',
+        'update'
+      );
       if (payload.ReturnValues !== 'NONE' && returnValue.Attributes) {
         return returnValue.Attributes;
       }
     } catch (err) {
       if (err && err.name === 'ConditionalCheckFailedException') {
-        const errorOn = (settings && settings.errorOnConditionalExpNotPass === true);
+        const errorOn =
+          settings && settings.errorOnConditionalExpNotPass === true;
         if (errorOn) {
-          const retryOn = (settings && settings.retryOnErrorConditionalExpNotPass === true);
+          const retryOn =
+            settings && settings.retryOnErrorConditionalExpNotPass === true;
           if (retryOn) {
             _izContext.logger.error(err.name + ': ' + err.message);
             throw new Error('ConditionalExpNotPass'); // retry upstream
@@ -1208,15 +1462,13 @@ async function updateItem(
         throw err;
       }
     }
-
   } catch (err) {
     const name = err && err.name ? String(err.name) : '';
     const message = err && err.message ? String(err.message) : '';
     _izContext.logger.error(name + ': ' + message);
     throw err;
   }
-};
-
+}
 
 /**
  * Executes a DeleteItem query on DynamoDB
@@ -1244,22 +1496,26 @@ async function deleteItem(
   _izContext.logger.debug('settings ', settings);
 
   try {
-
     let payload = {
       TableName: tableName,
       Key: keyValues,
-      ReturnValues: 'NONE',// NONE | ALL_OLD
-      ReturnConsumedCapacity: "TOTAL" // NONE(default) | TOTAL | INDEXES
+      ReturnValues: 'NONE', // NONE | ALL_OLD
+      ReturnConsumedCapacity: 'TOTAL' // NONE(default) | TOTAL | INDEXES
     };
 
     // set payload: ReturnValues
-    if (queryElements.hasOwnProperty('returnValues') && queryElements.returnValues.toLocaleUpperCase() == 'ALL_OLD') {
+    if (
+      queryElements.hasOwnProperty('returnValues') &&
+      queryElements.returnValues.toLocaleUpperCase() == 'ALL_OLD'
+    ) {
       payload.ReturnValues = queryElements.returnValues.toLocaleUpperCase();
     }
     // set payload: ConditionExpression and/or ExpressionAttributeValues
-    const [conditionExpression, expressionAttributeValues] = reformConditionExpression(_izContext, queryElements);
+    const [conditionExpression, expressionAttributeValues] =
+      reformConditionExpression(_izContext, queryElements);
     if (conditionExpression) payload.ConditionExpression = conditionExpression;
-    if (expressionAttributeValues) payload.ExpressionAttributeValues = expressionAttributeValues;
+    if (expressionAttributeValues)
+      payload.ExpressionAttributeValues = expressionAttributeValues;
 
     _izContext.logger.debug('payload before daleteItem', payload);
 
@@ -1269,17 +1525,30 @@ async function deleteItem(
         return payload; // stop process in here not send to dymanodb
       }
 
-      const returnValue = await dynamodb.delete(payload);  // ===== main query
-      _izContext.logger.debug("deleteItem status: ", returnValue['$metadata']);
-      await captureCapacityUsed(_izContext, returnValue.ConsumedCapacity, 'write', 'delete');
+      const returnValue = await dynamodb.delete(payload); // ===== main query
+      _izContext.logger.debug('deleteItem status: ', returnValue['$metadata']);
+      await captureCapacityUsed(
+        _izContext,
+        returnValue.ConsumedCapacity,
+        'write',
+        'delete'
+      );
       if (payload.ReturnValues !== 'NONE' && returnValue) {
         return returnValue; // returnValue.ConsumedCapacity
       }
-
-    } catch (err) { // catch error when put and handle errors.
-      if (err.name == 'ConditionalCheckFailedException') { // if return undefined (NOTE---dynamodb will return .Item value or Item undifined)
-        if (settings && settings.hasOwnProperty('errorOnConditionalExpNotPass') && settings.errorOnConditionalExpNotPass == true) {
-          if (settings.hasOwnProperty('retryOnErrorConditionalExpNotPass') && settings.retryOnErrorConditionalExpNotPass == true) {
+    } catch (err) {
+      // catch error when put and handle errors.
+      if (err.name == 'ConditionalCheckFailedException') {
+        // if return undefined (NOTE---dynamodb will return .Item value or Item undifined)
+        if (
+          settings &&
+          settings.hasOwnProperty('errorOnConditionalExpNotPass') &&
+          settings.errorOnConditionalExpNotPass == true
+        ) {
+          if (
+            settings.hasOwnProperty('retryOnErrorConditionalExpNotPass') &&
+            settings.retryOnErrorConditionalExpNotPass == true
+          ) {
             _izContext.logger.error(err.name + ': ' + err.message);
             throw new Error('ConditionalExpNotPass'); // TT, if throw will stop
           }
@@ -1288,19 +1557,17 @@ async function deleteItem(
         }
         // FF just pass ??
         // ...
-      } else { // e.g. ProvisionedThroughputExceededException
+      } else {
+        // e.g. ProvisionedThroughputExceededException
         throw new Error('Unhandled Error when daleteItem', err); // TT, if throw will stop
       }
     } //end catch err
-
-  } catch (err) { // catch unhandled error
+  } catch (err) {
+    // catch unhandled error
     _izContext.logger.error(err.name + ': ' + err.message);
     throw err; // TT, if throw will stop
   }
-
-};
-
-
+}
 
 // ----------- helper function -----------
 
@@ -1311,7 +1578,6 @@ function QueryElementConditionalCheckStringSetEquals(
   additionalAttributes = {},
   logicalElements = []
 ) {
-
   // ---- declare variable to return value logicalElement
   let logicalElement = {};
 
@@ -1319,23 +1585,25 @@ function QueryElementConditionalCheckStringSetEquals(
   if (oldRecord.hasOwnProperty(stringSetAttName)) {
     // --- add to attribute
     // not sure what is type stringSetAttName in oldrecord ?
-    additionalAttributes["test" + stringSetAttName] = oldRecord[stringSetAttName];
+    additionalAttributes['test' + stringSetAttName] =
+      oldRecord[stringSetAttName];
 
     // --- add to logicalElements
     logicalElement = {
-      type: "logical",
-      comparison: "equals",
+      type: 'logical',
+      comparison: 'equals',
       lhsAttribute: stringSetAttName,
-      rhsReference: "test" + stringSetAttName
+      rhsReference: 'test' + stringSetAttName
     };
-
   } else {
     // --- case if not have, just add to logicalElements
-    _izContext.logger.debug(`oldRecord NOT have property name: ${stringSetAttName}`);
+    _izContext.logger.debug(
+      `oldRecord NOT have property name: ${stringSetAttName}`
+    );
     logicalElement = {
-      type: "function",
-      function: "attribute_not_exists",
-      attribute: stringSetAttName, // require for function type
+      type: 'function',
+      function: 'attribute_not_exists',
+      attribute: stringSetAttName // require for function type
     };
   }
 
@@ -1344,23 +1612,24 @@ function QueryElementConditionalCheckStringSetEquals(
   if (logicalElements.length > 0) {
     // concate with "and" then concat new logicalElement
     logicalElements.push({
-      type: "logicalOperator",
-      operator: "and"
+      type: 'logicalOperator',
+      operator: 'and'
     });
   }
   // combine logicalElement all cases
   logicalElements.push(logicalElement);
 
-  _izContext.logger.debug(`additionalAttributes before returnValue:`, additionalAttributes);
-  _izContext.logger.debug(`logicalElements before returnValue:`, logicalElements);
-
-  return [
-    additionalAttributes,
+  _izContext.logger.debug(
+    `additionalAttributes before returnValue:`,
+    additionalAttributes
+  );
+  _izContext.logger.debug(
+    `logicalElements before returnValue:`,
     logicalElements
-  ];
-
-}; // end QueryElementConditionalCheckStringSetEquals
+  );
 
+  return [additionalAttributes, logicalElements];
+} // end QueryElementConditionalCheckStringSetEquals
 
 //----  Helper fucntion -----
 // module.exports.generateExistLogicalElements = (keyValues) => {
@@ -1374,22 +1643,20 @@ function generateNotExistLogicalElements(attributes, existed = false) {
   let logicalElements = [];
   for (let propName in attributes) {
     logicalElements.push({
-      type: "function",
+      type: 'function',
       // function: "attribute_not_exists",
-      function: existed,     // attribute_not_exists | attribute_exists
-      attribute: propName,
+      function: existed, // attribute_not_exists | attribute_exists
+      attribute: propName
+    });
+    logicalElements.push({
+      type: 'logicalOperator',
+      operator: 'and'
     });
-    logicalElements.push(
-      {
-        type: "logicalOperator",
-        operator: "and"
-      });
   }
   logicalElements.pop(); // delete last and conjunction element
 
   return logicalElements;
-};
-
+}
 
 function refractorAttributesToComplex(attributes, forPutQuery = false) {
   // only for SET update
@@ -1402,15 +1669,15 @@ function refractorAttributesToComplex(attributes, forPutQuery = false) {
       value: attributes[propName]
     };
 
-    if (!forPutQuery) { // case if want to use update syntax query
+    if (!forPutQuery) {
+      // case if want to use update syntax query
       addAttributes.action = 'set';
     }
 
     returnAttributes.push(addAttributes);
   }
   return returnAttributes;
-};
-
+}
 
 /**
  * Build and execute a DynamoDB TransactWrite from high-level writeItems.
@@ -1420,14 +1687,13 @@ function refractorAttributesToComplex(attributes, forPutQuery = false) {
  * @param {Array} writeItems
  * @returns {Promise<object>} DynamoDB response including $metadata/ConsumedCapacity
  */
-async function transactWriteItems(
-  _izContext,
-  writeItems
-) {
+async function transactWriteItems(_izContext, writeItems) {
   try {
     // Validate top-level arguments
     if (!Array.isArray(writeItems)) {
-      throw new NoRetryError('transactWriteItems requires writeItems as an array.');
+      throw new NoRetryError(
+        'transactWriteItems requires writeItems as an array.'
+      );
     }
 
     _izContext.logger.debug('writeItems', { writeItems: writeItems });
@@ -1463,7 +1729,7 @@ async function transactWriteItems(
 
       // Dispatch per action
       if (action === 'put') {
-        const putReq = await module.exports.putItem(
+        const putReq = await putItem(
           _izContext,
           item.params.tableName,
           item.params.attributes,
@@ -1472,7 +1738,7 @@ async function transactWriteItems(
         );
         transactItems.push({ Put: putReq });
       } else if (action === 'update') {
-        const updateReq = await module.exports.updateItem(
+        const updateReq = await updateItem(
           _izContext,
           item.params.tableName,
           item.params.keyValues,
@@ -1482,7 +1748,7 @@ async function transactWriteItems(
         );
         transactItems.push({ Update: updateReq });
       } else if (action === 'delete') {
-        const deleteReq = await module.exports.deleteItem(
+        const deleteReq = await deleteItem(
           _izContext,
           item.params.tableName,
           item.params.keyValues,
@@ -1493,7 +1759,9 @@ async function transactWriteItems(
       }
     }
 
-    _izContext.logger.debug('payload transactItems', { transactItems: transactItems });
+    _izContext.logger.debug('payload transactItems', {
+      transactItems: transactItems
+    });
 
     // Execute TransactWrite
     const returnValue = await dynamodb.transactWrite({
@@ -1502,7 +1770,9 @@ async function transactWriteItems(
     });
 
     _izContext.logger.debug('returnValue', { returnValue: returnValue });
-    _izContext.logger.debug('transactWriteItems status', { metadata: returnValue['$metadata'] });
+    _izContext.logger.debug('transactWriteItems status', {
+      metadata: returnValue['$metadata']
+    });
 
     // Track capacity usage
     await captureCapacityUsed(
@@ -1527,13 +1797,10 @@ async function transactWriteItems(
     });
     throw err;
   }
-};
-
+}
 
 // this.transactWriteItems()
 
-
-
 /* NOTE for batchWriteItems cannot perform multiple operations. you cannot put and delete the same item in the same BatchWriteItem request.
   Item  not exceed more than 25 requests in the batch, and not batch exceeds 400 KB.The total request size exceeds 16 MB
   action: PutItem | DeleteItem
@@ -1548,13 +1815,11 @@ async function batchDeleteItems(
   keyFieldName
 ) {
   try {
-
     let size = 25; // maybe should check size < 400 KB
     let chunked = [];
 
     for (let i = 0; i < writeItems.length; i += size) {
-      chunked.push(writeItems.slice(i, i + size)
-      );
+      chunked.push(writeItems.slice(i, i + size));
     }
 
     // ---- perform each chuck < 25 ----
@@ -1567,8 +1832,10 @@ async function batchDeleteItems(
         requestItems.push({
           DeleteRequest: {
             Key: {
-              [keyFieldName.partitionKeyFieldName]: chunkSet[i][keyFieldName.partitionKeyFieldName],
-              [keyFieldName.sortKeyFieldName]: chunkSet[i][keyFieldName.sortKeyFieldName]
+              [keyFieldName.partitionKeyFieldName]:
+                chunkSet[i][keyFieldName.partitionKeyFieldName],
+              [keyFieldName.sortKeyFieldName]:
+                chunkSet[i][keyFieldName.sortKeyFieldName]
             }
           }
         });
@@ -1578,23 +1845,27 @@ async function batchDeleteItems(
         RequestItems: {
           [tableName]: requestItems
         },
-        ReturnConsumedCapacity: "TOTAL"
+        ReturnConsumedCapacity: 'TOTAL'
       };
       _izContext.logger.debug('payload writeItems... ', payload);
 
       const returnValue = await dynamodb.batchWrite(payload);
-      _izContext.logger.debug("batchDeleteItems status: ", returnValue['$metadata']);
-      await captureCapacityUsed(_izContext, returnValue.ConsumedCapacity, 'write', 'delete');
+      _izContext.logger.debug(
+        'batchDeleteItems status: ',
+        returnValue['$metadata']
+      );
+      await captureCapacityUsed(
+        _izContext,
+        returnValue.ConsumedCapacity,
+        'write',
+        'delete'
+      );
     } // end loop
   } catch (err) {
     throw ('Error:baatchDeleteItems', err);
-  };
+  }
   _izContext.logger.info('----- finish all batchDeleteItems -----');
-
-};
-
-
-
+}
 
 /*https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#batchWriteItem-property
   NOTE: Cannot use complex settings inside PutRequest
@@ -1625,10 +1896,8 @@ async function batchPutItems(
     // ]
     // ---------------------------------
 
-
     for (let i = 0; i < writeItems.length; i += size) {
-      chunked.push(writeItems.slice(i, i + size)
-      );
+      chunked.push(writeItems.slice(i, i + size));
     }
 
     // ---- perform each chuck < 25 ----
@@ -1638,7 +1907,6 @@ async function batchPutItems(
       // console.log('chunkSet', chunkSet);
 
       for (let i = 0; i < chunkSet.length; i++) {
-
         // hard code set to return just query
         chunkSet[i].settings.returnQuery = true;
 
@@ -1659,24 +1927,30 @@ async function batchPutItems(
         });
       }
 
-
       let payload = {
         RequestItems: {
           [tableNameData]: requestItems
         },
-        ReturnConsumedCapacity: "TOTAL"
+        ReturnConsumedCapacity: 'TOTAL'
       };
       _izContext.logger.debug('payload writeItems... ', payload);
 
       const returnValue = await dynamodb.batchWrite(payload);
-      _izContext.logger.debug("batchPutItems status: ", returnValue['$metadata']);
-      await captureCapacityUsed(_izContext, returnValue.ConsumedCapacity, 'write', 'put');
+      _izContext.logger.debug(
+        'batchPutItems status: ',
+        returnValue['$metadata']
+      );
+      await captureCapacityUsed(
+        _izContext,
+        returnValue.ConsumedCapacity,
+        'write',
+        'put'
+      );
     } // end loop
   } catch (err) {
     throw ('Error:baatchPutItems', err);
   }
-
-};
+}
 
 /**
  *
@@ -1689,27 +1963,48 @@ async function batchPutItems(
  * This function will collect capacity units and store in _izContext.resourceUse
  * Middleware will capture resourceUse and send to ResourceUse Service later
  */
-async function captureCapacityUsed(_izContext, capacityUsed, capacityStatus, queryOperation) {
+async function captureCapacityUsed(
+  _izContext,
+  capacityUsed,
+  capacityStatus,
+  queryOperation
+) {
   // validate capacityUsed and resourceUse instance in _izContext
   if (!capacityUsed || !_izContext.resourceUse) return;
 
   if (Array.isArray(capacityUsed)) {
     // In case call transectionWrite, ConsumedCapacity will return array instead of object
     // We need map through array before call captureCapacityUsed
-    capacityUsed.map(async (capacityRecord) => {
-      await captureCapacityUsed(_izContext, capacityRecord, capacityStatus, queryOperation);
+    capacityUsed.map(async capacityRecord => {
+      await captureCapacityUsed(
+        _izContext,
+        capacityRecord,
+        capacityStatus,
+        queryOperation
+      );
     });
-
   } else {
-
-    if (capacityStatus === 'read') { // hardcode capacityStatus in  each query and here
+    if (capacityStatus === 'read') {
+      // hardcode capacityStatus in  each query and here
       capacityUsed.QueryOperation = queryOperation;
-      await _izContext.resourceUse.setResourceUse(_izContext, 'DynamoDbRead', capacityUsed.CapacityUnits, capacityUsed);
+      await _izContext.resourceUse.setResourceUse(
+        _izContext,
+        'DynamoDbRead',
+        capacityUsed.CapacityUnits,
+        capacityUsed
+      );
     } else if (capacityStatus === 'write') {
       capacityUsed.QueryOperation = queryOperation;
-      await _izContext.resourceUse.setResourceUse(_izContext, 'DynamoDbWrite', capacityUsed.CapacityUnits, capacityUsed);
+      await _izContext.resourceUse.setResourceUse(
+        _izContext,
+        'DynamoDbWrite',
+        capacityUsed.CapacityUnits,
+        capacityUsed
+      );
     } else {
-      throw new NoRetryError('captureCapacityUsed has wrong type of capacityStatus');
+      throw new NoRetryError(
+        'captureCapacityUsed has wrong type of capacityStatus'
+      );
     }
   }
 }
@@ -1743,4 +2038,4 @@ export default {
   QueryElementConditionalCheckStringSetEquals,
   generateNotExistLogicalElements,
   refractorAttributesToComplex
-};
+};