@izara_project/izara-market-library-service-schemas 1.0.83 → 1.0.84

package/src/GenerateCodeLibs/src/GenerateCodeLibs.js

@@ -15,44 +15,55 @@ 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 lodash from 'lodash';
 import { objectHash as hash } from '@izara_project/izara-shared-core';
-import { NoRetryError, inMemoryCacheLib, validator as validateObject } from '@izara_project/izara-core-library-core';
+import {
+  NoRetryError,
+  inMemoryCacheLib,
+  validator as validateObject
+} from '@izara_project/izara-core-library-core';
 import { sns, sqs } from '@izara_project/izara-core-library-external-request';
-import { getObjectSchema, validator as validatorSchema, serviceConfig, utils, consts as coreConsts, explodedReqParams, deliminatorTree } from '@izara_project/izara-core-library-service-schemas'
-import Logger from "@izara_project/izara-core-library-logger";
+import {
+  getObjectSchema,
+  validator as validatorSchema,
+  serviceConfig,
+  utils,
+  consts as coreConsts,
+  explodedReqParams,
+  deliminatorTree
+} from '@izara_project/izara-core-library-service-schemas';
+import Logger from '@izara_project/izara-core-library-logger';
 
 import { validateObjType } from '@izara_project/izara-shared-service-schemas';
 
 // core libs
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
-import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow'
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
 import sqsSharedLib from '@izara_project/izara-core-library-sqs';
 import snsSharedLib from '@izara_project/izara-core-library-sns';
 import graphSharedLibs from '@izara_project/izara-core-library-graph-service';
 import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
-import consts from './Consts.js'
-const { TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER, PREFIX } = consts
+import consts from './Consts.js';
+const { TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER, PREFIX } = consts;
 
-const nodeLabelRegexPattern = "^[a-zA-Z0-9_-]+(?:\:[a-zA-Z0-9_-]+)?$"
+const nodeLabelRegexPattern = '^[a-zA-Z0-9_-]+(?:\:[a-zA-Z0-9_-]+)?$';
 
 const schemaFunctionPerAction = {
   [coreConsts.ACTIONS.create]: validatorSchema.generateValidatorSchemaForCreate,
   [coreConsts.ACTIONS.update]: validatorSchema.generateValidatorSchemaForUpdate,
-  [coreConsts.ACTIONS.get]: validatorSchema.generateValidatorSchemaForIdentifier,
-  [coreConsts.ACTIONS.delete]: validatorSchema.generateValidatorSchemaForIdentifier,
-}
+  [coreConsts.ACTIONS.get]:
+    validatorSchema.generateValidatorSchemaForIdentifier,
+  [coreConsts.ACTIONS.delete]:
+    validatorSchema.generateValidatorSchemaForIdentifier
+};
 
 const explodeDataPerAction = {
   [coreConsts.ACTIONS.create]: explodedReqParams.explodedDataForCreate,
   [coreConsts.ACTIONS.get]: explodedReqParams.explodedDataForIdentifiers,
   [coreConsts.ACTIONS.update]: explodedReqParams.explodedDataForUpdate,
   [coreConsts.ACTIONS.delete]: explodedReqParams.explodedDataForIdentifiers
-}
-
+};
 
 /*
   ---------- Contain function use for generated code ----------
@@ -71,9 +82,10 @@ function validateSchemaMiddleware(
   bucketName = process.env.iz_serviceSchemaBucketName
   // setting = {}
 ) {
-
   if (!schemaFunctionPerAction[action] || !explodeDataPerAction[action]) {
-    throw new NoRetryError(`Not found function for generateValidatorSchema or explodeDataPerAction of action:${action}`);
+    throw new NoRetryError(
+      `Not found function for generateValidatorSchema or explodeDataPerAction of action:${action}`
+    );
   }
   // Logger.debug("setting in generateCodeLibs", setting)
   middleware.setServiceSchema(
@@ -84,7 +96,7 @@ function validateSchemaMiddleware(
       //   specificFieldNames: setting?.specificFieldNames ? setting.specificFieldNames : [],
       action: action,
       bucketName: bucketName
-    },
+    }
   );
 }
 
@@ -104,33 +116,48 @@ async function validateSchemaPerRecord(
   lambdaFunctionName,
   objType,
   action,
-  setting = { bucketName: process.env.iz_serviceSchemaBucketName, specificFieldNames: [] }
+  setting = {
+    bucketName: process.env.iz_serviceSchemaBucketName,
+    specificFieldNames: []
+  }
 ) {
   try {
-    record._izContext.logger.debug("validateSchemaPerRecord: ",
+    record._izContext.logger.debug(
+      'validateSchemaPerRecord: ',
       record,
       lambdaFunctionName,
       objType,
       action,
       setting
-    )
+    );
 
     if (!schemaFunctionPerAction[action] || !explodeDataPerAction[action]) {
-      throw new Error(`Not found function for generateValidatorSchema or function for explodeData of action:${action}`);
+      throw new Error(
+        `Not found function for generateValidatorSchema or function for explodeData of action:${action}`
+      );
     }
 
-    const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(record._izContext, objType);
+    const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
+      record._izContext,
+      objType
+    );
 
     if (!objectSchema) {
-      throw new Error("not have objectSchema in service");
+      throw new Error('not have objectSchema in service');
     }
 
     const generateValidatorFunction = schemaFunctionPerAction[action];
-    const explodeDataFunction = explodeDataPerAction[action]
-
-    const generatedSchema = await generateValidatorFunction(record._izContext, objType, setting);
-    record._izContext.logger.debug(`generatedSchema in validateSchemaPerRecord : `, generatedSchema);
+    const explodeDataFunction = explodeDataPerAction[action];
 
+    const generatedSchema = await generateValidatorFunction(
+      record._izContext,
+      objType,
+      setting
+    );
+    record._izContext.logger.debug(
+      `generatedSchema in validateSchemaPerRecord : `,
+      generatedSchema
+    );
 
     const explodedDataRequestParams = await explodeDataFunction(
       record._izContext,
@@ -139,24 +166,35 @@ async function validateSchemaPerRecord(
       setting
     );
 
+    record._izContext.logger.debug(
+      'explodedDataRequestParams in validateSchemaPerRecord : ',
+      JSON.stringify(explodedDataRequestParams)
+    );
 
-    record._izContext.logger.debug('explodedDataRequestParams in validateSchemaPerRecord : ', JSON.stringify(explodedDataRequestParams));
-
-
-    let validateStatus = validateObject(generatedSchema, explodedDataRequestParams);
+    let validateStatus = validateObject(
+      generatedSchema,
+      explodedDataRequestParams
+    );
     record._izContext.logger.debug('validateStatus : ', validateStatus);
 
     // if not pass validate will sent message to dlq and throw NoRetryError
     if (!validateStatus.pass) {
-      await messageToDlq(record, `Invalid: ${validateStatus.error}`, await sqsSharedLib.sqsQueueUrlDLQ(record._izContext, lambdaFunctionName));
-      record._izError = new Error(validateStatus.error)
+      await messageToDlq(
+        record,
+        `Invalid: ${validateStatus.error}`,
+        await sqsSharedLib.sqsQueueUrlDLQ(record._izContext, lambdaFunctionName)
+      );
+      record._izError = new Error(validateStatus.error);
     }
   } catch (error) {
-    record._izContext.logger.debug("validate PerSchema Record error", error)
-    await messageToDlq(record, error.message, await sqsSharedLib.sqsQueueUrlDLQ(record._izContext, lambdaFunctionName));
-    record._izError = new Error(error)
+    record._izContext.logger.debug('validate PerSchema Record error', error);
+    await messageToDlq(
+      record,
+      error.message,
+      await sqsSharedLib.sqsQueueUrlDLQ(record._izContext, lambdaFunctionName)
+    );
+    record._izError = new Error(error);
   }
-
 }
 
 /**
@@ -169,19 +207,18 @@ async function validateSchemaPerRecord(
  * @returns {object}
  */
 
-async function validationForWebSocket(
-  _izContext,
-  flowType
-) {
-  _izContext.logger.debug("validator schema for flowTag", {
+async function validationForWebSocket(_izContext, flowType) {
+  _izContext.logger.debug('validator schema for flowTag', {
     flowType
-  })
-  let flowSchema = await getObjectSchema.getFlowSchemaS3(_izContext, flowType)
-
-  let validatorSchemaForFlowSchema = flowSchema.initializeRequest.initializeRequestProperties
-  _izContext.logger.debug("validatorSchemaForFlowSchema:", validatorSchemaForFlowSchema)
-
+  });
+  let flowSchema = await getObjectSchema.getFlowSchemaS3(_izContext, flowType);
 
+  let validatorSchemaForFlowSchema =
+    flowSchema.initializeRequest.initializeRequestProperties;
+  _izContext.logger.debug(
+    'validatorSchemaForFlowSchema:',
+    validatorSchemaForFlowSchema
+  );
 }
 
 /**
@@ -196,25 +233,26 @@ function validatorSchemaMiddlewareByAction(
   action,
   setting = {}
 ) {
-
   // if (!schemaFunctionPerAction[action] || !explodeDataPerAction[action]) {
   //   throw new NoRetryError(`Not found function for generateValidatorSchema or explodeDataPerAction of action:${action}`);
   // }
-  console.log("before send to middleware", {
+  console.log('before send to middleware', {
     middleware,
     // objectType,
     action,
     setting
-  })
-  Logger.debug("setting in generateCodeLibs", setting)
+  });
+  Logger.debug('setting in generateCodeLibs', setting);
   middleware.setServiceSchema(
     // schemaFunctionPerAction[action],
     // explodeDataPerAction[action],
     {
       // objectType: objectType,
-      specificFieldNames: setting?.specificFieldNames ? setting.specificFieldNames : [],
+      specificFieldNames: setting?.specificFieldNames
+        ? setting.specificFieldNames
+        : [],
       action: action
-    },
+    }
   );
 }
 // /**
@@ -258,7 +296,6 @@ function validatorSchemaMiddlewareByAction(
 
 //     _izContext.logger.debug("exploded RequestParams Data in GeneratorValidatorSchema :", explodedDataPerWebSocket);
 
-
 //     let validateStatus = validateObject(_izContext, generateValidatorSchemaPerWebSocket, explodedDataPerWebSocket);
 //     _izContext.logger.debug('validateStatus : ', validateStatus);
 
@@ -272,31 +309,45 @@ function validatorSchemaMiddlewareByAction(
 //   }
 // }
 
-async function sendMsgOutComplete(_izContext, topicName, messageObj, callingFlowConfig) {
-
+async function sendMsgOutComplete(
+  _izContext,
+  topicName,
+  messageObj,
+  callingFlowConfig
+) {
   try {
     // add callingFlow to message
-    messageObj = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObj);
-    let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+    messageObj =
+      callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
+        callingFlowConfig,
+        messageObj
+      );
+    let messageAttributes =
+      callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+        callingFlowConfig,
+        {}
+      );
 
     let sendMessageOutComplete = {
       Message: JSON.stringify(messageObj),
-      MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-      TopicArn: await snsSharedLib.snsTopicArn(_izContext, topicName),
+      MessageAttributes: sns.createStringMessageAttributes(
+        _izContext,
+        messageAttributes
+      ),
+      TopicArn: await snsSharedLib.snsTopicArn(_izContext, topicName)
     };
 
-    _izContext.logger.debug(`Send message to ${topicName} :`, sendMessageOutComplete);
+    _izContext.logger.debug(
+      `Send message to ${topicName} :`,
+      sendMessageOutComplete
+    );
     await sns.publishAsync(_izContext, sendMessageOutComplete);
     return;
   } catch (error) {
     throw error;
   }
-
 }
 
-
-
-
 /**
  * @param {object} record               - One record from sqs.
  * @param {string} messageFailError     - The message error.
@@ -304,26 +355,29 @@ async function sendMsgOutComplete(_izContext, topicName, messageObj, callingFlow
  *
  */
 async function messageToDlq(record, messageFailError, queueUrl) {
-
-  let messageBody = record.body
+  let messageBody = record.body;
 
   let params = {
     QueueUrl: queueUrl,
     MessageAttributes: {
       messageFailError: {
-        DataType: "String",
+        DataType: 'String',
         StringValue: messageFailError
       }
     },
-    MessageBody: JSON.stringify(messageBody),
+    MessageBody: JSON.stringify(messageBody)
   };
 
-  record._izContext.logger.debug('messageToDlq, params before sending DLQ', params);
+  record._izContext.logger.debug(
+    'messageToDlq, params before sending DLQ',
+    params
+  );
 
   await sqs.sendMessage(record._izContext, params);
-  record._izContext.logger.debug("----- messageToDlq sendMessage success -----");
-};
-
+  record._izContext.logger.debug(
+    '----- messageToDlq sendMessage success -----'
+  );
+}
 
 // {
 //   [storageTag]: {
@@ -338,7 +392,6 @@ async function messageToDlq(record, messageFailError, queueUrl) {
 //   }
 // }
 
-
 /**
  * helper function for get endpoint
  * create get data detail for each storageTag
@@ -346,18 +399,23 @@ async function messageToDlq(record, messageFailError, queueUrl) {
  * @param {Object} _izContext
  * @param {Object} objectSchema
  */
-async function createGetDataDetails(_izContext, objectSchema, settings = { bucketName: process.env.iz_serviceSchemaBucketName }) {
-
+async function createGetDataDetails(
+  _izContext,
+  objectSchema,
+  settings = { bucketName: process.env.iz_serviceSchemaBucketName }
+) {
   // group versionedData per storageTag
   // or should group versionedData per graph serviceTag
-  let versionedDataPerStorageTag = {}
+  let versionedDataPerStorageTag = {};
   if (objectSchema?.addOnDataStructure?.length) {
     for (let addOn of objectSchema.addOnDataStructure) {
-      if (addOn.type !== "versionedData") {
+      if (addOn.type !== 'versionedData') {
         continue;
       }
 
-      if (!versionedDataPerStorageTag.hasOwnProperty(addOn.storageResourceTag)) {
+      if (
+        !versionedDataPerStorageTag.hasOwnProperty(addOn.storageResourceTag)
+      ) {
         versionedDataPerStorageTag[addOn.storageResourceTag] = [];
       }
 
@@ -365,22 +423,25 @@ async function createGetDataDetails(_izContext, objectSchema, settings = { bucke
     }
   }
 
-  _izContext.logger.debug("versionedDataPerStorageTag: ", versionedDataPerStorageTag);
-
+  _izContext.logger.debug(
+    'versionedDataPerStorageTag: ',
+    versionedDataPerStorageTag
+  );
 
   let getGraphDataDetails = {};
   let getDynamoDbDataDetails = {};
 
-
   // reference to graph serviceTag that already used
-  let graphStorageTagPerGraphServiceTag = {} // {serviceTag:storageTag,... }
-
-
-  for (let [storageTag, storageData] of Object.entries(objectSchema.storageResources)) {
+  let graphStorageTagPerGraphServiceTag = {}; // {serviceTag:storageTag,... }
 
+  for (let [storageTag, storageData] of Object.entries(
+    objectSchema.storageResources
+  )) {
     // collect fieldNames per storageTag
     let storageTagFieldNames = [];
-    for (let [fieldName, fieldNameData] of Object.entries(objectSchema.fieldNames)) {
+    for (let [fieldName, fieldNameData] of Object.entries(
+      objectSchema.fieldNames
+    )) {
       // if (fieldName.startsWith("versionedDataField")) {
       //   continue;
       // }
@@ -391,52 +452,61 @@ async function createGetDataDetails(_izContext, objectSchema, settings = { bucke
     }
 
     if (storageData.storageType === coreConsts.STORAGE_TYPES.graph) {
-
       let useStorageTag = storageTag;
-      let graphServiceTag = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageData.graphServerTag, settings.bucketName);
+      let graphServiceTag = await serviceConfig.getGraphServiceTagWithCache(
+        _izContext,
+        storageData.graphServerTag,
+        settings.bucketName
+      );
 
       // check duplicate graph serviceTag
       if (!graphStorageTagPerGraphServiceTag.hasOwnProperty(graphServiceTag)) {
         graphStorageTagPerGraphServiceTag[graphServiceTag] = storageTag;
       } else {
         // overwrite useStorageTag if graphServiceTag already used
-        _izContext.logger.debug("current storageTag: ", storageTag);
-        _izContext.logger.debug("use storageTag: ", useStorageTag);
+        _izContext.logger.debug('current storageTag: ', storageTag);
+        _izContext.logger.debug('use storageTag: ', useStorageTag);
 
         useStorageTag = graphStorageTagPerGraphServiceTag[graphServiceTag];
       }
 
-
       if (!getGraphDataDetails.hasOwnProperty(useStorageTag)) {
         getGraphDataDetails[useStorageTag] = {
           storageType: storageData.storageType,
           graphServiceTag: graphServiceTag,
           fieldNames: storageTagFieldNames
-        }
+        };
       } else {
-        getGraphDataDetails[useStorageTag].fieldNames =
-          [...new Set(getGraphDataDetails[useStorageTag].fieldNames.concat(storageTagFieldNames))];
+        getGraphDataDetails[useStorageTag].fieldNames = [
+          ...new Set(
+            getGraphDataDetails[useStorageTag].fieldNames.concat(
+              storageTagFieldNames
+            )
+          )
+        ];
       }
 
-
       // add versionedData fieldNames
       if (versionedDataPerStorageTag.hasOwnProperty(storageTag)) {
-        if (!getGraphDataDetails[useStorageTag].hasOwnProperty("versionedDatas")) {
+        if (
+          !getGraphDataDetails[useStorageTag].hasOwnProperty('versionedDatas')
+        ) {
           getGraphDataDetails[useStorageTag].versionedDatas = {};
         }
 
         for (let versionedData of versionedDataPerStorageTag[storageTag]) {
-          _izContext.logger.debug("versionedData.fieldNames", versionedData.fieldNames)
+          _izContext.logger.debug(
+            'versionedData.fieldNames',
+            versionedData.fieldNames
+          );
           let versionedDataFieldNames = Object.keys(versionedData.fieldNames);
-          Object.assign(
-            getGraphDataDetails[useStorageTag].versionedDatas,
-            { [versionedData.versionedDataLabel]: versionedDataFieldNames }
-          )
+          Object.assign(getGraphDataDetails[useStorageTag].versionedDatas, {
+            [versionedData.versionedDataLabel]: versionedDataFieldNames
+          });
         }
       }
-
     } else if (storageData.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
-      let serviceTag = storageData.serviceTag || process.env.iz_serviceTag
+      let serviceTag = storageData.serviceTag || process.env.iz_serviceTag;
       Object.assign(getDynamoDbDataDetails, {
         [storageTag]: {
           storageType: storageData.storageType,
@@ -444,57 +514,64 @@ async function createGetDataDetails(_izContext, objectSchema, settings = { bucke
           serviceTag: serviceTag,
           fieldNames: storageTagFieldNames
         }
-      })
+      });
 
       if (storageData.groupByPartitionKeyField) {
-        Object.assign(
-          getDynamoDbDataDetails[storageTag],
-          {
-            groupByPartitionKeyField: storageData.groupByPartitionKeyField
-          }
-        )
+        Object.assign(getDynamoDbDataDetails[storageTag], {
+          groupByPartitionKeyField: storageData.groupByPartitionKeyField
+        });
       }
-
-
     } else {
-      throw new NoRetryError("Unhanled storageType");
+      throw new NoRetryError('Unhanled storageType');
     }
   }
 
-  _izContext.logger.debug("getGraphDataDetail: ", getGraphDataDetails);
-  _izContext.logger.debug("getDynamoDbData: ", getDynamoDbDataDetails);
-
+  _izContext.logger.debug('getGraphDataDetail: ', getGraphDataDetails);
+  _izContext.logger.debug('getDynamoDbData: ', getDynamoDbDataDetails);
 
   //-------- sort descending order of fieldNames.length --------
   let sortedGetGraphWithVersionedData = Object.entries(getGraphDataDetails)
-    .filter((getGraphDetail) => getGraphDetail[1].hasOwnProperty("versionedDatas"))
-    .sort((storageDataA, storageDataB) =>
-      storageDataB[1].fieldNames.length - storageDataA[1].fieldNames.length
+    .filter(getGraphDetail =>
+      getGraphDetail[1].hasOwnProperty('versionedDatas')
+    )
+    .sort(
+      (storageDataA, storageDataB) =>
+        storageDataB[1].fieldNames.length - storageDataA[1].fieldNames.length
     );
 
-  _izContext.logger.debug("sortedGetGraphWithVersionedData: ", sortedGetGraphWithVersionedData);
-
+  _izContext.logger.debug(
+    'sortedGetGraphWithVersionedData: ',
+    sortedGetGraphWithVersionedData
+  );
 
   let sortedGetGraphWithoutVersionedData = Object.entries(getGraphDataDetails)
-    .filter((getGraphDetail) => !getGraphDetail[1].hasOwnProperty("versionedDatas"))
-    .sort((storageDataA, storageDataB) =>
-      storageDataB[1].fieldNames.length - storageDataA[1].fieldNames.length
+    .filter(
+      getGraphDetail => !getGraphDetail[1].hasOwnProperty('versionedDatas')
+    )
+    .sort(
+      (storageDataA, storageDataB) =>
+        storageDataB[1].fieldNames.length - storageDataA[1].fieldNames.length
     );
 
-  _izContext.logger.debug("sortedGetGraphWithoutVersionedData: ", sortedGetGraphWithoutVersionedData);
-
-
-  let sortedGetDynamoDbData = Object.entries(getDynamoDbDataDetails).sort((storageDataA, storageDataB) =>
-    storageDataB[1].fieldNames.length - storageDataA[1].fieldNames.length
+  _izContext.logger.debug(
+    'sortedGetGraphWithoutVersionedData: ',
+    sortedGetGraphWithoutVersionedData
   );
 
-  _izContext.logger.debug("sortedGetDynamoDbData: ", sortedGetDynamoDbData);
+  let sortedGetDynamoDbData = Object.entries(getDynamoDbDataDetails).sort(
+    (storageDataA, storageDataB) =>
+      storageDataB[1].fieldNames.length - storageDataA[1].fieldNames.length
+  );
 
+  _izContext.logger.debug('sortedGetDynamoDbData: ', sortedGetDynamoDbData);
 
   // after sort data then filter duplicate fieldName
-  let allSortedGetDataDetails = [...sortedGetGraphWithVersionedData, ...sortedGetDynamoDbData, ...sortedGetGraphWithoutVersionedData];
-  _izContext.logger.debug("allSortedGetDataDetails: ", allSortedGetDataDetails);
-
+  let allSortedGetDataDetails = [
+    ...sortedGetGraphWithVersionedData,
+    ...sortedGetDynamoDbData,
+    ...sortedGetGraphWithoutVersionedData
+  ];
+  _izContext.logger.debug('allSortedGetDataDetails: ', allSortedGetDataDetails);
 
   let usedFieldName = [];
   for (let [storageTag, getDataDetail] of allSortedGetDataDetails) {
@@ -510,22 +587,26 @@ async function createGetDataDetails(_izContext, objectSchema, settings = { bucke
     getDataDetail.fieldNames = remainsFieldNames;
   }
 
-  _izContext.logger.debug("newSortedArray after: ", allSortedGetDataDetails);
-
+  _izContext.logger.debug('newSortedArray after: ', allSortedGetDataDetails);
 
   let getDataDetailResults = Object.fromEntries(
     allSortedGetDataDetails.filter(([storageTag, getDataDetail]) => {
-      return (getDataDetail.fieldNames.length || getDataDetail.hasOwnProperty("versionedDatas"));
+      return (
+        getDataDetail.fieldNames.length ||
+        getDataDetail.hasOwnProperty('versionedDatas')
+      );
     })
   );
 
-  _izContext.logger.debug("getDataDetailResults: ", getDataDetailResults);
+  _izContext.logger.debug('getDataDetailResults: ', getDataDetailResults);
 
   for (const getDataDetail of Object.values(getDataDetailResults)) {
-    if (getDataDetail.hasOwnProperty("versionedDatas")) {
+    if (getDataDetail.hasOwnProperty('versionedDatas')) {
       getDataDetail.versionedDataLabels = [];
-      for (let [versionedDataLabel, fieldNames] of Object.entries(getDataDetail.versionedDatas)) {
-        getDataDetail.versionedDataLabels.push(versionedDataLabel)
+      for (let [versionedDataLabel, fieldNames] of Object.entries(
+        getDataDetail.versionedDatas
+      )) {
+        getDataDetail.versionedDataLabels.push(versionedDataLabel);
         getDataDetail.fieldNames.push(...fieldNames);
       }
     }
@@ -534,7 +615,6 @@ async function createGetDataDetails(_izContext, objectSchema, settings = { bucke
   return getDataDetailResults;
 }
 
-
 /**
  * create dynamoDb identifiers using request param and objectSchema
  *
@@ -542,24 +622,41 @@ async function createGetDataDetails(_izContext, objectSchema, settings = { bucke
  * @param {Object} objectSchema
  * @param {Object} reqIdentifiers       - input identifier from calling function
  */
-async function generateDynamoDbIdentifiers(_izContext, objectSchema, reqIdentifiers, bucketName = process.env.iz_serviceSchemaBucketName) {
-
+async function generateDynamoDbIdentifiers(
+  _izContext,
+  objectSchema,
+  reqIdentifiers,
+  bucketName = process.env.iz_serviceSchemaBucketName
+) {
   // start create identifiers for dynamo
   let dynamoIdentifiers = {};
 
   for (let identifier of objectSchema.identifiers) {
     if (identifier.name) {
-      let deliminator = identifier.deliminator || coreConsts.DEFAULT_IDENTIFIER_DELIMINATOR;
+      let deliminator =
+        identifier.deliminator || coreConsts.DEFAULT_IDENTIFIER_DELIMINATOR;
       let currentDeliminatorAmount = 0;
 
       let concatenateValue = [];
       for (let fieldName of identifier.fieldNames) {
         concatenateValue.push(reqIdentifiers[fieldName]);
 
-        let deliminatorTreeFieldName = await deliminatorTree.generateDeliminatorTreePerFieldName(_izContext, fieldName, objectSchema.fieldNames[fieldName], {}, bucketName);
-        _izContext.logger.debug("deliminatorTreeFieldName: ", deliminatorTreeFieldName);
+        let deliminatorTreeFieldName =
+          await deliminatorTree.generateDeliminatorTreePerFieldName(
+            _izContext,
+            fieldName,
+            objectSchema.fieldNames[fieldName],
+            {},
+            bucketName
+          );
+        _izContext.logger.debug(
+          'deliminatorTreeFieldName: ',
+          deliminatorTreeFieldName
+        );
 
-        if (deliminatorTreeFieldName[fieldName]?.deliminatorList?.[deliminator]) {
+        if (
+          deliminatorTreeFieldName[fieldName]?.deliminatorList?.[deliminator]
+        ) {
           currentDeliminatorAmount = Math.max(
             currentDeliminatorAmount,
             deliminatorTreeFieldName[fieldName].deliminatorList[deliminator]
@@ -567,28 +664,23 @@ async function generateDynamoDbIdentifiers(_izContext, objectSchema, reqIdentifi
         }
       }
 
-      Object.assign(
-        dynamoIdentifiers,
-        {
-          [identifier.name]: concatenateValue.join(deliminator.repeat(currentDeliminatorAmount + 1))
-        }
-      );
+      Object.assign(dynamoIdentifiers, {
+        [identifier.name]: concatenateValue.join(
+          deliminator.repeat(currentDeliminatorAmount + 1)
+        )
+      });
     } else {
-      Object.assign(
-        dynamoIdentifiers,
-        {
-          [identifier.fieldName]: reqIdentifiers[identifier.fieldName]
-        }
-      )
+      Object.assign(dynamoIdentifiers, {
+        [identifier.fieldName]: reqIdentifiers[identifier.fieldName]
+      });
     }
   }
 
-  _izContext.logger.debug("dynamoIdentifiers: ", dynamoIdentifiers);
+  _izContext.logger.debug('dynamoIdentifiers: ', dynamoIdentifiers);
 
   return dynamoIdentifiers;
 }
 
-
 /**
  * create dynamoDb identifiers using request param and objectSchema
  *
@@ -598,13 +690,17 @@ async function generateDynamoDbIdentifiers(_izContext, objectSchema, reqIdentifi
  */
 const generateDynamoDbIdentifiersWithCache = inMemoryCacheLib(
   generateDynamoDbIdentifiers, // fn
-  { // setting
-    max: 20, maxAge: 86400000, promise: true, profileName: 'generateDynamoDbIdentifiers',
+  {
+    // setting
+    max: 20,
+    maxAge: 86400000,
+    promise: true,
+    profileName: 'generateDynamoDbIdentifiers',
     normalizer: function (args) {
-      return hash([args[1], args[2]])
+      return hash([args[1], args[2]]);
     }
   }
-)
+);
 
 /**
  *
@@ -613,25 +709,45 @@ const generateDynamoDbIdentifiersWithCache = inMemoryCacheLib(
  * @param {Object} dynamoStorageResource
  * @param {Object} reqIdentifiers
  */
-async function dynamoDbIdentifiersByStorageResource(_izContext, objectSchema, dynamoStorageResource, reqIdentifiers, bucketName = process.env.iz_serviceSchemaBucketName) {
-
-  let dynamoIdentifiers = await generateDynamoDbIdentifiersWithCache(_izContext, objectSchema, reqIdentifiers, bucketName)
+async function dynamoDbIdentifiersByStorageResource(
+  _izContext,
+  objectSchema,
+  dynamoStorageResource,
+  reqIdentifiers,
+  bucketName = process.env.iz_serviceSchemaBucketName
+) {
+  let dynamoIdentifiers = await generateDynamoDbIdentifiersWithCache(
+    _izContext,
+    objectSchema,
+    reqIdentifiers,
+    bucketName
+  );
 
   let identifiersByStorageResource = {};
 
   if (dynamoStorageResource.groupByPartitionKeyField) {
+    let deliminatorTreeIdentifiers =
+      await deliminatorTree.generateDeliminatorTreeIdentifier(
+        _izContext,
+        objectSchema,
+        bucketName
+      );
+    _izContext.logger.debug('deliminatorTree: ', deliminatorTreeIdentifiers);
 
-    let deliminatorTreeIdentifiers = await deliminatorTree.generateDeliminatorTreeIdentifier(_izContext, objectSchema, bucketName);
-    _izContext.logger.debug("deliminatorTree: ", deliminatorTreeIdentifiers);
-
-    let compositeKeyDeliminator = objectSchema.compositeKeyDeliminator || coreConsts.DEFAULT_IDENTIFIER_DELIMINATOR;
+    let compositeKeyDeliminator =
+      objectSchema.compositeKeyDeliminator ||
+      coreConsts.DEFAULT_IDENTIFIER_DELIMINATOR;
 
     let currentDeliminatorAmount = 0;
 
     for (let currentDeliminator of Object.values(deliminatorTreeIdentifiers)) {
       if (currentDeliminator.deliminator === compositeKeyDeliminator) {
-        if (currentDeliminatorAmount < currentDeliminator.deliminatorList[compositeKeyDeliminator]) {
-          currentDeliminatorAmount = currentDeliminator.deliminatorList[compositeKeyDeliminator];
+        if (
+          currentDeliminatorAmount <
+          currentDeliminator.deliminatorList[compositeKeyDeliminator]
+        ) {
+          currentDeliminatorAmount =
+            currentDeliminator.deliminatorList[compositeKeyDeliminator];
         }
       }
     }
@@ -643,12 +759,13 @@ async function dynamoDbIdentifiersByStorageResource(_izContext, objectSchema, dy
       sortedIdentifiersValue.push(dynamoIdentifiers[identifierName]);
     }
 
-    let newIdentifierValue = sortedIdentifiersValue.join(compositeKeyDeliminator.repeat(currentDeliminatorAmount + 1));
+    let newIdentifierValue = sortedIdentifiersValue.join(
+      compositeKeyDeliminator.repeat(currentDeliminatorAmount + 1)
+    );
 
     identifiersByStorageResource = {
       [dynamoStorageResource.groupByPartitionKeyField]: newIdentifierValue
     };
-
   } else {
     identifiersByStorageResource = dynamoIdentifiers;
   }
@@ -656,7 +773,6 @@ async function dynamoDbIdentifiersByStorageResource(_izContext, objectSchema, dy
   return identifiersByStorageResource;
 }
 
-
 /**
  * receive result from multiple database and create data format depend on returnFormat setting
  *
@@ -665,23 +781,29 @@ async function dynamoDbIdentifiersByStorageResource(_izContext, objectSchema, dy
  * @param {object} objectSchema
  * @returns
  */
-function collectGetData(_izContext, getResults, objectSchema, returnSystemFieldsName) {
-  _izContext.logger.debug("collectGetData: ", {
+function collectGetData(
+  _izContext,
+  getResults,
+  objectSchema,
+  returnSystemFieldsName
+) {
+  _izContext.logger.debug('collectGetData: ', {
     getResults,
     objectSchema,
     returnSystemFieldsName
   });
 
-
   let collectedData = {
     identifiers: {},
     fields: {}
-  }
+  };
 
   if (returnSystemFieldsName) {
-    Object.assign(collectedData, { versionDataSystemFields: {} })
+    Object.assign(collectedData, { versionDataSystemFields: {} });
   }
-  const identifierFieldNames = new Set(utils.getUsedFieldNamesOfIdentifiers(_izContext, objectSchema.identifiers));
+  const identifierFieldNames = new Set(
+    utils.getUsedFieldNamesOfIdentifiers(_izContext, objectSchema.identifiers)
+  );
 
   let addedFieldNames = new Set();
 
@@ -695,33 +817,58 @@ function collectGetData(_izContext, getResults, objectSchema, returnSystemFields
 
     // this process will add result from graph and dynamo to collectedData object by add identifiers and fieldName from getData
     if (getDataDetail.storageType === coreConsts.STORAGE_TYPES.graph) {
-      if (getData.returnValue.queryResults.refactoredNodes.objInstanceFull && Object.keys(getData.returnValue.queryResults.refactoredNodes.objInstanceFull).length) {
+      if (
+        getData.returnValue.queryResults.refactoredNodes.objInstanceFull &&
+        Object.keys(
+          getData.returnValue.queryResults.refactoredNodes.objInstanceFull
+        ).length
+      ) {
         for (const getDetailFieldName of getDataDetail.fieldNames) {
           if (addedFieldNames.has(getDetailFieldName)) {
             continue;
           }
 
-          if (getData.returnValue.queryResults.refactoredNodes.objInstanceFull.identifiers.hasOwnProperty(getDetailFieldName)) {
-            Object.assign(
-              collectedData.identifiers,
-              { [getDetailFieldName]: getData.returnValue.queryResults.refactoredNodes.objInstanceFull.identifiers[getDetailFieldName] }
-            );
+          if (
+            getData.returnValue.queryResults.refactoredNodes.objInstanceFull.identifiers.hasOwnProperty(
+              getDetailFieldName
+            )
+          ) {
+            Object.assign(collectedData.identifiers, {
+              [getDetailFieldName]:
+                getData.returnValue.queryResults.refactoredNodes.objInstanceFull
+                  .identifiers[getDetailFieldName]
+            });
             addedFieldNames.add(getDetailFieldName);
             isFound = true;
-          } else if (getData.returnValue.queryResults.refactoredNodes.objInstanceFull.fields.hasOwnProperty(getDetailFieldName)) {
-            Object.assign(
-              collectedData.fields,
-              { [getDetailFieldName]: getData.returnValue.queryResults.refactoredNodes.objInstanceFull.fields[getDetailFieldName] }
-            );
+          } else if (
+            getData.returnValue.queryResults.refactoredNodes.objInstanceFull.fields.hasOwnProperty(
+              getDetailFieldName
+            )
+          ) {
+            Object.assign(collectedData.fields, {
+              [getDetailFieldName]:
+                getData.returnValue.queryResults.refactoredNodes.objInstanceFull
+                  .fields[getDetailFieldName]
+            });
             addedFieldNames.add(getDetailFieldName);
             isFound = true;
           }
         }
       }
-      if (getData.returnValue.queryResults.refactoredNodes.versionDataSystemFields || returnSystemFieldsName == true) {
-        Object.assign(collectedData.versionDataSystemFields, getData.returnValue.queryResults.refactoredNodes.versionDataSystemFields)
+      if (
+        getData.returnValue.queryResults.refactoredNodes
+          .versionDataSystemFields ||
+        returnSystemFieldsName == true
+      ) {
+        Object.assign(
+          collectedData.versionDataSystemFields,
+          getData.returnValue.queryResults.refactoredNodes
+            .versionDataSystemFields
+        );
       }
-    } else if (getDataDetail.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
+    } else if (
+      getDataDetail.storageType === coreConsts.STORAGE_TYPES.dynamoDB
+    ) {
       for (const getDetailFieldName of getDataDetail.fieldNames) {
         if (addedFieldNames.has(getDetailFieldName)) {
           continue;
@@ -729,24 +876,22 @@ function collectGetData(_izContext, getResults, objectSchema, returnSystemFields
 
         if (getData.hasOwnProperty(getDetailFieldName)) {
           if (identifierFieldNames.has(getDetailFieldName)) {
-            Object.assign(
-              collectedData.identifiers,
-              { [getDetailFieldName]: getData[getDetailFieldName] }
-            );
+            Object.assign(collectedData.identifiers, {
+              [getDetailFieldName]: getData[getDetailFieldName]
+            });
             addedFieldNames.add(getDetailFieldName);
             isFound = true;
           } else {
-            Object.assign(
-              collectedData.fields,
-              { [getDetailFieldName]: getData[getDetailFieldName] }
-            );
+            Object.assign(collectedData.fields, {
+              [getDetailFieldName]: getData[getDetailFieldName]
+            });
             addedFieldNames.add(getDetailFieldName);
             isFound = true;
           }
         }
       }
     } else {
-      throw new NoRetryError("collectGetData unhandled storageType");
+      throw new NoRetryError('collectGetData unhandled storageType');
     }
   }
 
@@ -757,44 +902,67 @@ function collectGetData(_izContext, getResults, objectSchema, returnSystemFields
   }
 }
 
-
-async function createUpdateDataDetail(_izContext, objectSchema, settings = { bucketName: process.env.iz_serviceSchemaBucketName }) {
+async function createUpdateDataDetail(
+  _izContext,
+  objectSchema,
+  settings = { bucketName: process.env.iz_serviceSchemaBucketName }
+) {
   let getGraphDataDetails = {};
   let getDynamoDbDataDetails = {};
   let allUpdateDataDetail = {};
-  for (let [storageTag, storageProperties] of Object.entries(objectSchema.storageResources)) {
+  for (let [storageTag, storageProperties] of Object.entries(
+    objectSchema.storageResources
+  )) {
     let storageFieldNames = [];
-    for (let [fieldName, fieldNameProperties] of Object.entries(objectSchema.fieldNames)) {
+    for (let [fieldName, fieldNameProperties] of Object.entries(
+      objectSchema.fieldNames
+    )) {
       if (fieldNameProperties.storageResourceTags.includes(storageTag)) {
-        let versionedDataLabel = fieldNameProperties.versionedDataLabel
-        if (!fieldName.includes(versionedDataLabel)) { // not get fieldNames VersionedData_VersionedDataLabel_VersionedDataFieldNames
-          storageFieldNames.push(fieldName)
+        let versionedDataLabel = fieldNameProperties.versionedDataLabel;
+        if (!fieldName.includes(versionedDataLabel)) {
+          // not get fieldNames VersionedData_VersionedDataLabel_VersionedDataFieldNames
+          storageFieldNames.push(fieldName);
         }
       }
     }
     if (storageProperties.storageType === coreConsts.STORAGE_TYPES.graph) {
-      let graphStorageTagPerGraphServiceTag = {}
+      let graphStorageTagPerGraphServiceTag = {};
       let useStorageTag = storageTag;
-      let graphServiceName = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageProperties.graphServerTag, settings.bucketName)
+      let graphServiceName = await serviceConfig.getGraphServiceTagWithCache(
+        _izContext,
+        storageProperties.graphServerTag,
+        settings.bucketName
+      );
       if (!graphStorageTagPerGraphServiceTag.hasOwnProperty(graphServiceName)) {
         graphStorageTagPerGraphServiceTag[graphServiceName] = storageTag;
-        _izContext.logger.debug("graphStorageTagPerGraphServiceTag", graphStorageTagPerGraphServiceTag)
+        _izContext.logger.debug(
+          'graphStorageTagPerGraphServiceTag',
+          graphStorageTagPerGraphServiceTag
+        );
       } else {
-        _izContext.logger.debug("current storageTag", storageTag)
-        _izContext.logger.debug("used storageTag", useStorageTag)
-        useStorageTag = graphStorageTagPerGraphServiceTag[graphServiceName]
+        _izContext.logger.debug('current storageTag', storageTag);
+        _izContext.logger.debug('used storageTag', useStorageTag);
+        useStorageTag = graphStorageTagPerGraphServiceTag[graphServiceName];
       }
       if (!getGraphDataDetails.hasOwnProperty(useStorageTag)) {
-        getGraphDataDetails[graphServiceName] =
-        {
+        getGraphDataDetails[graphServiceName] = {
           storageType: storageProperties.storageType,
           fieldNames: storageFieldNames
-        }
+        };
       } else {
-        getGraphDataDetails[graphServiceName].fieldNames = [...new Set(getGraphDataDetails[useStorageTag].fieldNames.concat(storageFieldNames))]
+        getGraphDataDetails[graphServiceName].fieldNames = [
+          ...new Set(
+            getGraphDataDetails[useStorageTag].fieldNames.concat(
+              storageFieldNames
+            )
+          )
+        ];
       }
-    } else if (storageProperties.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
-      let serviceTag = storageProperties.serviceTag || process.env.iz_serviceTag;
+    } else if (
+      storageProperties.storageType === coreConsts.STORAGE_TYPES.dynamoDB
+    ) {
+      let serviceTag =
+        storageProperties.serviceTag || process.env.iz_serviceTag;
       Object.assign(getDynamoDbDataDetails, {
         [storageTag]: {
           storageType: storageProperties.storageType,
@@ -802,28 +970,35 @@ async function createUpdateDataDetail(_izContext, objectSchema, settings = { buc
           serviceTag: serviceTag,
           fieldNames: storageFieldNames
         }
-      })
+      });
 
       if (storageTag.groupByPartitionKeyField) {
-        Object.assign(
-          getDynamoDbDataDetails[storageTag],
-          {
-            groupByPartitionKeyField: storageProperties.groupByPartitionKeyField
-          }
-        )
+        Object.assign(getDynamoDbDataDetails[storageTag], {
+          groupByPartitionKeyField: storageProperties.groupByPartitionKeyField
+        });
       }
     }
   }
 
-  _izContext.logger.debug("getGraphDataDetails", getGraphDataDetails);
-  _izContext.logger.debug("getDynamoDataDetail", getDynamoDbDataDetails);
+  _izContext.logger.debug('getGraphDataDetails', getGraphDataDetails);
+  _izContext.logger.debug('getDynamoDataDetail', getDynamoDbDataDetails);
 
-  Object.assign(allUpdateDataDetail, getDynamoDbDataDetails, getGraphDataDetails);
-  return allUpdateDataDetail
+  Object.assign(
+    allUpdateDataDetail,
+    getDynamoDbDataDetails,
+    getGraphDataDetails
+  );
+  return allUpdateDataDetail;
 }
 
-async function createDataDetailsLib(_izContext, objectSchemas, settings = { bucketName: process.env.iz_serviceSchemaBucketName }) {
-  _izContext.logger.debug("Lib: createDataDetailsLib:", { objectSchemas: objectSchemas });
+async function createDataDetailsLib(
+  _izContext,
+  objectSchemas,
+  settings = { bucketName: process.env.iz_serviceSchemaBucketName }
+) {
+  _izContext.logger.debug('Lib: createDataDetailsLib:', {
+    objectSchemas: objectSchemas
+  });
   /**
    * TODO: crate DataDetail now will get parent objectSchema if have extendObjType
    * will split fieldNames for each serviceTag and storageREsourceTags
@@ -832,9 +1007,11 @@ async function createDataDetailsLib(_izContext, objectSchemas, settings = { buck
   let createDataDetails = {};
 
   let storageResources = objectSchemas.storageResources;
-  _izContext.logger.debug("storageResources:", storageResources);
+  _izContext.logger.debug('storageResources:', storageResources);
 
-  for (let [keyFieldName, settingFieldName] of Object.entries(objectSchemas.fieldNames)) {
+  for (let [keyFieldName, settingFieldName] of Object.entries(
+    objectSchemas.fieldNames
+  )) {
     // _izContext.logger.debug("Loop fieldNamesObjectSchemas", { keyFieldName });
 
     for (let eachStorageResourceTag of settingFieldName.storageResourceTags) {
@@ -843,38 +1020,55 @@ async function createDataDetailsLib(_izContext, objectSchemas, settings = { buck
       if (!storageResources.hasOwnProperty(eachStorageResourceTag)) {
         throw new Error("storageResources is'n exist"); // should be validate in step upload in s3
       } else {
-        if (storageResources[eachStorageResourceTag].storageType == coreConsts.STORAGE_TYPES.dynamoDB) {
+        if (
+          storageResources[eachStorageResourceTag].storageType ==
+          coreConsts.STORAGE_TYPES.dynamoDB
+        ) {
           if (createDataDetails.hasOwnProperty(eachStorageResourceTag)) {
             // _izContext.logger.debug("SAME STG DB", eachStorageResourceTag);
-            createDataDetails[eachStorageResourceTag].fieldNames.push(keyFieldName);
-
+            createDataDetails[eachStorageResourceTag].fieldNames.push(
+              keyFieldName
+            );
           } else {
             Object.assign(createDataDetails, {
               [eachStorageResourceTag]: {
                 storageType: coreConsts.STORAGE_TYPES.dynamoDB,
                 tableName: storageResources[eachStorageResourceTag].tableName,
-                serviceTag: storageResources[eachStorageResourceTag].serviceTag || process.env.iz_serviceTag,
+                serviceTag:
+                  storageResources[eachStorageResourceTag].serviceTag ||
+                  process.env.iz_serviceTag,
                 fieldNames: [keyFieldName]
               }
             });
 
-            if (storageResources[eachStorageResourceTag].hasOwnProperty("groupByPartitionKeyField")) {
+            if (
+              storageResources[eachStorageResourceTag].hasOwnProperty(
+                'groupByPartitionKeyField'
+              )
+            ) {
               Object.assign(createDataDetails[eachStorageResourceTag], {
-                groupByPartitionKeyField: storageResources[eachStorageResourceTag].groupByPartitionKeyField
+                groupByPartitionKeyField:
+                  storageResources[eachStorageResourceTag]
+                    .groupByPartitionKeyField
               });
             }
           }
-        } else if (storageResources[eachStorageResourceTag].storageType == coreConsts.STORAGE_TYPES.graph) {
-          let checkGraphServerTags = await serviceConfig.getGraphServiceTagWithCache(
-            _izContext,
-            storageResources[eachStorageResourceTag].graphServerTag,
-            settings.bucketName
-          );
+        } else if (
+          storageResources[eachStorageResourceTag].storageType ==
+          coreConsts.STORAGE_TYPES.graph
+        ) {
+          let checkGraphServerTags =
+            await serviceConfig.getGraphServiceTagWithCache(
+              _izContext,
+              storageResources[eachStorageResourceTag].graphServerTag,
+              settings.bucketName
+            );
           if (checkGraphServerTags) {
             if (createDataDetails.hasOwnProperty(checkGraphServerTags)) {
               // _izContext.logger.debug("SAME STG", checkGraphServerTags);
-              createDataDetails[checkGraphServerTags].fieldNames.push(keyFieldName)
-
+              createDataDetails[checkGraphServerTags].fieldNames.push(
+                keyFieldName
+              );
             } else {
               // _izContext.logger.debug("NEW STG", checkGraphServerTags);
               Object.assign(createDataDetails, {
@@ -883,10 +1077,16 @@ async function createDataDetailsLib(_izContext, objectSchemas, settings = { buck
                   fieldNames: [keyFieldName]
                 }
               });
-            };
-          };
-        } else if (storageResources[eachStorageResourceTag].storageType === coreConsts.STORAGE_TYPES.externalTopic) {
-          let topicName = storageResources[eachStorageResourceTag].serviceTag + storageResources[eachStorageResourceTag].stage + storageResources[eachStorageResourceTag].topicName
+            }
+          }
+        } else if (
+          storageResources[eachStorageResourceTag].storageType ===
+          coreConsts.STORAGE_TYPES.externalTopic
+        ) {
+          let topicName =
+            storageResources[eachStorageResourceTag].serviceTag +
+            storageResources[eachStorageResourceTag].stage +
+            storageResources[eachStorageResourceTag].topicName;
           Object.assign(createDataDetails, {
             [topicName]: {
               storageType: coreConsts.STORAGE_TYPES.externalTopic,
@@ -898,89 +1098,110 @@ async function createDataDetailsLib(_izContext, objectSchemas, settings = { buck
             }
           });
         }
-      };
-    }; // end loop storageResourceTags
-  }; // end loop
+      }
+    } // end loop storageResourceTags
+  } // end loop
 
   return createDataDetails;
-};
+}
 
-async function createDeleteDataDetail(_izContext, objectSchema, settings = { bucketName: process.env.iz_serviceSchemaBucketName }) {
+async function createDeleteDataDetail(
+  _izContext,
+  objectSchema,
+  settings = { bucketName: process.env.iz_serviceSchemaBucketName }
+) {
   let deleteDynamoDataDetail = {};
   let deleteGraphDataDetail = {};
   let allDeleteDataDetail = {};
 
-  for (let [storageTag, storageProperties] of Object.entries(objectSchema.storageResources)) {
+  for (let [storageTag, storageProperties] of Object.entries(
+    objectSchema.storageResources
+  )) {
     if (storageProperties.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
-      let serviceTag = storageProperties.serviceTag || process.env.iz_serviceTag;
+      let serviceTag =
+        storageProperties.serviceTag || process.env.iz_serviceTag;
       Object.assign(deleteDynamoDataDetail, {
         [storageTag]: {
           storageType: storageProperties.storageType,
           serviceTag: serviceTag,
           tableName: storageProperties.tableName
         }
-      })
+      });
       if (storageProperties.groupByPartitionKeyField) {
-        Object.assign(
-          deleteDynamoDataDetail[storageTag],
-          {
-            groupByPartitionKeyField: storageProperties.groupByPartitionKeyField
-          }
-        )
+        Object.assign(deleteDynamoDataDetail[storageTag], {
+          groupByPartitionKeyField: storageProperties.groupByPartitionKeyField
+        });
       }
-    } else if (storageProperties.storageType === coreConsts.STORAGE_TYPES.graph) {
+    } else if (
+      storageProperties.storageType === coreConsts.STORAGE_TYPES.graph
+    ) {
       let dataDetailPerGraphStorage = {};
-      let useStorageTag = storageTag
-      let graphServiceName = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageProperties.graphServerTag, settings.bucketName);
+      let useStorageTag = storageTag;
+      let graphServiceName = await serviceConfig.getGraphServiceTagWithCache(
+        _izContext,
+        storageProperties.graphServerTag,
+        settings.bucketName
+      );
       if (!dataDetailPerGraphStorage.hasOwnProperty(graphServiceName)) {
         dataDetailPerGraphStorage[graphServiceName] = storageTag;
       } else {
-        useStorageTag = dataDetailPerGraphStorage[graphServiceName]
+        useStorageTag = dataDetailPerGraphStorage[graphServiceName];
       }
       if (!deleteGraphDataDetail.hasOwnProperty(useStorageTag)) {
-        deleteGraphDataDetail[graphServiceName] =
-        {
-          storageType: storageProperties.storageType,
-        }
+        deleteGraphDataDetail[graphServiceName] = {
+          storageType: storageProperties.storageType
+        };
       }
     }
   }
-  _izContext.logger.debug("deleteGraphDataDetail", deleteGraphDataDetail);
-  _izContext.logger.debug("deleteDynamoDataDetail", deleteDynamoDataDetail);
-  Object.assign(allDeleteDataDetail, deleteGraphDataDetail, deleteDynamoDataDetail)
+  _izContext.logger.debug('deleteGraphDataDetail', deleteGraphDataDetail);
+  _izContext.logger.debug('deleteDynamoDataDetail', deleteDynamoDataDetail);
+  Object.assign(
+    allDeleteDataDetail,
+    deleteGraphDataDetail,
+    deleteDynamoDataDetail
+  );
 
-  _izContext.logger.debug("allDeleteDataDetail", allDeleteDataDetail)
-  return allDeleteDataDetail
+  _izContext.logger.debug('allDeleteDataDetail', allDeleteDataDetail);
+  return allDeleteDataDetail;
 }
 
-function createFieldForUpdateDynamoDb(_izContext, objectSchema, dynamoDataDetail, fields) {
-  _izContext.logger.debug("createFieldForUpdateDynamoDb", {
+function createFieldForUpdateDynamoDb(
+  _izContext,
+  objectSchema,
+  dynamoDataDetail,
+  fields
+) {
+  _izContext.logger.debug('createFieldForUpdateDynamoDb', {
     objectSchema,
     dynamoDataDetail,
     fields
-  })
+  });
 
   let fieldsForUpdateDynamo = {};
 
-  for (let [fieldName, fieldSetting] of Object.entries(objectSchema.fieldNames)) {
-    if (fieldSetting.canUpdate == true || !fieldSetting.hasOwnProperty("canUpdate")) {
+  for (let [fieldName, fieldSetting] of Object.entries(
+    objectSchema.fieldNames
+  )) {
+    if (
+      fieldSetting.canUpdate == true ||
+      !fieldSetting.hasOwnProperty('canUpdate')
+    ) {
       if (dynamoDataDetail.fieldNames.includes(fieldName)) {
         if (fields[fieldName]) {
           if (!fieldsForUpdateDynamo.hasOwnProperty(fields[fieldName])) {
-            _izContext.logger.debug("assign new fieldName", (fields[fieldName]))
+            _izContext.logger.debug('assign new fieldName', fields[fieldName]);
             Object.assign(fieldsForUpdateDynamo, {
               [fieldName]: fields[fieldName]
-            }
-            )
+            });
           }
         }
       }
     }
   }
-  return fieldsForUpdateDynamo
+  return fieldsForUpdateDynamo;
 }
 
-
 /**
  *
  * @param {Object} from
@@ -996,15 +1217,27 @@ function createFieldForUpdateDynamoDb(_izContext, objectSchema, dynamoDataDetail
  * @param {Object} storageResources
  * @param {Boolean} topLevelParent
  */
-function createBasicRelationshipsProperties(from, to, storageResources, baseDirection, topLevelParent = false) {
-  validateObjType.validateObjType({ objectType: from.objectType, serviceTag: from.serviceTag });
-  validateObjType.validateObjType({ objectType: to.objectType, serviceTag: to.serviceTag });
+function createBasicRelationshipsProperties(
+  from,
+  to,
+  storageResources,
+  baseDirection,
+  topLevelParent = false
+) {
+  validateObjType.validateObjType({
+    objectType: from.objectType,
+    serviceTag: from.serviceTag
+  });
+  validateObjType.validateObjType({
+    objectType: to.objectType,
+    serviceTag: to.serviceTag
+  });
 
   let otherDirection;
-  if (baseDirection === "to") {
-    otherDirection = "from"
-  } else if (baseDirection === "from") {
-    otherDirection = "to"
+  if (baseDirection === 'to') {
+    otherDirection = 'from';
+  } else if (baseDirection === 'from') {
+    otherDirection = 'to';
   }
 
   let relationshipProperties = {
@@ -1042,51 +1275,66 @@ function createBasicRelationshipsProperties(from, to, storageResources, baseDire
           requiredOnCreate: to.requiredOnCreate
         }
       }
-    ],
-  }
+    ]
+  };
 
   if (topLevelParent === true) {
-    relationshipProperties.links.push(
-      {
-        storageResourceTags: Object.keys(storageResources),
-        from: {
-          objType: {
-            serviceTag: to.serviceTag,
-            objectType: to.objectType
-          },
-          linkType: "one",
-          direction: "from",
-          requiredOnCreate: false
+    relationshipProperties.links.push({
+      storageResourceTags: Object.keys(storageResources),
+      from: {
+        objType: {
+          serviceTag: to.serviceTag,
+          objectType: to.objectType
         },
-        to: {
-          objType: {
-            serviceTag: to.serviceTag,
-            objectType: to.objectType
-          },
-          linkType: "many",
-          direction: "to",
-          requiredOnCreate: false
-        }
+        linkType: 'one',
+        direction: 'from',
+        requiredOnCreate: false
+      },
+      to: {
+        objType: {
+          serviceTag: to.serviceTag,
+          objectType: to.objectType
+        },
+        linkType: 'many',
+        direction: 'to',
+        requiredOnCreate: false
       }
-    )
+    });
   }
-  return relationshipProperties
+  return relationshipProperties;
 }
 
-function createFieldNamesFromRequestParamsByObjectSchema(_izContext, requestParams, objectSchema) {
+function createFieldNamesFromRequestParamsByObjectSchema(
+  _izContext,
+  requestParams,
+  objectSchema
+) {
   let createFieldNameParams = {};
-  _izContext.logger.debug("createFieldNamesFromRequestParamsByObjectSchema ::", { requestParams, objectSchema })
+  _izContext.logger.debug(
+    'createFieldNamesFromRequestParamsByObjectSchema ::',
+    { requestParams, objectSchema }
+  );
   for (const fieldName of Object.keys(objectSchema.fieldNames)) {
     if (Object.keys(requestParams).includes(fieldName)) {
       if (!createFieldNameParams.hasOwnProperty(fieldName)) {
-        Object.assign(createFieldNameParams, { [fieldName]: requestParams[fieldName] })
+        Object.assign(createFieldNameParams, {
+          [fieldName]: requestParams[fieldName]
+        });
       }
     }
   }
-  return createFieldNameParams
+  return createFieldNameParams;
 }
 
-async function sharedCreateEndpoint(_izContext, objType, requestParams, callingFlowConfig, settings = { userAgent: false, directInvoke: false, parentObject }) {
+async function sharedCreateEndpoint(_izContext,
+  objType,
+  requestParams,
+  callingFlowConfig,
+  settings = {
+    userAgent: false,
+    directInvoke: false,
+    parentObject: {}
+  }) {
   let objectSchemas = await getObjectSchema.getObjectSchemaCombineFieldNamesWithCache(_izContext, objType)
   let createDataDetails = await createDataDetailsLib(_izContext, objectSchemas)
   _izContext.logger.debug("createDataDetails is =", createDataDetails);
@@ -1096,44 +1344,66 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
   let objInstanceFull = {
     identifiers: {},
     fields: {}
-  }
+  };
 
   for (let fieldName of Object.keys(requestParams.fieldNames)) {
     if (objectSchemas.identifierFieldNames.includes(fieldName)) {
-      _izContext.logger.debug("identifiers is", fieldName);
+      _izContext.logger.debug('identifiers is', fieldName);
       Object.assign(objInstanceFull.identifiers, {
         [fieldName]: requestParams.fieldNames[fieldName]
       });
-    };
-  };
+    }
+  }
 
   let objInstanceFullForDynamoDb = lodash.cloneDeep(objInstanceFull);
   let objInstanceFullForGraph = lodash.cloneDeep(objInstanceFull);
   let objInstanceFullForExternalTopic = lodash.cloneDeep(objInstanceFull);
 
-  for (const [storageTag, createDataDetail] of Object.entries(createDataDetails)) {
+  for (const [storageTag, createDataDetail] of Object.entries(
+    createDataDetails
+  )) {
     if (createDataDetail.storageType == coreConsts.STORAGE_TYPES.dynamoDB) {
-      _izContext.logger.debug("::::::DynamoDB::::::", { storageTag, objInstanceFull });
+      _izContext.logger.debug('::::::DynamoDB::::::', {
+        storageTag,
+        objInstanceFull
+      });
 
       if (settings.parentObject) {
-        if (createDataDetail.tableName.includes(firstLetterUpperCase(`${parentObject.objectType}Records`))) {
-          Object.assign(
-            objInstanceFullForDynamoDb.fields, {
-            [`${settings.parentObject.objectType}HandlerServiceTag`]: process.env.iz_serviceTag
-          })
+        if (
+          createDataDetail.tableName.includes(
+            firstLetterUpperCase(`${parentObject.objectType}Records`)
+          )
+        ) {
+          Object.assign(objInstanceFullForDynamoDb.fields, {
+            [`${settings.parentObject.objectType}HandlerServiceTag`]:
+              process.env.iz_serviceTag
+          });
         }
       }
 
-      Object.assign(objInstanceFullForDynamoDb.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
-      _izContext.logger.debug("objInstanceFull before create item in dynamoDB", objInstanceFullForDynamoDb)
+      Object.assign(
+        objInstanceFullForDynamoDb.fields,
+        createObjInstanceFullFieldsByStorageTag(
+          _izContext,
+          storageTag,
+          createDataDetail
+        )
+      );
+      _izContext.logger.debug(
+        'objInstanceFull before create item in dynamoDB',
+        objInstanceFullForDynamoDb
+      );
 
       let identifiersForCreateData = await dynamoDbIdentifiersByStorageResource(
         _izContext,
         objectSchemas,
         createDataDetail,
         objInstanceFullForDynamoDb.identifiers
-      )
-      _izContext.logger.debug("identifiersForCreateData", identifiersForCreateData);
+      );
+      _izContext.logger.debug(
+        'identifiersForCreateData',
+        identifiersForCreateData
+      );
 
       await dynamodbSharedLib.putItem(
         _izContext,
@@ -1148,7 +1418,7 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
         }
       );
 
-      objInstanceFullForDynamoDb.fields = {} // prevent using fieldNames from other tableName
+      objInstanceFullForDynamoDb.fields = {}; // prevent using fieldNames from other tableName
       if (allAwaitingStepsId.length == 0) {
         let messageObject = {
           objType: objType,
@@ -1156,49 +1426,85 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
             identifiers: objInstanceFullForDynamoDb.identifiers,
             fields: objInstanceFullForDynamoDb.fields
           }
-        }
+        };
 
-        if (callingFlowConfig[callingFlowSharedLib.coreConsts.CALLINGFLOW_PROPERTYNAME]) {
+        if (
+          callingFlowConfig[
+          callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME
+          ]
+        ) {
           // send message to SNS OutCreateNodeComplete
-          _izContext.logger.debug("HAVE CallingFlow");
-          messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
+          _izContext.logger.debug('HAVE CallingFlow');
+          messageObject =
+            callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
+              callingFlowConfig,
+              messageObject
+            );
 
-          let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
-          let outCreateNodeCompleteTopic = await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
+          let messageAttributes =
+            callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+              callingFlowConfig,
+              {}
+            );
+          let outCreateNodeCompleteTopic =
+            await snsSharedLib.snsTopicArnByFlowSchema(
+              _izContext,
+              TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete
+            );
           let messageParams = {
             Message: JSON.stringify(messageObject),
-            MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-            TopicArn: outCreateNodeCompleteTopic,
+            MessageAttributes: sns.createStringMessageAttributes(
+              _izContext,
+              messageAttributes
+            ),
+            TopicArn: outCreateNodeCompleteTopic
           };
 
-          _izContext.logger.debug("messageParams OutCreateNode ::::::: ", messageParams);
+          _izContext.logger.debug(
+            'messageParams OutCreateNode ::::::: ',
+            messageParams
+          );
           await sns.publishAsync(_izContext, messageParams);
         }
         return {
           objType: objType,
           objInstanceFull: objInstanceFullForDynamoDb,
           relationships: requestParams.relationships || [],
-          status: "complete",
+          status: 'complete',
           errorsFound: []
-        }
+        };
       }
-
     } else if (createDataDetail.storageType == coreConsts.STORAGE_TYPES.graph) {
-      _izContext.logger.debug("::::::Graph::::::", { storageTag, objInstanceFull });
+      _izContext.logger.debug('::::::Graph::::::', {
+        storageTag,
+        objInstanceFull
+      });
 
-      Object.assign(objInstanceFullForGraph.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
-      _izContext.logger.debug("objInstanceFull before send to Graph", objInstanceFullForGraph)
+      Object.assign(
+        objInstanceFullForGraph.fields,
+        createObjInstanceFullFieldsByStorageTag(
+          _izContext,
+          storageTag,
+          createDataDetail
+        )
+      );
+      _izContext.logger.debug(
+        'objInstanceFull before send to Graph',
+        objInstanceFullForGraph
+      );
 
       // allStorageTagComplete = false;
-      allAwaitingStepsId.push(await asyncFlowSharedLib.createAwaitingStepId(
-        (hash({
-          objType: objType,
-          graphServerTag: storageTag,
-          identifiers: objInstanceFullForGraph.identifiers,
-          callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
-        })),
-        PREFIX.CREATE_OBJECT_ASYNC
-      ));
+      allAwaitingStepsId.push(
+        await asyncFlowSharedLib.createAwaitingStepId(
+          hash({
+            objType: objType,
+            graphServerTag: storageTag,
+            identifiers: objInstanceFullForGraph.identifiers,
+            callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
+          }),
+          PREFIX.CREATE_OBJECT_ASYNC
+        )
+      );
       listOfObjectForCreates.push({
         [storageTag]: {
           objInstanceFull: {
@@ -1209,42 +1515,71 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
         }
       });
 
-      _izContext.logger.debug("FIRST", listOfObjectForCreates)
-
-    } else if (createDataDetail.storageType === coreConsts.STORAGE_TYPES.externalTopic) {
-      _izContext.logger.debug("::::::externalTopic::::::", { storageTag, createDataDetail });
-      Object.assign(objInstanceFullForExternalTopic.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
-      _izContext.logger.debug("objInstanceFull before send to external topic", objInstanceFullForExternalTopic)
+      _izContext.logger.debug('FIRST', listOfObjectForCreates);
+    } else if (
+      createDataDetail.storageType === coreConsts.STORAGE_TYPES.externalTopic
+    ) {
+      _izContext.logger.debug('::::::externalTopic::::::', {
+        storageTag,
+        createDataDetail
+      });
+      Object.assign(
+        objInstanceFullForExternalTopic.fields,
+        createObjInstanceFullFieldsByStorageTag(
+          _izContext,
+          storageTag,
+          createDataDetail
+        )
+      );
+      _izContext.logger.debug(
+        'objInstanceFull before send to external topic',
+        objInstanceFullForExternalTopic
+      );
 
-      allAwaitingStepsId.push(await asyncFlowSharedLib.createAwaitingStepId(
-        (hash({
-          objType: objType,
-          graphServerTag: storageTag,
-          identifiers: objInstanceFullForGraph.identifiers,
-          callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
-        })),
-        PREFIX.CREATE_OBJECT_EXTERNAL_TOPIC
-      ));
+      allAwaitingStepsId.push(
+        await asyncFlowSharedLib.createAwaitingStepId(
+          hash({
+            objType: objType,
+            graphServerTag: storageTag,
+            identifiers: objInstanceFullForGraph.identifiers,
+            callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
+          }),
+          PREFIX.CREATE_OBJECT_EXTERNAL_TOPIC
+        )
+      );
 
       let sendToCreateExternalTopic = {
-        Message: JSON.stringify({ objType, objInstanceFull: objInstanceFullForExternalTopic, relationships: requestParams.relationships }),
+        Message: JSON.stringify({
+          objType,
+          objInstanceFull: objInstanceFullForExternalTopic,
+          relationships: requestParams.relationships
+        }),
         TopicArn: `arn:aws:sns:${createDataDetail.region}:${createDataDetail.accountId}:${createDataDetail.serviceTag}_${createDataDetail.stage}_Create_In`
       };
-      _izContext.logger.debug("Request params before send to create endpoint:", sendToCreateExternalTopic);
+      _izContext.logger.debug(
+        'Request params before send to create endpoint:',
+        sendToCreateExternalTopic
+      );
 
-      await sns.publishAsync(_izContext, sendToCreateExternalTopic)
-      return sendToCreateExternalTopic
+      await sns.publishAsync(_izContext, sendToCreateExternalTopic);
+      return sendToCreateExternalTopic;
     }
-  };
-  _izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
+  }
+  _izContext.logger.debug(
+    '[1]listOfObjectForCreates:::',
+    listOfObjectForCreates
+  );
 
   /// step save awaitingMultipleStep of storageType graph ...........................................................
   if (!settings.userAgent) {
-    _izContext.logger.debug("not api will create awaitingStep")
+    _izContext.logger.debug('not api will create awaitingStep');
     await asyncFlowSharedLib.createAwaitingMultipleSteps(
       _izContext,
       allAwaitingStepsId,
-      asyncFlowSharedLib.createPendingStepId((hash({ objType: objType, identifiers: objInstanceFull.identifiers })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)
+      asyncFlowSharedLib.createPendingStepId(
+        hash({ objType: objType, identifiers: objInstanceFull.identifiers }),
+        PREFIX.CREATE_OBJECT_ASYNC_COMPLETE
+      )
     );
   }
   //............................................................................................................
@@ -1252,28 +1587,34 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
   // process storageType : graph
   let messageObject = {};
   for (let objectCreate of listOfObjectForCreates) {
-
-    for (let [graphServiceName, objectForCreate] of Object.entries(objectCreate)) {
-      _izContext.logger.debug("Loop each graph:", {
+    for (let [graphServiceName, objectForCreate] of Object.entries(
+      objectCreate
+    )) {
+      _izContext.logger.debug('Loop each graph:', {
         [graphServiceName]: objectForCreate
       });
 
-      if (objectForCreate.allStorageTagComplete == false) { // needless check because in listOfObjectForCreates push case graph  only!
+      if (objectForCreate.allStorageTagComplete == false) {
+        // needless check because in listOfObjectForCreates push case graph  only!
         messageObject = {
           objType: objType,
           objInstanceFull: objectForCreate.objInstanceFull,
           relationships: requestParams.relationships || []
         };
-      };
+      }
 
-      _izContext.logger.debug("SENT MESSAGE EACH GRAPH::::", { graphServiceName, messageObject, callingFlowConfig })
+      _izContext.logger.debug('SENT MESSAGE EACH GRAPH::::', {
+        graphServiceName,
+        messageObject,
+        callingFlowConfig
+      });
 
       Object.assign(messageObject, {
         settings: { updatePropertiesOnMatch: false },
-        originTimestamp: Date.now(),
+        originTimestamp: Date.now()
       });
       if (settings.userAgent) {
-        _izContext.logger.debug("have userAgent will invoke GraphHandler")
+        _izContext.logger.debug('have userAgent will invoke GraphHandler');
         let createNodeResult = await graphSharedLibs.createNodeV2(
           _izContext,
           graphServiceName,
@@ -1284,11 +1625,12 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
           {
             updatePropertiesOnMatch: false
           }
-        )
-        return createNodeResult
-
+        );
+        return createNodeResult;
       } else if (settings.directInvoke) {
-        _izContext.logger.debug("Direction Invoke case will invoke GraphHandlerInv")
+        _izContext.logger.debug(
+          'Direction Invoke case will invoke GraphHandlerInv'
+        );
         let createNodeResult = await graphSharedLibs.createNodeV2(
           _izContext,
           graphServiceName,
@@ -1303,48 +1645,76 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
 
         return createNodeResult;
       } else {
-        _izContext.logger.debug("not have userAgent will send Message to GraphHandler")
-        messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-          messageObject,
-          callingFlowSharedLib.addParentCallingFlowConfig(
-            callingFlowConfig, // receive parent callingFlowConfig.
-            callingFlowSharedLib.createCallingFlowConfig( // calling flow own service
-              await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.createNodeComplete), {}
-            )
-          )
+        _izContext.logger.debug(
+          'not have userAgent will send Message to GraphHandler'
         );
+        messageObject =
+          callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+            messageObject,
+            callingFlowSharedLib.addParentCallingFlowConfig(
+              callingFlowConfig, // receive parent callingFlowConfig.
+              callingFlowSharedLib.createCallingFlowConfig(
+                // calling flow own service
+                await lambdaSharedLib.lambdaFunctionName(
+                  _izContext,
+                  TOPIC_NAME_GENERATE_CODE.createNodeComplete
+                ),
+                {}
+              )
+            )
+          );
 
         let messageToCreateObject = {
           Message: JSON.stringify(messageObject),
-          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GRAPH_HANDLER.inCreateNode, graphServiceName)
+          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
+            _izContext,
+            TOPIC_NAME_GRAPH_HANDLER.inCreateNode,
+            graphServiceName
+          )
         };
-        _izContext.logger.debug("RequestParams before send to sqs messageToCreateObject ::::::: ", messageToCreateObject);
+        _izContext.logger.debug(
+          'RequestParams before send to sqs messageToCreateObject ::::::: ',
+          messageToCreateObject
+        );
         await sns.publishAsync(_izContext, messageToCreateObject);
 
-        return messageObject
+        return messageObject;
       }
-    };
-  };
+    }
+  }
 
-  function createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail) {
+  function createObjInstanceFullFieldsByStorageTag(
+    _izContext,
+    storageTag,
+    createDataDetail
+  ) {
     let fields = {};
     for (let fieldName of Object.keys(requestParams.fieldNames)) {
-      if ((createDataDetails[storageTag].fieldNames.includes(fieldName)) &&
-        (createDataDetail.fieldNames.includes(fieldName))) {
+      if (
+        createDataDetails[storageTag].fieldNames.includes(fieldName) &&
+        createDataDetail.fieldNames.includes(fieldName)
+      ) {
         if (!objInstanceFull.identifiers.hasOwnProperty(fieldName)) {
           if (!fields.hasOwnProperty(fieldName)) {
             Object.assign(fields, {
               [fieldName]: requestParams.fieldNames[fieldName]
-            })
+            });
           }
         }
       }
     }
-    return fields
+    return fields;
   }
 }
 
-async function sharedCreateCompleteEndpoint(_izContext, returnValue, status, errorsFound, graphServiceTag, passBackProperties) {
+async function sharedCreateCompleteEndpoint(
+  _izContext,
+  returnValue,
+  status,
+  errorsFound,
+  graphServiceTag,
+  passBackProperties
+) {
   let existsNode = null;
   let createNodeFinished = false;
   if (Object.keys(returnValue.queryResult.returnCreateNode.existsNode).length) {
@@ -1353,65 +1723,88 @@ async function sharedCreateCompleteEndpoint(_izContext, returnValue, status, err
         objectType: returnValue.requestParams.objType.objectType,
         serviceTag: returnValue.requestParams.objType.serviceTag
       },
-      objInstanceFull: returnValue.queryResult.returnCreateNode.existsNode.objInstanceFull
-    }
+      objInstanceFull:
+        returnValue.queryResult.returnCreateNode.existsNode.objInstanceFull
+    };
   }
 
   let awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
-    (hash({
+    hash({
       objType: returnValue.requestParams.objType,
       graphServerTag: graphServiceTag,
       identifiers: returnValue.requestParams.objInstanceFull.identifiers,
-      callingFlowProperties: passBackProperties.passBackProperties.parentPassBackProperties.callingFlowProperties || {}
-    })),
+      callingFlowProperties:
+        passBackProperties.passBackProperties.parentPassBackProperties
+          .callingFlowProperties || {}
+    }),
     PREFIX.CREATE_OBJECT_ASYNC
-  )
-  _izContext.logger.debug("awaitingStepId:", awaitingStepId);
+  );
+  _izContext.logger.debug('awaitingStepId:', awaitingStepId);
 
   let recordAwaitingSteps = await dynamodbSharedLib.query(
     _izContext,
-    await dynamodbSharedLib.tableName(_izContext, "AwaitingMultipleSteps"),
+    await dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
     {
       awaitingStepId: awaitingStepId
     }
   );
-  _izContext.logger.debug("record awaitingSteps::", recordAwaitingSteps);
+  _izContext.logger.debug('record awaitingSteps::', recordAwaitingSteps);
 
   await Promise.all(
     recordAwaitingSteps.Items.map(async ({ pendingStepId }) => {
-      if (await asyncFlowSharedLib.checkAllAwaitingStepsFinished(
-        _izContext,
-        pendingStepId,
-        awaitingStepId,
-        errorsFound
-      )) {
-        _izContext.logger.debug("finish all awaitingStep");
+      if (
+        await asyncFlowSharedLib.checkAllAwaitingStepsFinished(
+          _izContext,
+          pendingStepId,
+          awaitingStepId,
+          errorsFound
+        )
+      ) {
+        _izContext.logger.debug('finish all awaitingStep');
 
         let messageObject = {
           objType: {
             objectType: returnValue.requestParams.objType.objectType,
             serviceTag: returnValue.requestParams.objType.serviceTag
           },
-          objInstanceFull: returnValue.queryResult.returnCreateNode.objInstanceFull,
+          objInstanceFull:
+            returnValue.queryResult.returnCreateNode.objInstanceFull,
           relationships: returnValue.queryResult.returnCreateNode.relationships,
           existsNode: existsNode,
           status: status,
           errorsFound: errorsFound
-        }
+        };
 
-        messageObject = callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(passBackProperties, messageObject)
-        let messageAttributes = callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(passBackProperties, {})
+        messageObject =
+          callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
+            passBackProperties,
+            messageObject
+          );
+        let messageAttributes =
+          callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
+            passBackProperties,
+            {}
+          );
 
         let sendMessageOutCreateObjectComplete = {
           Message: JSON.stringify(messageObject),
-          MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
+          MessageAttributes: sns.createStringMessageAttributes(
+            _izContext,
+            messageAttributes
+          ),
+          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
+            _izContext,
+            TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete
+          )
         };
-        _izContext.logger.debug("Send message to OutCreateObjectComplete :::>", sendMessageOutCreateObjectComplete)
+        _izContext.logger.debug(
+          'Send message to OutCreateObjectComplete :::>',
+          sendMessageOutCreateObjectComplete
+        );
         await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
-        createNodeFinished = true
+        createNodeFinished = true;
       } else {
-        createNodeFinished = false
+        createNodeFinished = false;
       }
 
       await asyncFlowSharedLib.removeAwaitingMultipleStep(
@@ -1420,10 +1813,9 @@ async function sharedCreateCompleteEndpoint(_izContext, returnValue, status, err
         pendingStepId,
         errorsFound
       );
-
     })
-  )
-  return createNodeFinished
+  );
+  return createNodeFinished;
 }
 
 export default {
@@ -1449,11 +1841,7 @@ export default {
   createFieldNamesFromRequestParamsByObjectSchema,
   sharedCreateEndpoint,
   sharedCreateCompleteEndpoint
-}
-
-
-
-
+};
 
 // /**
 //  * filter request param depend on generatedValidatorSchema function
@@ -1490,7 +1878,6 @@ export default {
 //   return newRequestParams
 // }
 
-
 // /**
 //  * reformat request for main function of each action
 //  * @param {Object} _izContext
@@ -1520,8 +1907,6 @@ export default {
 //     }
 //   }
 
-
-
 //   let reformattedReq
 
 //   // reformat request depend on action
@@ -1547,11 +1932,8 @@ export default {
 //         return returnFieldNames;
 //       }, [])
 
-
-
 //       _izContext.logger.debug("createFieldNames: ", createFieldNames);
 
-
 //       for (const [reqFieldName, reqFieldData] of Object.entries(requestParams.fieldNames)) {
 //         if (identifierFieldNames.includes(reqFieldName)) {
 //           Object.assign(
@@ -1599,8 +1981,6 @@ export default {
 //   }
 // )
 
-
-
 // /**
 //  * filter identifiers from requestParams depend on objectSchema.identifiers
 //  * @param {object} _izContext
@@ -1614,7 +1994,6 @@ export default {
 
 //   let identifierFieldNameList = utils.getUsedFieldNamesOfIdentifiers(_izContext, objectSchema.identifiers, usedIdentifierTypes);
 
-
 //   let identifiersObj = {};
 
 //   for (let identifierFieldName of identifierFieldNameList) {
@@ -1625,13 +2004,9 @@ export default {
 //     }
 //   }
 
-
 //   return identifiersObj;
 // }
 
-
-
-
 // /*
 //   Q?
 //   - when perform action in dynamodb some table need to concatenate
@@ -1711,8 +2086,6 @@ export default {
 
 //   // --------------  initial return value  --------------
 
-
-
 //   // create identifier object from requestParams
 //   let identifierObj = saperateIdentifierRequestParams(_izContext, objectSchema, requestParams);
 
@@ -1755,7 +2128,6 @@ export default {
 
 //       let graphServiceName = await serviceConfig.getGraphServiceNameFromGraphServerTagWithCache(_izContext, storageData.graphServerTag);
 
-
 //       if (returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName]) {
 //         // have exists graphServiceName,
 //         // need to merge properties for multiple graphServerTag to one serviceName
@@ -1775,7 +2147,6 @@ export default {
 //           }
 //         }
 
-
 //         /*
 //           if versionedDatas exists in graphRequestParams
 //             - check versionedDatas exists in  returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName]
@@ -1793,7 +2164,6 @@ export default {
 //           }
 //         }
 
-
 //       } else {
 //         // not exists graphServiceName
 //         Object.assign(returnValue[coreConsts.STORAGE_TYPES.graph], { [graphServiceName]: graphRequestParams });
@@ -1808,10 +2178,6 @@ export default {
 
 // }
 
-
-
-
-
 // /**
 //  * helper function for separate requestParams depend on storageTag
 //  *
@@ -1831,7 +2197,6 @@ export default {
 //     storageData
 //   });
 
-
 //   //----------------------- Filter requestParams ------------------------
 
 //   // filter requestParams that includes in storageTag
@@ -1844,7 +2209,6 @@ export default {
 
 //   //----------------------- End Filter requestParams ------------------------
 
-
 //   //----------------------- Create dynamoDb identifier object ------------------------
 
 //   // use identifierObj to prepare dynamodb identifiers
@@ -1888,7 +2252,6 @@ export default {
 
 //   //----------------------- End Create dynamoDb identifier object ------------------------
 
-
 //   //----------------------- calculate composite deliminator amount ------------------------
 
 //   let compositeDeliminator = objectSchema.compositeKeyDeliminator ? objectSchema.compositeKeyDeliminator : "_";
@@ -1904,7 +2267,6 @@ export default {
 
 //   //----------------------- End calculate composite deliminator amount ------------------------
 
-
 //   //----------------------- create return value  ------------------------
 
 //   // initial returnValue
@@ -1933,11 +2295,9 @@ export default {
 
 //   //----------------------- End create return value  ------------------------
 
-
 //   return returnValue;
 // }
 
-
 // // helper function for separate requestParams fieldName per storageTag
 // async function separateRequestByGraph(_izContext, objectSchema, requestParams, identifierObj, storageTag, storageData, action) {
 //   _izContext.logger.debug("separateRequestByGraph: ", {
@@ -1948,7 +2308,6 @@ export default {
 //     action
 //   });
 
-
 //   //----------------------- Filter requestParams ------------------------
 
 //   // filter requestParams that includes in storageTag
@@ -1961,7 +2320,6 @@ export default {
 
 //   //----------------------- End Filter requestParams ------------------------
 
-
 //   //----------------------- standard return value  ------------------------
 
 //   // initial returnValue
@@ -1990,7 +2348,6 @@ export default {
 
 //   //----------------------- End standard return value  ------------------------
 
-
 //   //----------------------- prepare additional return data per action   ------------------------
 
 //   if (action === coreConsts.ACTIONS.get) {
@@ -2024,7 +2381,6 @@ export default {
 
 //   } else if (action === coreConsts.ACTIONS.create) {
 
-
 //   } else if (action === coreConsts.ACTIONS.update) {
 //     _izContext.logger.debug("filter versionedData update")
 //     _izContext.logger.debug("additionalReq: ", requestParams.additionalRequest.versionedDatas)
@@ -2071,8 +2427,6 @@ export default {
 //             addOnVersionedData => addOnVersionedData.versionedDataLabel === versionedDataReq.nodeLabel
 //           );
 
-
-
 //           if (versionedDataSchema) {
 //             _izContext.logger.debug('exists versionedDataSchema: ', versionedDataSchema);
 
@@ -2081,12 +2435,10 @@ export default {
 //             let versionedDataValidatorSchema = generateValidatorSchemaForVersionedData(_izContext, versionedDataSchema, action);
 //             _izContext.logger.debug("versionedData validator schema: ", versionedDataValidatorSchema);
 
-
 //             _izContext.logger.debug("versionedDataReq before validate: ", versionedDataReq)
 //             let validateVersionedDataStatus = validateObject(_izContext, versionedDataValidatorSchema, versionedDataReq);
 //             _izContext.logger.debug("versionedData validate status: ", validateVersionedDataStatus);
 
-
 //             if (validateVersionedDataStatus.pass === false) {
 //               throw new NoRetryError("Function:separateRequestByGraph: ", validateVersionedDataStatus.error);
 //             }
@@ -2096,7 +2448,6 @@ export default {
 //             }
 //             // end validate versionedData
 
-
 //             let hookProperties = [];
 //             for (let fieldNameSetting of versionedDataSchema.fieldNames) {
 //               hookProperties.push(fieldNameSetting.fieldName);
@@ -2111,7 +2462,6 @@ export default {
 
 //     }
 
-
 //   } else if (action === coreConsts.ACTIONS.delete) {
 
 //   } else {
@@ -2120,13 +2470,10 @@ export default {
 
 //   //----------------------- End prepare additional return data per action   ------------------------
 
-
 //   _izContext.logger.debug("Function:separateRequestByGraph: return value: ", returnValue);
 //   return returnValue;
 // }
 
-
-
 // function mergeReturnGetData(_izContext, dynamoDbData, graphData) {
 //   let mergedData = {
 //     properties: {}
@@ -2156,7 +2503,6 @@ export default {
 //         continue;
 //       }
 
-
 //       if (Object.keys(graphDataValue.nodeProperties).length) {
 
 //         if (!mergedData.versionedDataLabel) {
@@ -2171,8 +2517,6 @@ export default {
 //   return mergedData
 // }
 
-
-
 // // this function not use for new version because versionedData will not saperate from request params
 // function generateValidatorSchemaForVersionedData(_izContext, versionedObjDataSchema, action) {
 //   // input form of versionedData will be the same for create and update action