@izara_project/izara-market-library-service-schemas 1.0.1 → 1.0.2

package/src/GenerateCodeLibs/src/GenerateCodeLibs.js

@@ -0,0 +1,1373 @@
+/*
+Copyright(C) 2021 Sven Mason < http://izara.io>
+
+This program is free software: you can redistribute it and / or modify
+it under the terms of the GNU Affero General Public License as
+  published by the Free Software Foundation, either version 3 of the
+License, or(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.If not, see < http://www.gnu.org/licenses/>.
+*/
+
+'use strict';
+
+const lodash = require('lodash');
+const hash = require("object-hash")
+
+
+const sqsSharedLib = require('@izara_project/izara-shared/src/SqsSharedLib');
+const snsSharedLib = require('@izara_project/izara-shared/src/SnsSharedLib');
+const inMemoryCacheLib = require('@izara_project/izara-shared/src/InMemoryCacheLib');
+const callingFlowSharedLib = require('@izara_project/izara-shared/src/CallingFlowSharedLib');
+
+const sns = require('@izara_project/izara-core-library-external-request/src/resources/Sns');
+const sqs = require('@izara_project/izara-core-library-external-request/src/resources/Sqs');
+
+const NoRetryError = require('@izara_project/izara-core-library-core/src/NoRetryError');
+const { validateObject } = require('@izara_project/izara-core-library-core/src/Validator');
+
+
+const getObjectSchema = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema')
+// const serviceSchemas = require('./ServiceSchemas');
+const validatorSchema = require('@izara_project/izara-core-library-service-schemas/src/ValidatorSchema');
+const serviceConfig = require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig');
+const utils = require('@izara_project/izara-core-library-service-schemas/src/Utils');
+const consts = require('@izara_project/izara-core-library-service-schemas/src/Consts');
+const explodedReqParams = require('@izara_project/izara-core-library-service-schemas/src/libs/ExplodedReqParams');
+const {
+  generateDeliminatorTreeIdentifier,
+  generateDeliminatorTreePerFieldName
+} = require('@izara_project/izara-core-library-service-schemas/src/libs/DeliminatorTree');
+
+const nodeLabelRegexPattern = "^[a-zA-Z0-9_-]+(?:\:[a-zA-Z0-9_-]+)?$"
+
+
+
+const schemaFunctionPerAction = {
+  [consts.ACTIONS.create]: validatorSchema.generateValidatorSchemaForCreate,
+  [consts.ACTIONS.update]: validatorSchema.generateValidatorSchemaForUpdate,
+  [consts.ACTIONS.get]: validatorSchema.generateValidatorSchemaForIdentifier,
+  [consts.ACTIONS.delete]: validatorSchema.generateValidatorSchemaForIdentifier,
+}
+
+const explodeDataPerAction = {
+  [consts.ACTIONS.create]: explodedReqParams.explodedDataForCreate,
+  [consts.ACTIONS.get]: explodedReqParams.explodedDataForIdentifiers,
+}
+
+
+/*
+  ---------- Contain function use for generated code ----------
+*/
+
+/**
+ *
+ * @param {middleware} middleware
+ * @param {string} objectType           - name of ObjectType
+ * @param {string} action               - action type of Lambda create | update | get | delete
+ * @param {object} [setting]
+ * @param {string[]} [setting.specificFieldNames] - optional - specific fieldNames use as param in generateValidatorFunction
+ */
+function validateSchemaMiddleware(
+  middleware,
+  objectType,
+  action,
+  setting = {}
+) {
+
+  if (!schemaFunctionPerAction[action] || !explodeDataPerAction[action]) {
+    throw new NoRetryError(`Not found function for generateValidatorSchema or explodeDataPerAction of action:${action}`);
+  }
+
+  middleware.setServiceSchema(
+    schemaFunctionPerAction[action],
+    explodeDataPerAction[action],
+    {
+      objectType: objectType,
+      specificFieldNames: setting.specificFieldNames ? setting.specificFieldNames : []
+    },
+  );
+}
+
+/**
+ * use to validate record for Lambda handler hdrSqs/hdrDsq
+ * Note!: cannot throw error when use this function outside recordHandler
+ *
+ * @param {object} record                         - one record from sqs
+ * @param {string} lambdaFunctionName             - name of Lambda used to build SQS/DLQ // QueueName
+ * @param {string} objectType                     - name of ObjectType
+ * @param {string} action                         - action type of Lambda create | update | get | delete
+ * @param {object} [setting]
+ * @param {string[]} [setting.specificFieldNames] - optional - specific fieldNames use as param in generateValidatorFunction
+ */
+async function validateSchemaPerRecord(
+  record,
+  lambdaFunctionName,
+  objType,
+  action, // action
+  setting = {}
+) {
+  try {
+    record._izContext.logger.debug("validateSchemaPerRecord: ", record,
+      lambdaFunctionName,
+      objType,
+      action, // action
+      setting
+    )
+
+    if (!schemaFunctionPerAction[action] || !explodeDataPerAction[action]) {
+      throw new Error(`Not found function for generateValidatorSchema or function for explodeData of action:${action}`);
+    }
+
+    const objectSchema = await getObjectSchema.getObjSchemaFromS3WithHierarchy(record._izContext, objType);
+
+    const generateValidatorFunction = schemaFunctionPerAction[action];
+    const explodeDataFunction = explodeDataPerAction[action]
+
+    const generatedSchema = await generateValidatorFunction(record._izContext, objType, setting.specificFieldNames);
+    record._izContext.logger.debug(`generatedSchema in validateSchemaPerRecord : `, generatedSchema);
+
+
+    const explodedDataRequestParams = await explodeDataFunction(
+      record._izContext,
+      record.body.Message,
+      objectSchema
+    );
+
+
+    record._izContext.logger.debug('explodedDataRequestParams in validateSchemaPerRecord : ', JSON.stringify(explodedDataRequestParams));
+
+
+    let validateStatus = validateObject(record._izContext, generatedSchema, explodedDataRequestParams);
+    record._izContext.logger.debug('validateStatus : ', validateStatus);
+
+    // if not pass validate will sent messsage to dlq and throw NoRetryError
+    if (!validateStatus.pass) {
+      await messageToDlq(record, `Invalid: ${validateStatus.error}`, sqsSharedLib.sqsQueueUrlDLQ(lambdaFunctionName));
+      record._izError = new Error(validateStatus.error)
+    }
+  } catch (error) {
+    await messageToDlq(record, error.message, sqsSharedLib.sqsQueueUrlDLQ(lambdaFunctionName));
+    record._izError = new Error(error)
+  }
+
+}
+
+
+
+async function sendMsgOutComplete(_izContext, topicName, messageObj, callingFlowConfig) {
+
+  try {
+    // add callingFlow to message
+    messageObj = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObj);
+    let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+
+    let sendMessageOutComplete = {
+      Message: JSON.stringify(messageObj),
+      MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+      TopicArn: snsSharedLib.snsTopicArn(topicName),
+    };
+
+    _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.
+ * @param {object} lambdaFunctionName   - Queue anme what to send to dlq./name of Lambda being invoked, used to build SQS/DLQ
+ *
+ */
+async function messageToDlq(record, messageFailError, queueUrl) {
+
+  let messageBody = record.body
+
+  let params = {
+    QueueUrl: queueUrl,
+    MessageAttributes: {
+      messageFailError: {
+        DataType: "String",
+        StringValue: messageFailError
+      }
+    },
+    MessageBody: JSON.stringify(messageBody),
+  };
+
+  record._izContext.logger.debug('messageToDlq, params before sending DLQ', params);
+
+  await sqs.sendMessage(record._izContext, params).promise();
+  record._izContext.logger.debug("----- messageToDlq sendMessage success -----");
+};
+
+
+/**
+ * helper function for get endpoint
+ * create get data detail for each storageTag
+ *
+ * @param {Object} _izContext
+ * @param {Object} objectSchema
+ */
+async function createGetDataDetails(_izContext, objectSchema) {
+
+  // group versionedData per storageTag
+  // or should group versionedData per graph serviceTag
+  let versionedDataPerStorageTag = {}
+  if (objectSchema?.addOnDataStructure?.length) {
+    for (let addOn of objectSchema.addOnDataStructure) {
+      if (addOn.type !== "versionedData") {
+        continue;
+      }
+
+      if (!versionedDataPerStorageTag.hasOwnProperty(addOn.storageResourceTag)) {
+        versionedDataPerStorageTag[addOn.storageResourceTag] = [];
+      }
+
+      versionedDataPerStorageTag[addOn.storageResourceTag].push(addOn);
+    }
+  }
+
+  _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)) {
+
+    // collect fieldNames per storageTag
+    let storageTagFieldNames = [];
+    for (let [fieldName, fieldNameData] of Object.entries(objectSchema.fieldNames)) {
+      if (fieldNameData.storageResourceTags.includes(storageTag)) {
+        storageTagFieldNames.push(fieldName);
+      }
+    }
+
+    if (storageData.storageType === consts.STORAGE_TYPES.graph) {
+
+      let useStorageTag = storageTag;
+      let graphServiceTag = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageData.graphServerTag);
+
+      // 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);
+
+        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))];
+      }
+
+
+      // add versionedData fieldNames
+      if (versionedDataPerStorageTag.hasOwnProperty(storageTag)) {
+        if (!getGraphDataDetails[useStorageTag].hasOwnProperty("versionedDatas")) {
+          getGraphDataDetails[useStorageTag].versionedDatas = {};
+        }
+
+        for (let versionedData of versionedDataPerStorageTag[storageTag]) {
+          let versionedDataFieldNames = versionedData.fieldNames.map(data => data.fieldName);
+          Object.assign(
+            getGraphDataDetails[useStorageTag].versionedDatas,
+            { [versionedData.versionedDataLabel]: versionedDataFieldNames }
+          )
+        }
+      }
+
+    } else if (storageData.storageType === consts.STORAGE_TYPES.dynamoDB) {
+
+      Object.assign(getDynamoDbDataDetails, {
+        [storageTag]: {
+          storageType: storageData.storageType,
+          tableName: storageData.tableName,
+          fieldNames: storageTagFieldNames
+        }
+      })
+
+      if (storageData.groupByPartitionKeyField) {
+        Object.assign(
+          getDynamoDbDataDetails[storageTag],
+          {
+            groupByPartitionKeyField: storageData.groupByPartitionKeyField
+          }
+        )
+      }
+
+
+    } else {
+      throw new NoRetryError("Unhanled storageType");
+    }
+  }
+
+  _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
+    );
+
+  _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
+    );
+
+  _izContext.logger.debug("sortedGetGraphWithoutVersionedData: ", sortedGetGraphWithoutVersionedData);
+
+
+  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 usedFieldName = [];
+  for (let [storageTag, getDataDetail] of allSortedGetDataDetails) {
+    let remainsFieldNames = [];
+    while (getDataDetail.fieldNames.length) {
+      let checkedFiedName = getDataDetail.fieldNames.pop();
+      if (!usedFieldName.includes(checkedFiedName)) {
+        usedFieldName.push(checkedFiedName);
+        remainsFieldNames.push(checkedFiedName);
+      }
+    }
+
+    getDataDetail.fieldNames = remainsFieldNames;
+  }
+
+  _izContext.logger.debug("newSortedArray after: ", allSortedGetDataDetails);
+
+
+  let getDataDetailResults = Object.fromEntries(
+    allSortedGetDataDetails.filter(([storageTag, getDataDetail]) => {
+      return (getDataDetail.fieldNames.length || getDataDetail.hasOwnProperty("versionedDatas"));
+    })
+  );
+
+  _izContext.logger.debug("getDataDetailResults: ", getDataDetailResults);
+
+  return getDataDetailResults;
+}
+
+
+
+/**
+ * create dynamoDb identifiers using request param and objectSchema
+ *
+ * @param {Object} _izContext
+ * @param {Object} objectSchema
+ * @param {Object} reqIdentifiers       - input identifier from calling function
+ */
+async function generateDynamoDbIdentifiers(_izContext, objectSchema, reqIdentifiers) {
+
+  // start create identifiers for dynamo
+  let dynamoIdentifiers = {};
+
+  for (let identifier of objectSchema.identifiers) {
+    if (identifier.name) {
+      let deliminator = identifier.deliminator || consts.DEFAULT_IDENTIFIER_DELIMINATOR;
+      let currentDeliminatorAmount = 0;
+
+      let concatenateValue = [];
+      for (let fieldName of identifier.fieldNames) {
+        concatenateValue.push(reqIdentifiers[fieldName]);
+
+        let deliminatorTreeFieldName = await generateDeliminatorTreePerFieldName(_izContext, fieldName, objectSchema.fieldNames[fieldName]);
+        _izContext.logger.debug("deliminatorTreeFieldName: ", deliminatorTreeFieldName);
+
+        if (deliminatorTreeFieldName[fieldName]?.deliminatorList?.[deliminator]) {
+          currentDeliminatorAmount = Math.max(
+            currentDeliminatorAmount,
+            deliminatorTreeFieldName[fieldName].deliminatorList[deliminator]
+          );
+        }
+      }
+
+      Object.assign(
+        dynamoIdentifiers,
+        {
+          [identifier.name]: concatenateValue.join(deliminator.repeat(currentDeliminatorAmount + 1))
+        }
+      );
+    } else {
+      Object.assign(
+        dynamoIdentifiers,
+        {
+          [identifier.fieldName]: reqIdentifiers[identifier.fieldName]
+        }
+      )
+    }
+  }
+
+  _izContext.logger.debug("dynamoIdentifiers: ", dynamoIdentifiers);
+
+  return dynamoIdentifiers;
+}
+
+
+/**
+ * create dynamoDb identifiers using request param and objectSchema
+ *
+ * @param {Object} _izContext
+ * @param {Object} objectSchema
+ * @param {Object} reqIdentifiers       - input identifier from calling function
+ */
+const generateDynamoDbIdentifiersWithCache = inMemoryCacheLib.inMemoryCacheLib(
+  generateDynamoDbIdentifiers, // fn
+  { // setting
+    max: 20, maxAge: 86400000, promise: true, profileName: 'generateDynamoDbIdentifiers',
+    normalizer: function (args) {
+      return hash([args[1], args[2]])
+    }
+  }
+)
+
+/**
+ *
+ * @param {Object} _izContext
+ * @param {Object} objectSchema
+ * @param {Object} getDataDetail
+ * @param {Object} reqIdentifiers
+ */
+async function dynamoDbIdentifiersByStorageResource(_izContext, objectSchema, getDataDetail, reqIdentifiers) {
+
+  let dynamoIdentifiers = await generateDynamoDbIdentifiersWithCache(_izContext, objectSchema, reqIdentifiers)
+
+  let identifiersByStorageResource = {};
+
+  if (getDataDetail.groupByPartitionKeyField) {
+
+    let deliminatorTreeIdentifiers = await generateDeliminatorTreeIdentifier(_izContext, objectSchema);
+    _izContext.logger.debug("deliminatorTree: ", deliminatorTreeIdentifiers);
+
+    let compositeKeyDeliminator = objectSchema.compositeKeyDeliminator || consts.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];
+        }
+      }
+    }
+
+    // sort dynamoDbIdentifiers data by objectSchema
+    let sortedIdentifiersValue = [];
+    for (let identifier of objectSchema.identifiers) {
+      let identifierName = identifier.fieldName || identifier.name;
+      sortedIdentifiersValue.push(dynamoIdentifiers[identifierName]);
+    }
+
+    let newIdentifierValue = sortedIdentifiersValue.join(compositeKeyDeliminator.repeat(currentDeliminatorAmount + 1));
+
+    identifiersByStorageResource = {
+      [getDataDetail.groupByPartitionKeyField]: newIdentifierValue
+    };
+
+  } else {
+    identifiersByStorageResource = dynamoIdentifiers;
+  }
+
+  return identifiersByStorageResource;
+}
+
+
+
+function collectGetData(_izContext, getDataResult, getDataDetail) {
+
+  if (!getDataResult) {
+    return {};
+  }
+
+  let collectedData = {};
+
+  if (getDataDetail.storageType === consts.STORAGE_TYPES.graph) {
+    // collect return data form main node
+    if (getDataResult.nodeProperties) {
+      for (let [mainFieldName, mainFieldNameValue] of Object.entries(getDataResult.nodeProperties)) {
+        if (getDataDetail.fieldNames.includes(mainFieldName)) {
+          Object.assign(collectedData, { [mainFieldName]: mainFieldNameValue });
+        }
+      }
+    }
+
+    // collect data from versionedData
+    if (getDataDetail.hasOwnProperty("versionedDatas") && Object.keys(getDataDetail.versionedDatas).length) {
+      let versionedDataLabels = Object.keys(getDataDetail.versionedDatas);
+
+      for (let versionedDataLabel of versionedDataLabels) {
+        if (getDataResult[versionedDataLabel]?.nodeProperties && Object.keys(getDataResult[versionedDataLabel].nodeProperties).length) {
+          let neededVersionedDataFieldNames = getDataDetail.versionedDatas[versionedDataLabel];
+
+          for (let neededVersionedDataFieldName of neededVersionedDataFieldNames) {
+            if (getDataResult[versionedDataLabel].nodeProperties[neededVersionedDataFieldName]) {
+              Object.assign(collectedData, { [neededVersionedDataFieldName]: getDataResult[versionedDataLabel].nodeProperties[neededVersionedDataFieldName] });
+            }
+          }
+        }
+      }
+    }
+
+  } else if (getDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
+
+    for (let [dynamoDbKey, dynamoDbValue] of Object.entries(getDataResult)) {
+      if (getDataDetail.fieldNames.includes(dynamoDbKey)) {
+        Object.assign(collectedData, { [dynamoDbKey]: dynamoDbValue });
+      }
+    }
+
+  } else {
+    throw new NoRetryError(`Unhandled storageType:${getDataDetail.storageType}`);
+  }
+
+  return collectedData
+}
+
+
+
+
+module.exports = {
+  sendMsgOutComplete,
+  messageToDlq,
+
+  validateSchemaMiddleware,
+  validateSchemaPerRecord,
+
+  createGetDataDetails,
+  generateDynamoDbIdentifiers,
+  generateDynamoDbIdentifiersWithCache,
+  dynamoDbIdentifiersByStorageResource,
+  collectGetData
+}
+
+
+
+
+
+// /**
+//  * filter request param depend on generatedValidatorSchema function
+//  * @param {object} _izContext
+//  * @param {object} requestParams            - requestParams that need to filter
+//  * @param {string} action                   - use to match generateValidatorSchemaFunction
+//  * @param {string} objectType               - objectType for search objectSchema
+//  * @param {string[]} specificFieldNames     - setting of generateValidatorSchemaFunction
+//  */
+// async function filterRequestParam(_izContext, requestParams, action, objectType, specificFieldNames) {
+
+//   if (!validatorSchema.schemaFunctionPerAction[action]) {
+//     throw new NoRetryError(`Not found function for generateValidatorSchema of action:${action}`);
+//   }
+
+//   // prepare variable
+//   const generateValidatorFunction = validatorSchema.schemaFunctionPerAction[action];
+
+//   const generatedValidatorSchema = await generateValidatorFunction(_izContext, objectType, specificFieldNames);
+
+//   // prepare new requestParams depend on properties of generatedValidatorSchema
+//   let newRequestParams = {}
+//   for (let validatorFieldName in generatedValidatorSchema.properties) {
+//     if (requestParams.hasOwnProperty(validatorFieldName)) {
+//       Object.assign(newRequestParams, { [validatorFieldName]: requestParams[validatorFieldName] })
+//     }
+//   }
+
+//   // add additionalRequest to requestParams
+//   if (requestParams.hasOwnProperty("additionalRequest") && Object.keys(requestParams.additionalRequest).length) {
+//     Object.assign(newRequestParams, { additionalRequest: requestParams.additionalRequest });
+//   }
+
+//   return newRequestParams
+// }
+
+
+// /**
+//  * reformat request for main function of each action
+//  * @param {Object} _izContext
+//  * @param {String} objectType
+//  * @param {String} action
+//  * @param {Object} requestParams
+//  * @returns
+//  */
+// async function reformattedRequestParams(_izContext, objectType, action, requestParams) {
+//   _izContext.logger.debug("------ reformattedRequestParams ------");
+//   _izContext.logger.debug("objectType: ", objectType);
+//   _izContext.logger.debug("action: ", action);
+//   _izContext.logger.debug("requestParams: ", requestParams);
+
+//   const objectSchema = await getObjectSchema.getLocalObjectSchemasWithHierarchy(_izContext, objectType).then(data => data.records[0]);
+//   _izContext.logger.debug("objectSchema in reformatted: ", objectSchema);
+
+//   const identifierFieldNames = utils.getUsedFieldNamesOfIdentifiers(_izContext, objectSchema.identifiers);
+//   _izContext.logger.debug("identifierFieldNames: ", identifierFieldNames);
+
+//   let versionedDatas = [];
+//   if (objectSchema?.addOnDataStructure?.length) {
+//     for (let eachAddOn of objectSchema.addOnDataStructure) {
+//       if (eachAddOn.type === "versionedData") {
+//         versionedDatas.push(eachAddOn);
+//       }
+//     }
+//   }
+
+
+
+//   let reformattedReq
+
+//   // reformat request depend on action
+//   switch (action) {
+//     case consts.ACTIONS.create:
+//       _izContext.logger.debug("reformatted case create");
+
+//       // initial format
+//       reformattedReq = {
+//         identifiers: {},
+//         createFieldNames: {},
+//         relationships: []
+//       };
+
+//       let createFieldNames = Object.entries(objectSchema.fieldNames).reduce((returnFieldNames, [fieldName, fieldNameData]) => {
+//         if (identifierFieldNames.includes(fieldName)) {
+//           return returnFieldNames;
+//         }
+
+//         if (fieldNameData.requiredOnCreate === true || fieldNameData.optionalOnCreate === true) {
+//           returnFieldNames.push(fieldName);
+//         }
+//         return returnFieldNames;
+//       }, [])
+
+
+
+//       _izContext.logger.debug("createFieldNames: ", createFieldNames);
+
+
+//       for (const [reqFieldName, reqFieldData] of Object.entries(requestParams.fieldNames)) {
+//         if (identifierFieldNames.includes(reqFieldName)) {
+//           Object.assign(
+//             reformattedReq.identifiers,
+//             { [reqFieldName]: reqFieldData }
+//           );
+//         } else {
+//           if (createFieldNames.includes(reqFieldName)) {
+//             Object.assign(
+//               reformattedReq.createFieldNames,
+//               { [reqFieldName]: reqFieldData }
+//             );
+//           }
+//         }
+//       }
+
+//       if (requestParams?.relationships?.length) {
+//         reformattedReq.relationships = reformattedReq.relationships.concat(requestParams.relationships)
+//       }
+
+//       break;
+//     case consts.ACTIONS.update:
+//       // code block
+//       break;
+//     case consts.ACTIONS.get:
+//       // code block
+//       break;
+//     case consts.ACTIONS.delete:
+//       // code block
+//       break;
+//     default:
+//       throw new NoRetryError(`reformattedRequestParams:unhandled action:${action}`)
+//   }
+
+//   return reformattedReq;
+// }
+
+// const reformattedRequestParamsWithCache = inMemoryCacheLib.inMemoryCacheLib(
+//   reformattedRequestParams, // fn
+//   {
+//     max: 100, maxAge: 86400000, promise: true, profileName: 'reformattedRequestParams',
+//     normalizer: function (args) {
+//       return hash([args[1], args[2], args[3]]);
+//     }
+//   }
+// )
+
+
+
+// /**
+//  * filter identifiers from requestParams depend on objectSchema.identifiers
+//  * @param {object} _izContext
+//  * @param {object} objectSchema         - objectSchema of objectType
+//  * @param {object} requestParams        - requestParams from handler
+//  * @returns
+//  */
+// function saperateIdentifierRequestParams(_izContext, objectSchema, requestParams) {
+
+//   let usedIdentifierTypes = utils.selectIdentifierTypeByPriority(_izContext, [], objectSchema);
+
+//   let identifierFieldNameList = utils.getUsedFieldNamesOfIdentifiers(_izContext, objectSchema.identifiers, usedIdentifierTypes);
+
+
+//   let identifiersObj = {};
+
+//   for (let identifierFieldName of identifierFieldNameList) {
+//     if (requestParams.hasOwnProperty(identifierFieldName)) {
+//       Object.assign(identifiersObj, { [identifierFieldName]: requestParams[identifierFieldName] });
+//     } else {
+//       throw new NoRetryError(`missing ${identifierFieldName} in requestParams`);
+//     }
+//   }
+
+
+//   return identifiersObj;
+// }
+
+
+
+
+// /*
+//   Q?
+//   - when perform action in dynamodb some table need to concatenate
+//   - need to generate new identifier of dynamodb depend on storageResource
+
+//   returnValue = {
+//     graph:{  // storageType
+//       graphHandler:{ // graph service name
+//         nodeLabel:"string" // generate node label here
+//         identifier: {
+//           prop1: value1,
+//           prop2: value2,
+//         },
+//         properties:{
+//           prop1: value1,
+//           prop2: value2,
+//         },
+//         versionedDataLabel:[
+//           // ...
+//         ],
+//         versionedDatas:[ // for [create | update] action
+//           {
+//             nodeLabel:"xxx",
+//             nodeProperties:{
+//               // ...versionedData node properties
+//             }
+//             hookProperties:["xxx", yyy]
+//           }
+//         ]
+//         nodePropertyLabel:{ // addOnDataStructure: type  = nodePropertyLabel | attributeTree | , not implement yet
+//           // ...setting
+//         }
+//       },
+//       mediaGraph:{ // graph service name
+//         prop1:value1,
+//         prop2:value2,
+//       }
+//     },
+//     dynamoDb:{ // storageType
+//       table1:{ // tableName
+//         identifier: {
+//           prop1: value1,
+//           prop2: value2,
+//         },
+//         properties{
+//           prop1: value1,
+//           prop2: value2,
+//         }
+//       },
+//       table2:{ // tableName
+//         identifier: {
+//           prop1: value1,
+//           prop2: value2,
+//         },
+//         properties{
+//           prop1: value1,
+//           prop2: value2,
+//         }
+//       }
+//     }
+//   }
+// */
+// async function saperateRequestByStorageResources(_izContext, objectSchema, requestParams, action) {
+//   _izContext.logger.debug("Function: saperateRequestByStorageResources :", { requestParams, action })
+
+//   // --------------  initial return value  --------------
+
+//   let returnValue = {}
+
+//   for (let storageType of consts.STORAGE_TYPE_LIST) {
+//     if (!returnValue.hasOwnProperty(storageType)) {
+//       returnValue[storageType] = {}
+//     }
+//   }
+
+//   _izContext.logger.debug("initial returnValue: ", returnValue);
+
+//   // --------------  initial return value  --------------
+
+
+
+//   // create identifier object from requestParams
+//   let identifierObj = saperateIdentifierRequestParams(_izContext, objectSchema, requestParams);
+
+//   // separate requestParams by storageType
+//   for (let [storageTag, storageData] of Object.entries(objectSchema.storageResources)) {
+
+//     if (storageData.storageType === consts.STORAGE_TYPES.dynamoDB) {
+
+//       // separate by tableName
+//       let dynamoRequestParams = await separateRequestByDynamoDb(
+//         _izContext,
+//         objectSchema,
+//         requestParams,
+//         identifierObj,
+//         storageTag,
+//         storageData
+//       );
+//       _izContext.logger.debug("dynamoRequestParams: ", dynamoRequestParams);
+
+//       let tableName = storageData.tableName;
+//       if (returnValue[consts.STORAGE_TYPES.dynamoDB][tableName]) {
+//         throw new NoRetryError(`Have duplicate tableName in storageTag:${storageTag}`);
+//       }
+
+//       Object.assign(returnValue[consts.STORAGE_TYPES.dynamoDB], { [tableName]: dynamoRequestParams });
+
+//     } else if (storageData.storageType === consts.STORAGE_TYPES.graph) {
+
+//       // separate by GraphServiceName
+//       let graphRequestParams = await separateRequestByGraph(
+//         _izContext,
+//         objectSchema,
+//         requestParams,
+//         identifierObj,
+//         storageTag,
+//         storageData,
+//         action
+//       );
+//       _izContext.logger.debug("graphRequestParams: ", graphRequestParams);
+
+//       let graphServiceName = await serviceConfig.getGraphServiceNameFromGraphServerTagWithCache(_izContext, storageData.graphServerTag);
+
+
+//       if (returnValue[consts.STORAGE_TYPES.graph][graphServiceName]) {
+//         // have exists graphServiceName,
+//         // need to merge properties for multiple graphServerTag to one serviceName
+//         _izContext.logger.debug('exists serviceName');
+//         _izContext.logger.debug('graphRequestParams : ', graphRequestParams);
+//         _izContext.logger.debug('returnValue[consts.STORAGE_TYPES.graph][graphServiceName]: ',
+//           returnValue[consts.STORAGE_TYPES.graph][graphServiceName]
+//         );
+
+//         // merge node properties
+//         for (let graphProperty in graphRequestParams.properties) {
+//           if (!returnValue[consts.STORAGE_TYPES.graph][graphServiceName].properties.hasOwnProperty(graphProperty)) {
+//             Object.assign(
+//               returnValue[consts.STORAGE_TYPES.graph][graphServiceName].properties,
+//               { [graphProperty]: graphRequestParams.properties[graphProperty] }
+//             );
+//           }
+//         }
+
+
+//         /*
+//           if versionedDatas exists in graphRequestParams
+//             - check versionedDatas exists in  returnValue[consts.STORAGE_TYPES.graph][graphServiceName]
+//             - if exists add versionedData in graphRequestParams to returnValue
+//             - if not exists create and add versionedDatas
+//         */
+
+//         // merge graph versionedData
+//         if (graphRequestParams.versionedDatas?.length) {
+//           if (Array.isArray(returnValue[consts.STORAGE_TYPES.graph][graphServiceName].versionedDatas)) {
+//             returnValue[consts.STORAGE_TYPES.graph][graphServiceName].versionedDatas =
+//               returnValue[consts.STORAGE_TYPES.graph][graphServiceName].versionedDatas.concat(graphRequestParams.versionedDatas)
+//           } else {
+//             returnValue[consts.STORAGE_TYPES.graph][graphServiceName].versionedDatas = graphRequestParams.versionedDatas
+//           }
+//         }
+
+
+//       } else {
+//         // not exists graphServiceName
+//         Object.assign(returnValue[consts.STORAGE_TYPES.graph], { [graphServiceName]: graphRequestParams });
+//       }
+
+//     } else {
+//       throw new NoRetryError(`Don't know storageType:${storageData.type} in storageTag:${storageTag}`);
+//     }
+//   }
+
+//   return returnValue
+
+// }
+
+
+
+
+
+// /**
+//  * helper function for separate requestParams depend on storageTag
+//  *
+//  * @param {Object} _izContext
+//  * @param {Object} objectSchema                  -
+//  * @param {Object} requestParams                 - requestParams from lambda
+//  * @param {Object} identifierObj                 - identifiers
+//  * @param {String} storageTag                    - storageTag of storageResource
+//  * @param {Object} storageData                   - data of storageResource
+//  * @returns {Object} - object of identifier and property for dynamodb
+//  */
+// async function separateRequestByDynamoDb(_izContext, objectSchema, requestParams, identifierObj, storageTag, storageData) {
+//   _izContext.logger.debug('separateRequestByDynamoDb: ', {
+//     requestParams,
+//     identifierObj,
+//     storageTag,
+//     storageData
+//   });
+
+
+//   //----------------------- Filter requestParams ------------------------
+
+//   // filter requestParams that includes in storageTag
+//   let filteredRequestParams = {}
+//   for (let [fieldName, fieldNameData] of Object.entries(objectSchema.fieldNames)) {
+//     if (fieldNameData.storageResourceTags.includes(storageTag) && requestParams.hasOwnProperty(fieldName)) {
+//       Object.assign(filteredRequestParams, { [fieldName]: requestParams[fieldName] });
+//     }
+//   }
+
+//   //----------------------- End Filter requestParams ------------------------
+
+
+//   //----------------------- Create dynamoDb identifier object ------------------------
+
+//   // use identifierObj to prepare dynamodb identifiers
+//   let usedIdentifierTypes = utils.selectIdentifierTypeByPriority(_izContext, [], objectSchema);
+
+//   let deliminatorTree = await serviceSchemas.generateDeliminatorTree(_izContext, objectSchema, { objectType: objectSchema.objectType, serviceTag: process.env.iz_serviceTag }, usedIdentifierTypes);
+//   _izContext.logger.debug(`deliminatorTree objectType: ${objectSchema.objectType} : `, deliminatorTree)
+
+//   let dynamoDbIdentifier = {};
+//   for (let identifier of objectSchema.identifiers) {
+
+//     if (!usedIdentifierTypes.includes(identifier.type)) {
+//       continue;
+//     }
+
+//     if (identifier.hasOwnProperty("fieldName")) {
+
+//       Object.assign(dynamoDbIdentifier, { [identifier.fieldName]: identifierObj[identifier.fieldName] });
+
+//     } else if (identifier.hasOwnProperty("name") && identifier.hasOwnProperty("fieldNames")) {
+
+//       let deliminator = identifier.deliminator ? identifier.deliminator : "_";
+
+//       // if deliminatorList exists overwrite deliminator
+//       if (deliminatorTree.identifiersToProcess?.[identifier.name]?.deliminatorList?.[deliminator]) {
+//         let deliminatorAmount = deliminatorTree[identifier.name].deliminatorList[deliminator];
+//         deliminator = deliminator.repeat(deliminatorAmount)
+//       }
+
+//       let fieldNameDataList = [];
+//       for (let identifierFieldName of identifier.fieldNames) {
+//         fieldNameDataList.push(identifierObj[identifierFieldName]);
+//       }
+
+//       Object.assign(dynamoDbIdentifier, { [identifier.name]: fieldNameDataList.join(deliminator) });
+
+//     } else {
+//       throw new NoRetryError('separateRequestByDynamoDb: invalid identifier');
+//     }
+//   }
+
+//   //----------------------- End Create dynamoDb identifier object ------------------------
+
+
+//   //----------------------- calculate composite deliminator amount ------------------------
+
+//   let compositeDeliminator = objectSchema.compositeKeyDeliminator ? objectSchema.compositeKeyDeliminator : "_";
+
+//   let compositeDeliminatorAmount = 0;
+//   for (let deliminatorDetail of Object.values(deliminatorTree.identifiersToProcess)) {
+//     if (deliminatorDetail?.deliminatorList?.[compositeDeliminator]) {
+//       compositeDeliminatorAmount = Math.max(compositeDeliminatorAmount, deliminatorDetail.deliminatorList[compositeDeliminator]);
+//     }
+//   }
+
+//   compositeDeliminatorAmount + 1;
+
+//   //----------------------- End calculate composite deliminator amount ------------------------
+
+
+//   //----------------------- create return value  ------------------------
+
+//   // initial returnValue
+//   let returnValue = {
+//     identifiers: {},
+//     properties: {}
+//   }
+
+//   if (storageData.hasOwnProperty("groupByPartitionKeyField")) {
+//     // concatenate identifierObj
+//     let newIdentifier = Object.values(identifierObj).join(compositeDeliminator.repeat(compositeDeliminatorAmount));
+
+//     Object.assign(returnValue.identifiers, { [storageData.groupByPartitionKeyField]: newIdentifier });
+//     Object.assign(returnValue.properties, filteredRequestParams);
+
+//   } else {
+//     returnValue.identifiers = identifierObj;
+
+//     for (let requestParamProperty in filteredRequestParams) {
+//       if (!identifierObj.hasOwnProperty(requestParamProperty)) {
+//         Object.assign(returnValue.properties, { [requestParamProperty]: filteredRequestParams[requestParamProperty] });
+//       }
+//     }
+
+//   }
+
+//   //----------------------- 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: ", {
+//     requestParams,
+//     identifierObj,
+//     storageTag,
+//     storageData,
+//     action
+//   });
+
+
+//   //----------------------- Filter requestParams ------------------------
+
+//   // filter requestParams that includes in storageTag
+//   let filteredRequestParams = {}
+//   for (let [fieldName, fieldNameData] of Object.entries(objectSchema.fieldNames)) {
+//     if (fieldNameData.storageResourceTags.includes(storageTag) && requestParams.hasOwnProperty(fieldName)) {
+//       Object.assign(filteredRequestParams, { [fieldName]: requestParams[fieldName] });
+//     }
+//   }
+
+//   //----------------------- End Filter requestParams ------------------------
+
+
+//   //----------------------- standard return value  ------------------------
+
+//   // initial returnValue
+//   let returnValue = {
+//     identifiers: {},
+//     properties: {}
+//   }
+
+//   // add nodeLabel
+//   if (objectSchema.hasOwnProperty("extendObjType")) {
+//     let nodeLabel = `${objectSchema.objectType}:${objectSchema.extendObjType.objectType}`;
+//     Object.assign(returnValue, { nodeLabel: nodeLabel });
+//   } else {
+//     Object.assign(returnValue, { nodeLabel: objectSchema.objectType });
+//   }
+
+//   // add identifiers
+//   returnValue.identifiers = identifierObj;
+
+//   // add properties from requestParams if not exists in identifierObj
+//   for (let requestParamProperty in filteredRequestParams) {
+//     if (!identifierObj.hasOwnProperty(requestParamProperty)) {
+//       Object.assign(returnValue.properties, { [requestParamProperty]: filteredRequestParams[requestParamProperty] });
+//     }
+//   }
+
+//   //----------------------- End standard return value  ------------------------
+
+
+//   //----------------------- prepare additional return data per action   ------------------------
+
+//   if (action === consts.ACTIONS.get) {
+
+//     if (
+//       requestParams?.additionalRequest?.versionedDataLabel
+//       && Array.isArray(requestParams.additionalRequest.versionedDataLabel)
+//       && requestParams.additionalRequest.versionedDataLabel.length
+//       && objectSchema.addOnDataStructure
+//       && Array.isArray(objectSchema.addOnDataStructure)
+//     ) {
+//       // if versionedDataLabel exists in requestParams
+//       // add versionedDataLabel to returnValue if exists in storageResourceTag
+
+//       // get addOnDataStructure versionedData depend on storageTag
+//       let allAddOnVersionedDataPerStorageTag = objectSchema.addOnDataStructure.filter(
+//         addOnVersionedData => (addOnVersionedData.type === "versionedData" && addOnVersionedData.storageResourceTag === storageTag)
+//       );
+
+//       for (let addOnVersionedData of allAddOnVersionedDataPerStorageTag) {
+//         if (requestParams.additionalRequest.versionedDataLabel.includes(addOnVersionedData.versionedDataLabel)) {
+
+//           if (!returnValue.hasOwnProperty("versionedDataLabel")) {
+//             returnValue.versionedDataLabel = []
+//           }
+
+//           returnValue.versionedDataLabel.push(addOnVersionedData.versionedDataLabel)
+//         }
+//       }
+//     }
+
+//   } else if (action === consts.ACTIONS.create) {
+
+
+//   } else if (action === consts.ACTIONS.update) {
+//     _izContext.logger.debug("filter versionedData update")
+//     _izContext.logger.debug("additionalReq: ", requestParams.additionalRequest.versionedDatas)
+//     _izContext.logger.debug("addOnDataStructure: ", objectSchema.addOnDataStructure)
+//     // {
+//     //   // ...properties
+//     //   additionalRequest: {
+//     //     versionedDatas: [
+//     //       {
+//     //         nodeLabel: "nodeLabelName",
+//     //         nodeProperties: {
+//     //           // ...properties of versionedData
+//     //         }
+//     //       }
+//     //     ]
+//     //    // ...other additional request
+//     //   }
+//     // }
+
+//     // separate create versionedData request
+//     if (
+//       requestParams?.additionalRequest?.versionedDatas
+//       && Array.isArray(requestParams.additionalRequest.versionedDatas)
+//       && requestParams.additionalRequest.versionedDatas.length
+//       && objectSchema.addOnDataStructure
+//       && Array.isArray(objectSchema.addOnDataStructure)
+//     ) {
+
+//       let versionedDataReqList = requestParams.additionalRequest.versionedDatas;
+
+//       // get addOnDataStructure versionedData depend on storageTag from objectSchema
+//       let allAddOnVersionedDataPerStorageTag = objectSchema.addOnDataStructure.filter(
+//         addOnVersionedData => (addOnVersionedData.type === "versionedData" && addOnVersionedData.storageResourceTag === storageTag)
+//       );
+
+//       _izContext.logger.debug('allAddOnVersionedDataPerStorageTag update: ', allAddOnVersionedDataPerStorageTag);
+
+//       // check versionedData label in requestParams exists in allAddOnVersionedDataPerStorageTag
+//       // if exists validate and add versionedData to return label
+//       if (allAddOnVersionedDataPerStorageTag.length) {
+//         for (let versionedDataReq of versionedDataReqList) {
+//           // find exists versionedData Schema
+//           let versionedDataSchema = allAddOnVersionedDataPerStorageTag.find(
+//             addOnVersionedData => addOnVersionedData.versionedDataLabel === versionedDataReq.nodeLabel
+//           );
+
+
+
+//           if (versionedDataSchema) {
+//             _izContext.logger.debug('exists versionedDataSchema: ', versionedDataSchema);
+
+//             // validate versionedData
+
+//             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);
+//             }
+
+//             if (!returnValue.hasOwnProperty("versionedDatas")) {
+//               returnValue.versionedDatas = [];
+//             }
+//             // end validate versionedData
+
+
+//             let hookProperties = [];
+//             for (let fieldNameSetting of versionedDataSchema.fieldNames) {
+//               hookProperties.push(fieldNameSetting.fieldName);
+//             }
+
+//             Object.assign(versionedDataReq, { hookProperties });
+
+//             returnValue.versionedDatas.push(versionedDataReq);
+//           }
+//         }
+//       }
+
+//     }
+
+
+//   } else if (action === consts.ACTIONS.delete) {
+
+//   } else {
+//     throw new NoRetryError("Function:separateRequestByGraph: invalid action")
+//   }
+
+//   //----------------------- 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: {}
+//   };
+
+//   for (let dynamoDbDataDetail of dynamoDbData) {
+//     for (let [dynamoDataProp, dynamoDataValue] of Object.entries(dynamoDbDataDetail)) {
+//       if (!mergedData.properties.hasOwnProperty(dynamoDataProp)) {
+//         Object.assign(mergedData.properties, { [dynamoDataProp]: dynamoDataValue })
+//       }
+//     }
+
+//   }
+
+//   for (let graphDataDetail of graphData) {
+//     // add nodeProperties to mergedData
+//     for (let [graphDataProp, graphDataValue] of Object.entries(graphDataDetail.nodeProperties)) {
+//       if (!mergedData.properties.hasOwnProperty(graphDataProp)) {
+//         Object.assign(mergedData.properties, { [graphDataProp]: graphDataValue })
+//       }
+//     }
+
+//     // add versionedData to mergedData
+//     for (let [graphDataProp, graphDataValue] of Object.entries(graphDataDetail)) {
+//       console.log({ graphDataProp, graphDataValue })
+//       if (graphDataProp === "nodeLabels" || graphDataProp === "nodeProperties") {
+//         continue;
+//       }
+
+
+//       if (Object.keys(graphDataValue.nodeProperties).length) {
+
+//         if (!mergedData.versionedDataLabel) {
+//           mergedData.versionedDataLabel = {}
+//         }
+
+//         Object.assign(mergedData.versionedDataLabel, { [graphDataValue.nodeLabels.join(":")]: graphDataValue.nodeProperties })
+//       }
+//     }
+//   }
+
+//   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
+
+//   // initial versionedData validatorSchema
+//   let versionedDataValidatorSchema = {
+//     type: "object",
+//     required: ['nodeLabel', 'nodeProperties'],
+//     properties: {
+//       nodeLabel: {
+//         type: 'string',
+//         pattern: nodeLabelRegexPattern
+//       },
+//       nodeProperties: {
+//         type: 'object',
+//         required: [], // require fieldName
+//         additionalProperties: false,
+//         properties: {}
+//       }
+//     }
+//   }
+
+//   // maybe not need to validate action get and delete because
+//   if (action === consts.ACTIONS.create) {
+//     for (let versionedFieldName of versionedObjDataSchema.fieldNames) {
+//       if (versionedFieldName.requireOnCreate === true || versionedFieldName.optionalOnCreate === true) {
+//         // add require fieldName to require array in validatorSchema
+//         if (versionedFieldName.requireOnCreate === true) {
+//           versionedDataValidatorSchema.properties.nodeProperties.required.push(versionedFieldName.fieldName)
+//         }
+
+//         // add validation to properties
+//         let versionedDataProperties = versionedDataValidatorSchema.properties.nodeProperties.properties;
+//         Object.assign(versionedDataProperties, {
+//           [versionedFieldName.fieldName]: {
+//             type: versionedFieldName.type,
+//             ...versionedFieldName.validation
+//           }
+//         })
+
+//       }
+//     }
+//   } else if (action === consts.ACTIONS.update) {
+//     for (let versionedFieldName of versionedObjDataSchema.fieldNames) {
+//       if (versionedFieldName.canUpdate === true || versionedFieldName.canUpdate === undefined) {
+
+//         // add validation to properties
+//         let versionedDataProperties = versionedDataValidatorSchema.properties.nodeProperties.properties;
+//         Object.assign(versionedDataProperties, {
+//           [versionedFieldName.fieldName]: {
+//             type: versionedFieldName.type,
+//             ...versionedFieldName.validation
+//           }
+//         })
+
+//       }
+//     }
+//   } else {
+//     throw new NoRetryError("Function:generateValidatorSchemaForVersionedData: invalid action")
+//   }
+
+//   // return validator schema of versionedData
+//   return versionedDataValidatorSchema;
+// }