npm - @izara_project/izara-market-library-service-schemas - Versions diffs - 1.0.83 → 1.0.85 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (839) hide show

package/src/GenerateCodeLibs/src/GenerateCodeLibs.js CHANGED Viewed

@@ -15,971 +15,28 @@ You should have received a copy of the GNU Affero General Public License
 along with this program.If not, see < http://www.gnu.org/licenses/>.
 */
-'use strict';
 import lodash from 'lodash';
 import { objectHash as hash } from '@izara_project/izara-shared-core';
-import { NoRetryError, inMemoryCacheLib, validator as validateObject } from '@izara_project/izara-core-library-core';
 import { sns, sqs } from '@izara_project/izara-core-library-external-request';
-import { getObjectSchema, validator as validatorSchema, serviceConfig, utils, consts as coreConsts, explodedReqParams, deliminatorTree } from '@izara_project/izara-core-library-service-schemas'
-import Logger from "@izara_project/izara-core-library-logger";
+import {
+  getObjectSchema,
+  consts as coreConsts,
+} from '@izara_project/izara-core-library-service-schemas';
 import { validateObjType } from '@izara_project/izara-shared-service-schemas';
 // core libs
 import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
-import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow'
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
-import sqsSharedLib from '@izara_project/izara-core-library-sqs';
 import snsSharedLib from '@izara_project/izara-core-library-sns';
 import graphSharedLibs from '@izara_project/izara-core-library-graph-service';
 import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
-import consts from './Consts.js'
-const { TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER, PREFIX } = consts
-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
-}
+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_-]+)?$';
 /**
  *
@@ -996,15 +53,27 @@ function createFieldForUpdateDynamoDb(_izContext, objectSchema, dynamoDataDetail
  * @param {Object} storageResources
  * @param {Boolean} topLevelParent
  */
-function createBasicRelationshipsProperties(from, to, storageResources, baseDirection, topLevelParent = false) {
-  validateObjType.validateObjType({ objectType: from.objectType, serviceTag: from.serviceTag });
-  validateObjType.validateObjType({ objectType: to.objectType, serviceTag: to.serviceTag });
+function createBasicRelationshipsProperties(
+  from,
+  to,
+  storageResources,
+  baseDirection,
+  topLevelParent = false
+) {
+  validateObjType.validateObjType({
+    objectType: from.objectType,
+    serviceTag: from.serviceTag
+  });
+  validateObjType.validateObjType({
+    objectType: to.objectType,
+    serviceTag: to.serviceTag
+  });
   let otherDirection;
-  if (baseDirection === "to") {
-    otherDirection = "from"
-  } else if (baseDirection === "from") {
-    otherDirection = "to"
+  if (baseDirection === 'to') {
+    otherDirection = 'from';
+  } else if (baseDirection === 'from') {
+    otherDirection = 'to';
   }
   let relationshipProperties = {
@@ -1042,51 +111,66 @@ function createBasicRelationshipsProperties(from, to, storageResources, baseDire
           requiredOnCreate: to.requiredOnCreate
         }
       }
-    ],
-  }
+    ]
+  };
   if (topLevelParent === true) {
-    relationshipProperties.links.push(
-      {
-        storageResourceTags: Object.keys(storageResources),
-        from: {
-          objType: {
-            serviceTag: to.serviceTag,
-            objectType: to.objectType
-          },
-          linkType: "one",
-          direction: "from",
-          requiredOnCreate: false
+    relationshipProperties.links.push({
+      storageResourceTags: Object.keys(storageResources),
+      from: {
+        objType: {
+          serviceTag: to.serviceTag,
+          objectType: to.objectType
         },
-        to: {
-          objType: {
-            serviceTag: to.serviceTag,
-            objectType: to.objectType
-          },
-          linkType: "many",
-          direction: "to",
-          requiredOnCreate: false
-        }
+        linkType: 'one',
+        direction: 'from',
+        requiredOnCreate: false
+      },
+      to: {
+        objType: {
+          serviceTag: to.serviceTag,
+          objectType: to.objectType
+        },
+        linkType: 'many',
+        direction: 'to',
+        requiredOnCreate: false
       }
-    )
+    });
   }
-  return relationshipProperties
+  return relationshipProperties;
 }
-function createFieldNamesFromRequestParamsByObjectSchema(_izContext, requestParams, objectSchema) {
+function createFieldNamesFromRequestParamsByObjectSchema(
+  _izContext,
+  requestParams,
+  objectSchema
+) {
   let createFieldNameParams = {};
-  _izContext.logger.debug("createFieldNamesFromRequestParamsByObjectSchema ::", { requestParams, objectSchema })
+  _izContext.logger.debug(
+    'createFieldNamesFromRequestParamsByObjectSchema ::',
+    { requestParams, objectSchema }
+  );
   for (const fieldName of Object.keys(objectSchema.fieldNames)) {
     if (Object.keys(requestParams).includes(fieldName)) {
       if (!createFieldNameParams.hasOwnProperty(fieldName)) {
-        Object.assign(createFieldNameParams, { [fieldName]: requestParams[fieldName] })
+        Object.assign(createFieldNameParams, {
+          [fieldName]: requestParams[fieldName]
+        });
       }
     }
   }
-  return createFieldNameParams
+  return createFieldNameParams;
 }
-async function sharedCreateEndpoint(_izContext, objType, requestParams, callingFlowConfig, settings = { userAgent: false, directInvoke: false, parentObject }) {
+async function sharedCreateEndpoint(_izContext,
+  objType,
+  requestParams,
+  callingFlowConfig,
+  settings = {
+    userAgent: false,
+    directInvoke: false,
+    parentObject: {}
+  }) {
   let objectSchemas = await getObjectSchema.getObjectSchemaCombineFieldNamesWithCache(_izContext, objType)
   let createDataDetails = await createDataDetailsLib(_izContext, objectSchemas)
   _izContext.logger.debug("createDataDetails is =", createDataDetails);
@@ -1096,44 +180,66 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
   let objInstanceFull = {
     identifiers: {},
     fields: {}
-  }
+  };
   for (let fieldName of Object.keys(requestParams.fieldNames)) {
     if (objectSchemas.identifierFieldNames.includes(fieldName)) {
-      _izContext.logger.debug("identifiers is", fieldName);
+      _izContext.logger.debug('identifiers is', fieldName);
       Object.assign(objInstanceFull.identifiers, {
         [fieldName]: requestParams.fieldNames[fieldName]
       });
-    };
-  };
+    }
+  }
   let objInstanceFullForDynamoDb = lodash.cloneDeep(objInstanceFull);
   let objInstanceFullForGraph = lodash.cloneDeep(objInstanceFull);
   let objInstanceFullForExternalTopic = lodash.cloneDeep(objInstanceFull);
-  for (const [storageTag, createDataDetail] of Object.entries(createDataDetails)) {
+  for (const [storageTag, createDataDetail] of Object.entries(
+    createDataDetails
+  )) {
     if (createDataDetail.storageType == coreConsts.STORAGE_TYPES.dynamoDB) {
-      _izContext.logger.debug("::::::DynamoDB::::::", { storageTag, objInstanceFull });
+      _izContext.logger.debug('::::::DynamoDB::::::', {
+        storageTag,
+        objInstanceFull
+      });
       if (settings.parentObject) {
-        if (createDataDetail.tableName.includes(firstLetterUpperCase(`${parentObject.objectType}Records`))) {
-          Object.assign(
-            objInstanceFullForDynamoDb.fields, {
-            [`${settings.parentObject.objectType}HandlerServiceTag`]: process.env.iz_serviceTag
-          })
+        if (
+          createDataDetail.tableName.includes(
+            firstLetterUpperCase(`${parentObject.objectType}Records`)
+          )
+        ) {
+          Object.assign(objInstanceFullForDynamoDb.fields, {
+            [`${settings.parentObject.objectType}HandlerServiceTag`]:
+              process.env.iz_serviceTag
+          });
         }
       }
-      Object.assign(objInstanceFullForDynamoDb.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
-      _izContext.logger.debug("objInstanceFull before create item in dynamoDB", objInstanceFullForDynamoDb)
+      Object.assign(
+        objInstanceFullForDynamoDb.fields,
+        createObjInstanceFullFieldsByStorageTag(
+          _izContext,
+          storageTag,
+          createDataDetail
+        )
+      );
+      _izContext.logger.debug(
+        'objInstanceFull before create item in dynamoDB',
+        objInstanceFullForDynamoDb
+      );
       let identifiersForCreateData = await dynamoDbIdentifiersByStorageResource(
         _izContext,
         objectSchemas,
         createDataDetail,
         objInstanceFullForDynamoDb.identifiers
-      )
-      _izContext.logger.debug("identifiersForCreateData", identifiersForCreateData);
+      );
+      _izContext.logger.debug(
+        'identifiersForCreateData',
+        identifiersForCreateData
+      );
       await dynamodbSharedLib.putItem(
         _izContext,
@@ -1148,7 +254,7 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
         }
       );
-      objInstanceFullForDynamoDb.fields = {} // prevent using fieldNames from other tableName
+      objInstanceFullForDynamoDb.fields = {}; // prevent using fieldNames from other tableName
       if (allAwaitingStepsId.length == 0) {
         let messageObject = {
           objType: objType,
@@ -1156,49 +262,85 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
             identifiers: objInstanceFullForDynamoDb.identifiers,
             fields: objInstanceFullForDynamoDb.fields
           }
-        }
+        };
-        if (callingFlowConfig[callingFlowSharedLib.coreConsts.CALLINGFLOW_PROPERTYNAME]) {
+        if (
+          callingFlowConfig[
+          callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME
+          ]
+        ) {
           // send message to SNS OutCreateNodeComplete
-          _izContext.logger.debug("HAVE CallingFlow");
-          messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
+          _izContext.logger.debug('HAVE CallingFlow');
+          messageObject =
+            callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
+              callingFlowConfig,
+              messageObject
+            );
-          let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
-          let outCreateNodeCompleteTopic = await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
+          let messageAttributes =
+            callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+              callingFlowConfig,
+              {}
+            );
+          let outCreateNodeCompleteTopic =
+            await snsSharedLib.snsTopicArnByFlowSchema(
+              _izContext,
+              TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete
+            );
           let messageParams = {
             Message: JSON.stringify(messageObject),
-            MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-            TopicArn: outCreateNodeCompleteTopic,
+            MessageAttributes: sns.createStringMessageAttributes(
+              _izContext,
+              messageAttributes
+            ),
+            TopicArn: outCreateNodeCompleteTopic
           };
-          _izContext.logger.debug("messageParams OutCreateNode ::::::: ", messageParams);
+          _izContext.logger.debug(
+            'messageParams OutCreateNode ::::::: ',
+            messageParams
+          );
           await sns.publishAsync(_izContext, messageParams);
         }
         return {
           objType: objType,
           objInstanceFull: objInstanceFullForDynamoDb,
           relationships: requestParams.relationships || [],
-          status: "complete",
+          status: 'complete',
           errorsFound: []
-        }
+        };
       }
     } else if (createDataDetail.storageType == coreConsts.STORAGE_TYPES.graph) {
-      _izContext.logger.debug("::::::Graph::::::", { storageTag, objInstanceFull });
+      _izContext.logger.debug('::::::Graph::::::', {
+        storageTag,
+        objInstanceFull
+      });
-      Object.assign(objInstanceFullForGraph.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
-      _izContext.logger.debug("objInstanceFull before send to Graph", objInstanceFullForGraph)
+      Object.assign(
+        objInstanceFullForGraph.fields,
+        createObjInstanceFullFieldsByStorageTag(
+          _izContext,
+          storageTag,
+          createDataDetail
+        )
+      );
+      _izContext.logger.debug(
+        'objInstanceFull before send to Graph',
+        objInstanceFullForGraph
+      );
       // allStorageTagComplete = false;
-      allAwaitingStepsId.push(await asyncFlowSharedLib.createAwaitingStepId(
-        (hash({
-          objType: objType,
-          graphServerTag: storageTag,
-          identifiers: objInstanceFullForGraph.identifiers,
-          callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
-        })),
-        PREFIX.CREATE_OBJECT_ASYNC
-      ));
+      allAwaitingStepsId.push(
+        await asyncFlowSharedLib.createAwaitingStepId(
+          hash({
+            objType: objType,
+            graphServerTag: storageTag,
+            identifiers: objInstanceFullForGraph.identifiers,
+            callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
+          }),
+          PREFIX.CREATE_OBJECT_ASYNC
+        )
+      );
       listOfObjectForCreates.push({
         [storageTag]: {
           objInstanceFull: {
@@ -1209,42 +351,71 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
         }
       });
-      _izContext.logger.debug("FIRST", listOfObjectForCreates)
-    } else if (createDataDetail.storageType === coreConsts.STORAGE_TYPES.externalTopic) {
-      _izContext.logger.debug("::::::externalTopic::::::", { storageTag, createDataDetail });
-      Object.assign(objInstanceFullForExternalTopic.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
-      _izContext.logger.debug("objInstanceFull before send to external topic", objInstanceFullForExternalTopic)
+      _izContext.logger.debug('FIRST', listOfObjectForCreates);
+    } else if (
+      createDataDetail.storageType === coreConsts.STORAGE_TYPES.externalTopic
+    ) {
+      _izContext.logger.debug('::::::externalTopic::::::', {
+        storageTag,
+        createDataDetail
+      });
+      Object.assign(
+        objInstanceFullForExternalTopic.fields,
+        createObjInstanceFullFieldsByStorageTag(
+          _izContext,
+          storageTag,
+          createDataDetail
+        )
+      );
+      _izContext.logger.debug(
+        'objInstanceFull before send to external topic',
+        objInstanceFullForExternalTopic
+      );
-      allAwaitingStepsId.push(await asyncFlowSharedLib.createAwaitingStepId(
-        (hash({
-          objType: objType,
-          graphServerTag: storageTag,
-          identifiers: objInstanceFullForGraph.identifiers,
-          callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
-        })),
-        PREFIX.CREATE_OBJECT_EXTERNAL_TOPIC
-      ));
+      allAwaitingStepsId.push(
+        await asyncFlowSharedLib.createAwaitingStepId(
+          hash({
+            objType: objType,
+            graphServerTag: storageTag,
+            identifiers: objInstanceFullForGraph.identifiers,
+            callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
+          }),
+          PREFIX.CREATE_OBJECT_EXTERNAL_TOPIC
+        )
+      );
       let sendToCreateExternalTopic = {
-        Message: JSON.stringify({ objType, objInstanceFull: objInstanceFullForExternalTopic, relationships: requestParams.relationships }),
+        Message: JSON.stringify({
+          objType,
+          objInstanceFull: objInstanceFullForExternalTopic,
+          relationships: requestParams.relationships
+        }),
         TopicArn: `arn:aws:sns:${createDataDetail.region}:${createDataDetail.accountId}:${createDataDetail.serviceTag}_${createDataDetail.stage}_Create_In`
       };
-      _izContext.logger.debug("Request params before send to create endpoint:", sendToCreateExternalTopic);
+      _izContext.logger.debug(
+        'Request params before send to create endpoint:',
+        sendToCreateExternalTopic
+      );
-      await sns.publishAsync(_izContext, sendToCreateExternalTopic)
-      return sendToCreateExternalTopic
+      await sns.publishAsync(_izContext, sendToCreateExternalTopic);
+      return sendToCreateExternalTopic;
     }
-  };
-  _izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
+  }
+  _izContext.logger.debug(
+    '[1]listOfObjectForCreates:::',
+    listOfObjectForCreates
+  );
   /// step save awaitingMultipleStep of storageType graph ...........................................................
   if (!settings.userAgent) {
-    _izContext.logger.debug("not api will create awaitingStep")
+    _izContext.logger.debug('not api will create awaitingStep');
     await asyncFlowSharedLib.createAwaitingMultipleSteps(
       _izContext,
       allAwaitingStepsId,
-      asyncFlowSharedLib.createPendingStepId((hash({ objType: objType, identifiers: objInstanceFull.identifiers })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)
+      asyncFlowSharedLib.createPendingStepId(
+        hash({ objType: objType, identifiers: objInstanceFull.identifiers }),
+        PREFIX.CREATE_OBJECT_ASYNC_COMPLETE
+      )
     );
   }
   //............................................................................................................
@@ -1252,28 +423,34 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
   // process storageType : graph
   let messageObject = {};
   for (let objectCreate of listOfObjectForCreates) {
-    for (let [graphServiceName, objectForCreate] of Object.entries(objectCreate)) {
-      _izContext.logger.debug("Loop each graph:", {
+    for (let [graphServiceName, objectForCreate] of Object.entries(
+      objectCreate
+    )) {
+      _izContext.logger.debug('Loop each graph:', {
         [graphServiceName]: objectForCreate
       });
-      if (objectForCreate.allStorageTagComplete == false) { // needless check because in listOfObjectForCreates push case graph  only!
+      if (objectForCreate.allStorageTagComplete == false) {
+        // needless check because in listOfObjectForCreates push case graph  only!
         messageObject = {
           objType: objType,
           objInstanceFull: objectForCreate.objInstanceFull,
           relationships: requestParams.relationships || []
         };
-      };
+      }
-      _izContext.logger.debug("SENT MESSAGE EACH GRAPH::::", { graphServiceName, messageObject, callingFlowConfig })
+      _izContext.logger.debug('SENT MESSAGE EACH GRAPH::::', {
+        graphServiceName,
+        messageObject,
+        callingFlowConfig
+      });
       Object.assign(messageObject, {
         settings: { updatePropertiesOnMatch: false },
-        originTimestamp: Date.now(),
+        originTimestamp: Date.now()
       });
       if (settings.userAgent) {
-        _izContext.logger.debug("have userAgent will invoke GraphHandler")
+        _izContext.logger.debug('have userAgent will invoke GraphHandler');
         let createNodeResult = await graphSharedLibs.createNodeV2(
           _izContext,
           graphServiceName,
@@ -1284,11 +461,12 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
           {
             updatePropertiesOnMatch: false
           }
-        )
-        return createNodeResult
+        );
+        return createNodeResult;
       } else if (settings.directInvoke) {
-        _izContext.logger.debug("Direction Invoke case will invoke GraphHandlerInv")
+        _izContext.logger.debug(
+          'Direction Invoke case will invoke GraphHandlerInv'
+        );
         let createNodeResult = await graphSharedLibs.createNodeV2(
           _izContext,
           graphServiceName,
@@ -1303,48 +481,76 @@ async function sharedCreateEndpoint(_izContext, objType, requestParams, callingF
         return createNodeResult;
       } else {
-        _izContext.logger.debug("not have userAgent will send Message to GraphHandler")
-        messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-          messageObject,
-          callingFlowSharedLib.addParentCallingFlowConfig(
-            callingFlowConfig, // receive parent callingFlowConfig.
-            callingFlowSharedLib.createCallingFlowConfig( // calling flow own service
-              await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.createNodeComplete), {}
-            )
-          )
+        _izContext.logger.debug(
+          'not have userAgent will send Message to GraphHandler'
         );
+        messageObject =
+          callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+            messageObject,
+            callingFlowSharedLib.addParentCallingFlowConfig(
+              callingFlowConfig, // receive parent callingFlowConfig.
+              callingFlowSharedLib.createCallingFlowConfig(
+                // calling flow own service
+                await lambdaSharedLib.lambdaFunctionName(
+                  _izContext,
+                  TOPIC_NAME_GENERATE_CODE.createNodeComplete
+                ),
+                {}
+              )
+            )
+          );
         let messageToCreateObject = {
           Message: JSON.stringify(messageObject),
-          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GRAPH_HANDLER.inCreateNode, graphServiceName)
+          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
+            _izContext,
+            TOPIC_NAME_GRAPH_HANDLER.inCreateNode,
+            graphServiceName
+          )
         };
-        _izContext.logger.debug("RequestParams before send to sqs messageToCreateObject ::::::: ", messageToCreateObject);
+        _izContext.logger.debug(
+          'RequestParams before send to sqs messageToCreateObject ::::::: ',
+          messageToCreateObject
+        );
         await sns.publishAsync(_izContext, messageToCreateObject);
-        return messageObject
+        return messageObject;
       }
-    };
-  };
+    }
+  }
-  function createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail) {
+  function createObjInstanceFullFieldsByStorageTag(
+    _izContext,
+    storageTag,
+    createDataDetail
+  ) {
     let fields = {};
     for (let fieldName of Object.keys(requestParams.fieldNames)) {
-      if ((createDataDetails[storageTag].fieldNames.includes(fieldName)) &&
-        (createDataDetail.fieldNames.includes(fieldName))) {
+      if (
+        createDataDetails[storageTag].fieldNames.includes(fieldName) &&
+        createDataDetail.fieldNames.includes(fieldName)
+      ) {
         if (!objInstanceFull.identifiers.hasOwnProperty(fieldName)) {
           if (!fields.hasOwnProperty(fieldName)) {
             Object.assign(fields, {
               [fieldName]: requestParams.fieldNames[fieldName]
-            })
+            });
           }
         }
       }
     }
-    return fields
+    return fields;
   }
 }
-async function sharedCreateCompleteEndpoint(_izContext, returnValue, status, errorsFound, graphServiceTag, passBackProperties) {
+async function sharedCreateCompleteEndpoint(
+  _izContext,
+  returnValue,
+  status,
+  errorsFound,
+  graphServiceTag,
+  passBackProperties
+) {
   let existsNode = null;
   let createNodeFinished = false;
   if (Object.keys(returnValue.queryResult.returnCreateNode.existsNode).length) {
@@ -1353,65 +559,88 @@ async function sharedCreateCompleteEndpoint(_izContext, returnValue, status, err
         objectType: returnValue.requestParams.objType.objectType,
         serviceTag: returnValue.requestParams.objType.serviceTag
       },
-      objInstanceFull: returnValue.queryResult.returnCreateNode.existsNode.objInstanceFull
-    }
+      objInstanceFull:
+        returnValue.queryResult.returnCreateNode.existsNode.objInstanceFull
+    };
   }
   let awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
-    (hash({
+    hash({
       objType: returnValue.requestParams.objType,
       graphServerTag: graphServiceTag,
       identifiers: returnValue.requestParams.objInstanceFull.identifiers,
-      callingFlowProperties: passBackProperties.passBackProperties.parentPassBackProperties.callingFlowProperties || {}
-    })),
+      callingFlowProperties:
+        passBackProperties.passBackProperties.parentPassBackProperties
+          .callingFlowProperties || {}
+    }),
     PREFIX.CREATE_OBJECT_ASYNC
-  )
-  _izContext.logger.debug("awaitingStepId:", awaitingStepId);
+  );
+  _izContext.logger.debug('awaitingStepId:', awaitingStepId);
   let recordAwaitingSteps = await dynamodbSharedLib.query(
     _izContext,
-    await dynamodbSharedLib.tableName(_izContext, "AwaitingMultipleSteps"),
+    await dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
     {
       awaitingStepId: awaitingStepId
     }
   );
-  _izContext.logger.debug("record awaitingSteps::", recordAwaitingSteps);
+  _izContext.logger.debug('record awaitingSteps::', recordAwaitingSteps);
   await Promise.all(
     recordAwaitingSteps.Items.map(async ({ pendingStepId }) => {
-      if (await asyncFlowSharedLib.checkAllAwaitingStepsFinished(
-        _izContext,
-        pendingStepId,
-        awaitingStepId,
-        errorsFound
-      )) {
-        _izContext.logger.debug("finish all awaitingStep");
+      if (
+        await asyncFlowSharedLib.checkAllAwaitingStepsFinished(
+          _izContext,
+          pendingStepId,
+          awaitingStepId,
+          errorsFound
+        )
+      ) {
+        _izContext.logger.debug('finish all awaitingStep');
         let messageObject = {
           objType: {
             objectType: returnValue.requestParams.objType.objectType,
             serviceTag: returnValue.requestParams.objType.serviceTag
           },
-          objInstanceFull: returnValue.queryResult.returnCreateNode.objInstanceFull,
+          objInstanceFull:
+            returnValue.queryResult.returnCreateNode.objInstanceFull,
           relationships: returnValue.queryResult.returnCreateNode.relationships,
           existsNode: existsNode,
           status: status,
           errorsFound: errorsFound
-        }
+        };
-        messageObject = callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(passBackProperties, messageObject)
-        let messageAttributes = callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(passBackProperties, {})
+        messageObject =
+          callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
+            passBackProperties,
+            messageObject
+          );
+        let messageAttributes =
+          callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
+            passBackProperties,
+            {}
+          );
         let sendMessageOutCreateObjectComplete = {
           Message: JSON.stringify(messageObject),
-          MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
+          MessageAttributes: sns.createStringMessageAttributes(
+            _izContext,
+            messageAttributes
+          ),
+          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
+            _izContext,
+            TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete
+          )
         };
-        _izContext.logger.debug("Send message to OutCreateObjectComplete :::>", sendMessageOutCreateObjectComplete)
+        _izContext.logger.debug(
+          'Send message to OutCreateObjectComplete :::>',
+          sendMessageOutCreateObjectComplete
+        );
         await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
-        createNodeFinished = true
+        createNodeFinished = true;
       } else {
-        createNodeFinished = false
+        createNodeFinished = false;
       }
       await asyncFlowSharedLib.removeAwaitingMultipleStep(
@@ -1420,820 +649,14 @@ async function sharedCreateCompleteEndpoint(_izContext, returnValue, status, err
         pendingStepId,
         errorsFound
       );
     })
-  )
-  return createNodeFinished
+  );
+  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;
-// }
+  sharedCreateCompleteEndpoint,
+};