@izara_project/izara-core-generate-service-code 1.0.17 → 1.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Code for locally generating per service files",
   "main": "index.js",
   "scripts": {

package/src/TemplateData/IntTest/generateTests/tests/data.js

@@ -60,7 +60,10 @@ async function data(_izContext, allIntTestConfig, srcPath) {
             //   'testConfig.seedDataConfig[seedDataTag]',
             //   testConfig.seedDataConfig[seedDataTag]
             // );
-            if (testConfig.seedDataConfig.hasOwnProperty(seedDataTag) && testConfig.seedDataConfig[seedDataTag].length > 0) {
+            if (
+              testConfig.seedDataConfig.hasOwnProperty(seedDataTag) &&
+              testConfig.seedDataConfig[seedDataTag].length > 0
+            ) {
               baseIntTest[seedDataTag] = testConfig.seedDataConfig[seedDataTag];
             } else {
               baseIntTest[seedDataTag] = [];
@@ -157,17 +160,25 @@ async function data(_izContext, allIntTestConfig, srcPath) {
             );
             if (dynamoEventStage.length > 0) {
               // baseIntTest.stage[currentStageIdx]["dynamodbOutputEventIdentifiers"] = dynamoEventStage;
-              stages[currentStageIdx]['dynamodbOutputEventIdentifiers'] = dynamoEventStage;
+              stages[currentStageIdx]['dynamodbOutputEventIdentifiers'] =
+                dynamoEventStage;
             }
           }
 
           // generatedSeedData
-          if (stage.generatedSeedData && Object.keys(stage.generatedSeedData).length > 0) {
-            for (const generateSeedType of Object.values(GENERATE_SEED_DATA_TYPE)) {
+          if (
+            stage.generatedSeedData &&
+            Object.keys(stage.generatedSeedData).length > 0
+          ) {
+            for (const generateSeedType of Object.values(
+              GENERATE_SEED_DATA_TYPE
+            )) {
               if (stage.generatedSeedData.hasOwnProperty(generateSeedType)) {
                 // baseIntTest.stage[currentStageIdx]["generateSeedDatas"] = {
-                stages[currentStageIdx]['generateSeedData'] = {
-                  [generateSeedType]: [...stage.generatedSeedData[generateSeedType]]
+                stages[currentStageIdx]['generatedSeedData'] = {
+                  [generateSeedType]: [
+                    ...stage.generatedSeedData[generateSeedType]
+                  ]
                 };
               }
             }

package/src/TemplateData/processLogicalPagination/mainFunction/template.ejs

@@ -20,13 +20,9 @@ import sqsSharedLib from '@izara_project/izara-core-library-sqs';
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
 import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
 
-import {
-  sqs
-} from '@izara_project/izara-core-library-external-request';
+import { sqs } from '@izara_project/izara-core-library-external-request';
 
-import {
-  NoRetryError
-} from '@izara_project/izara-core-library-core';
+import { NoRetryError } from '@izara_project/izara-core-library-core';
 
 // set query limit
 const limit = 2;
@@ -38,9 +34,11 @@ const limit = 2;
  * @param {string} tableName
  * @param {string} partitionKeyFieldName
  * @param {string} sortKeyFieldName
+ * @param {Object} dynamoDbIdentifiers
  * @param {string} comparison
  * @param {Object} startKey
  * @param {string} overwriteUniqueRequestId
+ * @param {boolean} overwriteCache
  * @param {string} callingFlow
  *
  * @returns {string} description of return value
@@ -52,46 +50,52 @@ export default async function paginateProcessLogical(
   tableName,
   partitionKeyFieldName,
   sortKeyFieldName,
+  dynamoDbIdentifiers,
   comparison, // optional
   startKey, // optional
   overwriteUniqueRequestId, // optional
+  overWriteCache,
   callingFlow // optional
 ) {
-
   try {
-
-    _izContext.logger.debug(
-    '----- PaginateProcessLogical event params -----', {
+    _izContext.logger.debug('----- PaginateProcessLogical event params -----', {
       logicalResultId: logicalResultId,
       tableName: tableName,
       partitionKeyFieldName: partitionKeyFieldName,
       sortKeyFieldName: sortKeyFieldName,
+      dynamoDbIdentifiers: dynamoDbIdentifiers,
       comparison: comparison,
       startKey: startKey,
       overwriteUniqueRequestId: overwriteUniqueRequestId,
+      overWriteCache: overWriteCache,
       callingFlow: callingFlow
     });
 
     // Check/Create logicalResultsMain
     let [checkUniqueRequestProcessingStatus, logicalResultsMain] =
-    await asyncFlowSharedLib.checkUniqueRequestProcessing(
-      _izContext,
-      "LogicalResultsMain", {
-        logicalResultId: logicalResultId
-      },
-      "paginateProcessLogical",
-      overwriteUniqueRequestId
-    );
-    _izContext.logger.debug("After check uniqueRequestProcessingStatus:", {
+      await asyncFlowSharedLib.checkUniqueRequestProcessing(
+        _izContext,
+        'LogicalResultsMain',
+        {
+          logicalResultId: logicalResultId
+        },
+        'paginateProcessLogical',
+        overwriteUniqueRequestId
+      );
+    _izContext.logger.debug('After check uniqueRequestProcessingStatus:', {
       checkUniqueRequestProcessingStatus: checkUniqueRequestProcessingStatus,
       logicalResultsMain: logicalResultsMain
     });
 
-    if (checkUniqueRequestProcessingStatus == "stop") {
-      return;
-    } else if (checkUniqueRequestProcessingStatus == "recordNotFound") {
+    if (checkUniqueRequestProcessingStatus == 'stop') {
+      return {
+        returnResponse: 'process already stop'
+      };
+    } else if (checkUniqueRequestProcessingStatus == 'recordNotFound') {
       // should always have unless another request already completed it, in which case nothing to do
-      return;
+      return {
+        returnResponse: 'record not found'
+      };
     }
 
     let errorsFound = [];
@@ -100,11 +104,11 @@ export default async function paginateProcessLogical(
       logicalResultId,
       logicalResultsMain.logicalElement,
       logicalResultsMain.objType,
+      overWriteCache,
       callingFlow,
-      "error"
+      'error'
     ];
 
-    const partitionKeyValue = logicalResultsMain.logicalElement.partitionKey;
     let queryElements = {
       limit: limit
     };
@@ -118,60 +122,101 @@ export default async function paginateProcessLogical(
     );
 
     if (startKey === false) {
-      throw new NoRetryError("split processing received invalid startKey");
+      throw new NoRetryError('split processing received invalid startKey');
     }
-    _izContext.logger.debug("startKey :", startKey);
+    _izContext.logger.debug('startKey :', startKey);
 
     if (startKey) {
-      queryElements["exclusiveStartKey"] = {
+      queryElements['exclusiveStartKey'] = {
         [partitionKeyFieldName]: startKey[partitionKeyFieldName],
         [sortKeyFieldName]: startKey[sortKeyFieldName]
-      }
-    };
+      };
+    }
 
     if (comparison) {
-      const sortKeyValue = logicalResultsMain.logicalElement.sortKey;
-
-      queryElements["sortKeyCondition"] = {
+      queryElements['sortKeyCondition'] = {
         comparison: comparison,
         name: sortKeyFieldName,
-        value: sortKeyValue
+        value: dynamoDbIdentifiers[sortKeyFieldName]
       };
     }
 
     let queryDatas = await dynamodbSharedLib.query(
       _izContext,
-      await dynamodbSharedLib.tableName(_izContext, tableName), {
-        [partitionKeyFieldName]: partitionKeyValue
+      await dynamodbSharedLib.tableName(_izContext, tableName),
+      {
+        [partitionKeyFieldName]: dynamoDbIdentifiers[partitionKeyFieldName]
       },
       queryElements
-    )
-    _izContext.logger.debug("queryDatas result: ", queryDatas)
+    );
+    _izContext.logger.debug('queryDatas result: ', queryDatas);
 
     if (!startKey && queryDatas.Items.length == 0) {
-      _izContext.logger.debug(`can't find data in table ${tableName}`)
-      errorsFound.push(`can't find data in table ${tableName}`)
-      standardErrorParams.push(errorsFound)
-      await logicalResultsSharedLib.completeLogicalResultsMain(...
-        standardErrorParams);
-      return;
+      _izContext.logger.debug(`can't find data in table ${tableName}`);
+      errorsFound.push(`can't find data in table ${tableName}`);
+      standardErrorParams.push(errorsFound);
+      await logicalResultsSharedLib.completeLogicalResultsMain(
+        ...standardErrorParams
+      );
+      return {
+        returnResponse: 'Cannot find data in table'
+      };
     }
 
-    for (const objInstanceBase of queryDatas.Items) {
+    // For conditionalFieldValues
+    let objInstanceBases = queryDatas.Items;
+    const conditionalFieldValues =
+      logicalResultsMain.logicalElement.conditionalFieldValues;
+
+    if (
+      Array.isArray(conditionalFieldValues) &&
+      conditionalFieldValues.length > 0
+    ) {
+      for (const conditionalFieldValue of conditionalFieldValues) {
+        _izContext.logger.debug(
+          'conditionalFieldValue: ',
+          conditionalFieldValue
+        );
+
+        let conditionalFieldName = conditionalFieldValue.fieldName;
+
+        if (conditionalFieldValue.hasOwnProperty('includeValues')) {
+          let includeValues = conditionalFieldValue.includeValues; // array
+
+          objInstanceBases = objInstanceBases.filter(objInstanceBase => {
+            return includeValues.includes(
+              objInstanceBase[conditionalFieldName]
+            );
+          });
+        } else if (conditionalFieldValue.hasOwnProperty('excludeValues')) {
+          let excludeValues = conditionalFieldValue.excludeValues; // array
+
+          objInstanceBases = objInstanceBases.filter(objInstanceBase => {
+            return !excludeValues.includes(
+              objInstanceBase[conditionalFieldName]
+            );
+          });
+        }
+      }
+      _izContext.logger.debug(
+        'objInstanceBases after conditionalFieldValues: ',
+        objInstanceBases
+      );
+    }
 
+    for (const objInstanceBase of objInstanceBases) {
       await logicalResultsSharedLib.saveLogicalData(
         _izContext,
         logicalResultId,
         logicalResultsMain.objType,
         objInstanceBase
-      )
+      );
     }
 
-    if (queryDatas.hasOwnProperty("LastEvaluatedKey")) {
-
+    if (queryDatas.hasOwnProperty('LastEvaluatedKey')) {
       if (!overwriteUniqueRequestId) {
-        overwriteUniqueRequestId = _izContext.uniqueRequestId
-      };
+        overwriteUniqueRequestId = _izContext.uniqueRequestId;
+      }
 
       let continuePaginationMsg = {
         MessageBody: JSON.stringify({
@@ -179,39 +224,45 @@ export default async function paginateProcessLogical(
           tableName: tableName,
           partitionKeyFieldName: partitionKeyFieldName,
           sortKeyFieldName: sortKeyFieldName,
+          dynamoDbIdentifiers: dynamoDbIdentifiers,
           comparison: comparison,
-          overwriteUniqueRequestId: overwriteUniqueRequestId,
           startKey: queryDatas.LastEvaluatedKey,
+          overwriteUniqueRequestId: overwriteUniqueRequestId,
           overWriteCache: overWriteCache,
           callingFlow: callingFlow
         }),
-        QueueUrl: await sqsSharedLib.sqsQueueUrl(_izContext,
-          "PaginateProcessLogicalHdrDsq"),
+        QueueUrl: await sqsSharedLib.sqsQueueUrl(
+          _izContext,
+          'PaginateProcessLogicalHdrDsq'
+        )
       };
 
-      _izContext.logger.debug("continuePaginationMessage: ",
-        continuePaginationMsg);
+      _izContext.logger.debug(
+        'continuePaginationMessage: ',
+        continuePaginationMsg
+      );
       await sqs.sendMessage(_izContext, continuePaginationMsg);
 
-      return "Continue PaginateProcessLogical"
-
+      return {
+        returnResponse: 'Continue PaginateProcessLogical'
+      };
     } else {
-
       await logicalResultsSharedLib.completeLogicalResultsMain(
         _izContext,
         logicalResultId,
         logicalResultsMain.logicalElement,
         logicalResultsMain.objType,
+        overWriteCache,
         callingFlow,
-        "complete",
-        [],
-      )
+        'complete'
+      );
     }
 
-    return "Function PaginateProcessLogical is Finished"
-
+    return {
+      returnResponse: 'Function PaginateProcessLogical is Finished'
+    };
   } catch (err) {
     _izContext.logger.error('error PaginateProcessLogicalMain: ', err);
-    throw (err)
+    throw err;
   }
-}
+}