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

package/src/GenerateCodeLibs/src/GenerateCodeLibs.js

@@ -1,2583 +0,0 @@
-/*
-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/>.
-*/
-
-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 { 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 { 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 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;
-
-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
-};
-
-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 ----------
-*/
-
-/**
- *
- * @param {middleware} middleware
- * @param {string} objectType           - name of ObjectType
- * @param {string} action               - action type of Lambda create | update | get | delete
- */
-function validateSchemaMiddleware(
-  middleware,
-  // objectType,
-  action,
-  bucketName = process.env.iz_serviceSchemaBucketName
-  // setting = {}
-) {
-  if (!schemaFunctionPerAction[action] || !explodeDataPerAction[action]) {
-    throw new NoRetryError(
-      `Not found function for generateValidatorSchema or explodeDataPerAction of action:${action}`
-    );
-  }
-  // Logger.debug("setting in generateCodeLibs", setting)
-  middleware.setServiceSchema(
-    schemaFunctionPerAction[action],
-    explodeDataPerAction[action],
-    {
-      //   objectType: objectType,
-      //   specificFieldNames: setting?.specificFieldNames ? setting.specificFieldNames : [],
-      action: action,
-      bucketName: bucketName
-    }
-  );
-}
-
-/**
- * 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,
-  setting = {
-    bucketName: process.env.iz_serviceSchemaBucketName,
-    specificFieldNames: []
-  }
-) {
-  try {
-    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}`
-      );
-    }
-
-    const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
-      record._izContext,
-      objType
-    );
-
-    if (!objectSchema) {
-      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 explodedDataRequestParams = await explodeDataFunction(
-      record._izContext,
-      record.body.Message,
-      objectSchema,
-      setting
-    );
-
-    record._izContext.logger.debug(
-      'explodedDataRequestParams in validateSchemaPerRecord : ',
-      JSON.stringify(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);
-    }
-  } 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);
-  }
-}
-
-/**
- * use to create validation for initialize request
- *
- * @param {object} _izContext
- * @param {object} flowType
- * @param {object} flowType.flowTag
- * @param {object} flowType.serviceTag
- * @returns {object}
- */
-
-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
-  );
-}
-
-/**
- *
- * @param {middleware} middleware
- * @param {string} objectType           - name of ObjectType
- * @param {string} action               - action type of Lambda create | update | get | delete
- */
-function validatorSchemaMiddlewareByAction(
-  middleware,
-  // objectType,
-  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', {
-    middleware,
-    // objectType,
-    action,
-    setting
-  });
-  Logger.debug('setting in generateCodeLibs', setting);
-  middleware.setServiceSchema(
-    // schemaFunctionPerAction[action],
-    // explodeDataPerAction[action],
-    {
-      // objectType: objectType,
-      specificFieldNames: setting?.specificFieldNames
-        ? setting.specificFieldNames
-        : [],
-      action: action
-    }
-  );
-}
-// /**
-//  * use to validate record for Lambda handler hdrSqs/hdrDsq
-//  * Note!: cannot throw error when use this function outside recordHandler
-
-//  * @param {string} objectType                     - name of ObjectType
-//  * @param {string} action                         - action type of Lambda create | update | get | delete
-//  * @param {object} [setting]
-//  */
-// async function validateSchemaPerWebSocket(
-//   _izContext,
-//   requestParams,
-//   objectType,
-//   action,
-//   setting = {}
-// ) {
-//   _izContext.logger.debug("validateSchema Per WebSocketFunction", {
-//     objectType,
-//     requestParams,
-//     action,
-//     setting
-//   })
-//   try {
-//     if (action === "update") {
-//       setting.updateScenario = "versionedData"
-//     }
-
-//     const objType = utils.createObjType(objectType)
-//     _izContext.logger.debug("objType in validatorSchema per WebSocket", objType)
-
-//     const objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(_izContext, objType);
-//     _izContext.logger.debug("objectSchema", objectSchema)
-//     const generateValidatorSchema = schemaFunctionPerAction[action];
-//     const explodeDataFunction = explodeDataPerAction[action];
-
-//     const generateValidatorSchemaPerWebSocket = await generateValidatorSchema(_izContext, objType, setting);
-//     _izContext.logger.debug("Generate Validator Schema For WebSocket :", generateValidatorSchemaPerWebSocket);
-
-//     const explodedDataPerWebSocket = await explodeDataFunction(_izContext, requestParams, objectSchema, setting);
-
-//     _izContext.logger.debug("exploded RequestParams Data in GeneratorValidatorSchema :", explodedDataPerWebSocket);
-
-//     let validateStatus = validateObject(_izContext, generateValidatorSchemaPerWebSocket, explodedDataPerWebSocket);
-//     _izContext.logger.debug('validateStatus : ', validateStatus);
-
-//     if (!validateStatus.pass) {
-//       const validatorError = new Error(`validation failed: ${validateStatus.error}`)
-//       throw validatorError;
-//     }
-//   } catch (err) {
-//     _izContext.logger.error("Error in validateSchemaPerWebSocket:", err);
-//     throw err;
-//   }
-// }
-
-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: await snsSharedLib.snsTopicArn(_izContext, 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);
-  record._izContext.logger.debug(
-    '----- messageToDlq sendMessage success -----'
-  );
-}
-
-// {
-//   [storageTag]: {
-//     storageType: 'graph',
-//     graphServiceTag: 'GraphHandler',
-//     fieldNames: [ 'companyName', 'companyId' ],
-//     versionedDatas: {
-//       ceo: [ 'name', 'ceoAddress', 'salary' ],
-//       branch: [ 'branchAddress', 'branchId' ]
-//     }
-//     versionedDataLabels:[],
-//   }
-// }
-
-/**
- * helper function for get endpoint
- * create get data detail for each storageTag
- *
- * @param {Object} _izContext
- * @param {Object} objectSchema
- */
-async function createGetDataDetails(
-  _izContext,
-  objectSchema,
-  settings = { bucketName: process.env.iz_serviceSchemaBucketName }
-) {
-  // 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 (fieldName.startsWith("versionedDataField")) {
-      //   continue;
-      // }
-
-      if (fieldNameData.storageResourceTags.includes(storageTag)) {
-        storageTagFieldNames.push(fieldName);
-      }
-    }
-
-    if (storageData.storageType === coreConsts.STORAGE_TYPES.graph) {
-      let useStorageTag = storageTag;
-      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);
-
-        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]) {
-          _izContext.logger.debug(
-            'versionedData.fieldNames',
-            versionedData.fieldNames
-          );
-          let versionedDataFieldNames = Object.keys(versionedData.fieldNames);
-          Object.assign(getGraphDataDetails[useStorageTag].versionedDatas, {
-            [versionedData.versionedDataLabel]: versionedDataFieldNames
-          });
-        }
-      }
-    } else if (storageData.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
-      let serviceTag = storageData.serviceTag || process.env.iz_serviceTag;
-      Object.assign(getDynamoDbDataDetails, {
-        [storageTag]: {
-          storageType: storageData.storageType,
-          tableName: storageData.tableName,
-          serviceTag: serviceTag,
-          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);
-
-  for (const getDataDetail of Object.values(getDataDetailResults)) {
-    if (getDataDetail.hasOwnProperty('versionedDatas')) {
-      getDataDetail.versionedDataLabels = [];
-      for (let [versionedDataLabel, fieldNames] of Object.entries(
-        getDataDetail.versionedDatas
-      )) {
-        getDataDetail.versionedDataLabels.push(versionedDataLabel);
-        getDataDetail.fieldNames.push(...fieldNames);
-      }
-    }
-  }
-
-  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,
-  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 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
-        );
-
-        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(
-  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} dynamoStorageResource
- * @param {Object} reqIdentifiers
- */
-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 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];
-        }
-      }
-    }
-
-    // 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 = {
-      [dynamoStorageResource.groupByPartitionKeyField]: newIdentifierValue
-    };
-  } else {
-    identifiersByStorageResource = dynamoIdentifiers;
-  }
-
-  return identifiersByStorageResource;
-}
-
-/**
- * receive result from multiple database and create data format depend on returnFormat setting
- *
- * @param {object} _izContext
- * @param {object[]} getResults
- * @param {object} objectSchema
- * @returns
- */
-function collectGetData(
-  _izContext,
-  getResults,
-  objectSchema,
-  returnSystemFieldsName
-) {
-  _izContext.logger.debug('collectGetData: ', {
-    getResults,
-    objectSchema,
-    returnSystemFieldsName
-  });
-
-  let collectedData = {
-    identifiers: {},
-    fields: {}
-  };
-
-  if (returnSystemFieldsName) {
-    Object.assign(collectedData, { versionDataSystemFields: {} });
-  }
-  const identifierFieldNames = new Set(
-    utils.getUsedFieldNamesOfIdentifiers(_izContext, objectSchema.identifiers)
-  );
-
-  let addedFieldNames = new Set();
-
-  //  if isFound === true then return null from this function
-  let isFound = false;
-
-  for (const [getData, getDataDetail] of getResults) {
-    if (!getData || !Object.keys(getData).length) {
-      continue;
-    }
-
-    // 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
-      ) {
-        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]
-            });
-            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]
-            });
-            addedFieldNames.add(getDetailFieldName);
-            isFound = true;
-          }
-        }
-      }
-      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
-    ) {
-      for (const getDetailFieldName of getDataDetail.fieldNames) {
-        if (addedFieldNames.has(getDetailFieldName)) {
-          continue;
-        }
-
-        if (getData.hasOwnProperty(getDetailFieldName)) {
-          if (identifierFieldNames.has(getDetailFieldName)) {
-            Object.assign(collectedData.identifiers, {
-              [getDetailFieldName]: getData[getDetailFieldName]
-            });
-            addedFieldNames.add(getDetailFieldName);
-            isFound = true;
-          } else {
-            Object.assign(collectedData.fields, {
-              [getDetailFieldName]: getData[getDetailFieldName]
-            });
-            addedFieldNames.add(getDetailFieldName);
-            isFound = true;
-          }
-        }
-      }
-    } else {
-      throw new NoRetryError('collectGetData unhandled storageType');
-    }
-  }
-
-  if (isFound) {
-    return collectedData;
-  } else {
-    return null;
-  }
-}
-
-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
-  )) {
-    let storageFieldNames = [];
-    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);
-        }
-      }
-    }
-    if (storageProperties.storageType === coreConsts.STORAGE_TYPES.graph) {
-      let graphStorageTagPerGraphServiceTag = {};
-      let useStorageTag = storageTag;
-      let graphServiceName = await serviceConfig.getGraphServiceTagWithCache(
-        _izContext,
-        storageProperties.graphServerTag,
-        settings.bucketName
-      );
-      if (!graphStorageTagPerGraphServiceTag.hasOwnProperty(graphServiceName)) {
-        graphStorageTagPerGraphServiceTag[graphServiceName] = storageTag;
-        _izContext.logger.debug(
-          'graphStorageTagPerGraphServiceTag',
-          graphStorageTagPerGraphServiceTag
-        );
-      } else {
-        _izContext.logger.debug('current storageTag', storageTag);
-        _izContext.logger.debug('used storageTag', useStorageTag);
-        useStorageTag = graphStorageTagPerGraphServiceTag[graphServiceName];
-      }
-      if (!getGraphDataDetails.hasOwnProperty(useStorageTag)) {
-        getGraphDataDetails[graphServiceName] = {
-          storageType: storageProperties.storageType,
-          fieldNames: storageFieldNames
-        };
-      } else {
-        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;
-      Object.assign(getDynamoDbDataDetails, {
-        [storageTag]: {
-          storageType: storageProperties.storageType,
-          tableName: storageProperties.tableName,
-          serviceTag: serviceTag,
-          fieldNames: storageFieldNames
-        }
-      });
-
-      if (storageTag.groupByPartitionKeyField) {
-        Object.assign(getDynamoDbDataDetails[storageTag], {
-          groupByPartitionKeyField: storageProperties.groupByPartitionKeyField
-        });
-      }
-    }
-  }
-
-  _izContext.logger.debug('getGraphDataDetails', getGraphDataDetails);
-  _izContext.logger.debug('getDynamoDataDetail', getDynamoDbDataDetails);
-
-  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
-  });
-  /**
-   * TODO: crate DataDetail now will get parent objectSchema if have extendObjType
-   * will split fieldNames for each serviceTag and storageREsourceTags
-   * */
-
-  let createDataDetails = {};
-
-  let storageResources = objectSchemas.storageResources;
-  _izContext.logger.debug('storageResources:', storageResources);
-
-  for (let [keyFieldName, settingFieldName] of Object.entries(
-    objectSchemas.fieldNames
-  )) {
-    // _izContext.logger.debug("Loop fieldNamesObjectSchemas", { keyFieldName });
-
-    for (let eachStorageResourceTag of settingFieldName.storageResourceTags) {
-      // _izContext.logger.debug("Loop eachStorageResourceTags", eachStorageResourceTag);
-
-      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 (createDataDetails.hasOwnProperty(eachStorageResourceTag)) {
-            // _izContext.logger.debug("SAME STG DB", eachStorageResourceTag);
-            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,
-                fieldNames: [keyFieldName]
-              }
-            });
-
-            if (
-              storageResources[eachStorageResourceTag].hasOwnProperty(
-                'groupByPartitionKeyField'
-              )
-            ) {
-              Object.assign(createDataDetails[eachStorageResourceTag], {
-                groupByPartitionKeyField:
-                  storageResources[eachStorageResourceTag]
-                    .groupByPartitionKeyField
-              });
-            }
-          }
-        } 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
-              );
-            } else {
-              // _izContext.logger.debug("NEW STG", checkGraphServerTags);
-              Object.assign(createDataDetails, {
-                [checkGraphServerTags]: {
-                  storageType: coreConsts.STORAGE_TYPES.graph,
-                  fieldNames: [keyFieldName]
-                }
-              });
-            }
-          }
-        } 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,
-              fieldNames: [keyFieldName],
-              accountId: storageResources[eachStorageResourceTag].accountId,
-              region: storageResources[eachStorageResourceTag].region,
-              serviceTag: storageResources[eachStorageResourceTag].serviceTag,
-              stage: storageResources[eachStorageResourceTag].stage
-            }
-          });
-        }
-      }
-    } // end loop storageResourceTags
-  } // end loop
-
-  return createDataDetails;
-}
-
-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
-  )) {
-    if (storageProperties.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
-      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
-        });
-      }
-    } else if (
-      storageProperties.storageType === coreConsts.STORAGE_TYPES.graph
-    ) {
-      let dataDetailPerGraphStorage = {};
-      let useStorageTag = storageTag;
-      let graphServiceName = await serviceConfig.getGraphServiceTagWithCache(
-        _izContext,
-        storageProperties.graphServerTag,
-        settings.bucketName
-      );
-      if (!dataDetailPerGraphStorage.hasOwnProperty(graphServiceName)) {
-        dataDetailPerGraphStorage[graphServiceName] = storageTag;
-      } else {
-        useStorageTag = dataDetailPerGraphStorage[graphServiceName];
-      }
-      if (!deleteGraphDataDetail.hasOwnProperty(useStorageTag)) {
-        deleteGraphDataDetail[graphServiceName] = {
-          storageType: storageProperties.storageType
-        };
-      }
-    }
-  }
-  _izContext.logger.debug('deleteGraphDataDetail', deleteGraphDataDetail);
-  _izContext.logger.debug('deleteDynamoDataDetail', deleteDynamoDataDetail);
-  Object.assign(
-    allDeleteDataDetail,
-    deleteGraphDataDetail,
-    deleteDynamoDataDetail
-  );
-
-  _izContext.logger.debug('allDeleteDataDetail', allDeleteDataDetail);
-  return allDeleteDataDetail;
-}
-
-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')
-    ) {
-      if (dynamoDataDetail.fieldNames.includes(fieldName)) {
-        if (fields[fieldName]) {
-          if (!fieldsForUpdateDynamo.hasOwnProperty(fields[fieldName])) {
-            _izContext.logger.debug('assign new fieldName', fields[fieldName]);
-            Object.assign(fieldsForUpdateDynamo, {
-              [fieldName]: fields[fieldName]
-            });
-          }
-        }
-      }
-    }
-  }
-  return fieldsForUpdateDynamo;
-}
-
-/**
- *
- * @param {Object} from
- * @param {String} from.objectType
- * @param {String} from.serviceTag
- * @param {String} from.linkType
- * @param {String} from.requiredOnCreate
- * @param {Object} to
- * @param {String} to.objectType
- * @param {String} to.serviceTag
- * @param {String} to.linkType
- * @param {String} to.requiredOnCreate
- * @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
-  });
-
-  let otherDirection;
-  if (baseDirection === 'to') {
-    otherDirection = 'from';
-  } else if (baseDirection === 'from') {
-    otherDirection = 'to';
-  }
-
-  let relationshipProperties = {
-    fieldNames: {
-      originTimeStamp: {
-        type: 'number',
-        requiredOnCreate: true,
-        canUpdate: false,
-        validation: {
-          minimum: 1111111111111,
-          maximum: 9999999999999
-        }
-      }
-    },
-    storageResources: storageResources,
-    links: [
-      {
-        storageResourceTags: Object.keys(storageResources),
-        from: {
-          objType: {
-            objectType: from.objectType,
-            serviceTag: from.serviceTag
-          },
-          linkType: from.linkType,
-          direction: baseDirection,
-          requiredOnCreate: from.requiredOnCreate
-        },
-        to: {
-          objType: {
-            objectType: to.objectType,
-            serviceTag: to.serviceTag
-          },
-          linkType: to.linkType,
-          direction: otherDirection,
-          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
-      },
-      to: {
-        objType: {
-          serviceTag: to.serviceTag,
-          objectType: to.objectType
-        },
-        linkType: 'many',
-        direction: 'to',
-        requiredOnCreate: false
-      }
-    });
-  }
-  return relationshipProperties;
-}
-
-function createFieldNamesFromRequestParamsByObjectSchema(
-  _izContext,
-  requestParams,
-  objectSchema
-) {
-  let createFieldNameParams = {};
-  _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]
-        });
-      }
-    }
-  }
-  return createFieldNameParams;
-}
-
-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);
-  let listOfObjectForCreates = [];
-  let allAwaitingStepsId = [];
-
-  let objInstanceFull = {
-    identifiers: {},
-    fields: {}
-  };
-
-  for (let fieldName of Object.keys(requestParams.fieldNames)) {
-    if (objectSchemas.identifierFieldNames.includes(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
-  )) {
-    if (createDataDetail.storageType == coreConsts.STORAGE_TYPES.dynamoDB) {
-      _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
-          });
-        }
-      }
-
-      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
-      );
-
-      await dynamodbSharedLib.putItem(
-        _izContext,
-        await dynamodbSharedLib.tableName(
-          _izContext,
-          createDataDetail.tableName,
-          createDataDetail.serviceTag
-        ),
-        {
-          ...identifiersForCreateData,
-          ...objInstanceFullForDynamoDb.fields
-        }
-      );
-
-      objInstanceFullForDynamoDb.fields = {}; // prevent using fieldNames from other tableName
-      if (allAwaitingStepsId.length == 0) {
-        let messageObject = {
-          objType: objType,
-          objInstanceFull: {
-            identifiers: objInstanceFullForDynamoDb.identifiers,
-            fields: objInstanceFullForDynamoDb.fields
-          }
-        };
-
-        if (
-          callingFlowConfig[
-          callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME
-          ]
-        ) {
-          // send message to SNS OutCreateNodeComplete
-          _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 messageParams = {
-            Message: JSON.stringify(messageObject),
-            MessageAttributes: sns.createStringMessageAttributes(
-              _izContext,
-              messageAttributes
-            ),
-            TopicArn: outCreateNodeCompleteTopic
-          };
-
-          _izContext.logger.debug(
-            'messageParams OutCreateNode ::::::: ',
-            messageParams
-          );
-          await sns.publishAsync(_izContext, messageParams);
-        }
-        return {
-          objType: objType,
-          objInstanceFull: objInstanceFullForDynamoDb,
-          relationships: requestParams.relationships || [],
-          status: 'complete',
-          errorsFound: []
-        };
-      }
-    } else if (createDataDetail.storageType == coreConsts.STORAGE_TYPES.graph) {
-      _izContext.logger.debug('::::::Graph::::::', {
-        storageTag,
-        objInstanceFull
-      });
-
-      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
-        )
-      );
-      listOfObjectForCreates.push({
-        [storageTag]: {
-          objInstanceFull: {
-            identifiers: objInstanceFullForGraph.identifiers,
-            fields: objInstanceFullForGraph.fields
-          },
-          allStorageTagComplete: false
-        }
-      });
-
-      _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
-        )
-      );
-
-      let sendToCreateExternalTopic = {
-        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
-      );
-
-      await sns.publishAsync(_izContext, sendToCreateExternalTopic);
-      return sendToCreateExternalTopic;
-    }
-  }
-  _izContext.logger.debug(
-    '[1]listOfObjectForCreates:::',
-    listOfObjectForCreates
-  );
-
-  /// step save awaitingMultipleStep of storageType graph ...........................................................
-  if (!settings.userAgent) {
-    _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
-      )
-    );
-  }
-  //............................................................................................................
-
-  // process storageType : graph
-  let messageObject = {};
-  for (let objectCreate of listOfObjectForCreates) {
-    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!
-        messageObject = {
-          objType: objType,
-          objInstanceFull: objectForCreate.objInstanceFull,
-          relationships: requestParams.relationships || []
-        };
-      }
-
-      _izContext.logger.debug('SENT MESSAGE EACH GRAPH::::', {
-        graphServiceName,
-        messageObject,
-        callingFlowConfig
-      });
-
-      Object.assign(messageObject, {
-        settings: { updatePropertiesOnMatch: false },
-        originTimestamp: Date.now()
-      });
-      if (settings.userAgent) {
-        _izContext.logger.debug('have userAgent will invoke GraphHandler');
-        let createNodeResult = await graphSharedLibs.createNodeV2(
-          _izContext,
-          graphServiceName,
-          objType,
-          objInstanceFullForGraph,
-          requestParams.relationships || [],
-          Date.now(),
-          {
-            updatePropertiesOnMatch: false
-          }
-        );
-        return createNodeResult;
-      } else if (settings.directInvoke) {
-        _izContext.logger.debug(
-          'Direction Invoke case will invoke GraphHandlerInv'
-        );
-        let createNodeResult = await graphSharedLibs.createNodeV2(
-          _izContext,
-          graphServiceName,
-          objType,
-          objInstanceFullForGraph,
-          requestParams.relationships,
-          Date.now(),
-          {
-            updatePropertiesOnMatch: false
-          }
-        );
-
-        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
-                ),
-                {}
-              )
-            )
-          );
-
-        let messageToCreateObject = {
-          Message: JSON.stringify(messageObject),
-          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
-            _izContext,
-            TOPIC_NAME_GRAPH_HANDLER.inCreateNode,
-            graphServiceName
-          )
-        };
-        _izContext.logger.debug(
-          'RequestParams before send to sqs messageToCreateObject ::::::: ',
-          messageToCreateObject
-        );
-        await sns.publishAsync(_izContext, messageToCreateObject);
-
-        return messageObject;
-      }
-    }
-  }
-
-  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 (!objInstanceFull.identifiers.hasOwnProperty(fieldName)) {
-          if (!fields.hasOwnProperty(fieldName)) {
-            Object.assign(fields, {
-              [fieldName]: requestParams.fieldNames[fieldName]
-            });
-          }
-        }
-      }
-    }
-    return fields;
-  }
-}
-
-async function sharedCreateCompleteEndpoint(
-  _izContext,
-  returnValue,
-  status,
-  errorsFound,
-  graphServiceTag,
-  passBackProperties
-) {
-  let existsNode = null;
-  let createNodeFinished = false;
-  if (Object.keys(returnValue.queryResult.returnCreateNode.existsNode).length) {
-    existsNode = {
-      objType: {
-        objectType: returnValue.requestParams.objType.objectType,
-        serviceTag: returnValue.requestParams.objType.serviceTag
-      },
-      objInstanceFull:
-        returnValue.queryResult.returnCreateNode.existsNode.objInstanceFull
-    };
-  }
-
-  let awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
-    hash({
-      objType: returnValue.requestParams.objType,
-      graphServerTag: graphServiceTag,
-      identifiers: returnValue.requestParams.objInstanceFull.identifiers,
-      callingFlowProperties:
-        passBackProperties.passBackProperties.parentPassBackProperties
-          .callingFlowProperties || {}
-    }),
-    PREFIX.CREATE_OBJECT_ASYNC
-  );
-  _izContext.logger.debug('awaitingStepId:', awaitingStepId);
-
-  let recordAwaitingSteps = await dynamodbSharedLib.query(
-    _izContext,
-    await dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
-    {
-      awaitingStepId: awaitingStepId
-    }
-  );
-  _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');
-
-        let messageObject = {
-          objType: {
-            objectType: returnValue.requestParams.objType.objectType,
-            serviceTag: returnValue.requestParams.objType.serviceTag
-          },
-          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,
-            {}
-          );
-
-        let sendMessageOutCreateObjectComplete = {
-          Message: JSON.stringify(messageObject),
-          MessageAttributes: sns.createStringMessageAttributes(
-            _izContext,
-            messageAttributes
-          ),
-          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
-            _izContext,
-            TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete
-          )
-        };
-        _izContext.logger.debug(
-          'Send message to OutCreateObjectComplete :::>',
-          sendMessageOutCreateObjectComplete
-        );
-        await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
-        createNodeFinished = true;
-      } else {
-        createNodeFinished = false;
-      }
-
-      await asyncFlowSharedLib.removeAwaitingMultipleStep(
-        _izContext,
-        awaitingStepId,
-        pendingStepId,
-        errorsFound
-      );
-    })
-  );
-  return createNodeFinished;
-}
-
-export default {
-  sendMsgOutComplete,
-  messageToDlq,
-
-  validateSchemaMiddleware,
-  validateSchemaPerRecord,
-  validatorSchemaMiddlewareByAction,
-
-  createGetDataDetails,
-  collectGetData,
-
-  generateDynamoDbIdentifiers,
-  generateDynamoDbIdentifiersWithCache,
-  dynamoDbIdentifiersByStorageResource,
-  createUpdateDataDetail,
-  createDataDetailsLib,
-  createDeleteDataDetail,
-
-  createFieldForUpdateDynamoDb,
-  createBasicRelationshipsProperties,
-  createFieldNamesFromRequestParamsByObjectSchema,
-  sharedCreateEndpoint,
-  sharedCreateCompleteEndpoint
-};
-
-// /**
-//  * 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 coreConsts.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 coreConsts.ACTIONS.update:
-//       // code block
-//       break;
-//     case coreConsts.ACTIONS.get:
-//       // code block
-//       break;
-//     case coreConsts.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 coreConsts.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 === coreConsts.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[coreConsts.STORAGE_TYPES.dynamoDB][tableName]) {
-//         throw new NoRetryError(`Have duplicate tableName in storageTag:${storageTag}`);
-//       }
-
-//       Object.assign(returnValue[coreConsts.STORAGE_TYPES.dynamoDB], { [tableName]: dynamoRequestParams });
-
-//     } else if (storageData.storageType === coreConsts.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[coreConsts.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[coreConsts.STORAGE_TYPES.graph][graphServiceName]: ',
-//           returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName]
-//         );
-
-//         // merge node properties
-//         for (let graphProperty in graphRequestParams.properties) {
-//           if (!returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName].properties.hasOwnProperty(graphProperty)) {
-//             Object.assign(
-//               returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName].properties,
-//               { [graphProperty]: graphRequestParams.properties[graphProperty] }
-//             );
-//           }
-//         }
-
-//         /*
-//           if versionedDatas exists in graphRequestParams
-//             - check versionedDatas exists in  returnValue[coreConsts.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[coreConsts.STORAGE_TYPES.graph][graphServiceName].versionedDatas)) {
-//             returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName].versionedDatas =
-//               returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName].versionedDatas.concat(graphRequestParams.versionedDatas)
-//           } else {
-//             returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName].versionedDatas = graphRequestParams.versionedDatas
-//           }
-//         }
-
-//       } else {
-//         // not exists graphServiceName
-//         Object.assign(returnValue[coreConsts.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 === coreConsts.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 === coreConsts.ACTIONS.create) {
-
-//   } else if (action === coreConsts.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 === coreConsts.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 === coreConsts.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 === coreConsts.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;
-// }