@izara_project/izara-market-library-service-schemas 1.0.75 → 1.0.77

package/src/GenerateCodeLibs/src/GenerateCodeLibs.js

@@ -17,44 +17,40 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 
 'use strict';
 
-const lodash = require('lodash');
-const hash = require('@izara_project/izara-shared-core').objectHash;
-const snsSharedLib = require('@izara_project/izara-core-library-sns');
-const sqsSharedLib = require('@izara_project/izara-core-library-sqs');
-const inMemoryCacheLib = require('@izara_project/izara-core-library-core').inMemoryCacheLib;
-const callingFlowSharedLib = require('@izara_project/izara-core-library-calling-flow');
-const sns = require('@izara_project/izara-core-library-external-request/src/resources/Sns');
-const sqs = require('@izara_project/izara-core-library-external-request/src/resources/Sqs');
-const NoRetryError = require('@izara_project/izara-core-library-core/src/NoRetryError');
-const getObjectSchema = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema')
-const validatorSchema = require('@izara_project/izara-core-library-service-schemas/src/ValidatorSchema');
-const serviceConfig = require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig');
-const utils = require('@izara_project/izara-core-library-service-schemas/src/Utils');
-const consts = require('@izara_project/izara-core-library-service-schemas/src/Consts');
-const explodedReqParams = require('@izara_project/izara-core-library-service-schemas/src/libs/ExplodedReqParams');
-const {
-  generateDeliminatorTreeIdentifier,
-  generateDeliminatorTreePerFieldName
-} = require('@izara_project/izara-core-library-service-schemas/src/libs/DeliminatorTree');
-const Logger = require("@izara_project/izara-core-library-logger");
+import lodash from 'lodash';
+import { objectHash as hash } from '@izara_project/izara-shared-core';
+import { NoRetryError, inMemoryCacheLib } from '@izara_project/izara-core-library-core';
+import { sns, sqs } from '@izara_project/izara-core-library-external-request';
+import { getObjectSchema, validator as validatorSchema, serviceConfig, utils, consts as coreConsts, explodedReqParams, deliminatorTree } from '@izara_project/izara-core-library-service-schemas'
+import Logger from "@izara_project/izara-core-library-logger";
+
+import { validateObjType } from '@izara_project/izara-shared-service-schemas';
+import { validator as validateObject } from "@izara_project/izara-core-library-core"
+// core libs
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow'
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import sqsSharedLib from '@izara_project/izara-core-library-sqs';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import graphSharedLibs from '@izara_project/izara-core-library-graph-service';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+import consts from './Consts.js'
+const { TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER, PREFIX } = consts
 
 const nodeLabelRegexPattern = "^[a-zA-Z0-9_-]+(?:\:[a-zA-Z0-9_-]+)?$"
-const { validateObjType } = require('@izara_project/izara-shared-service-schemas').validateObjType;
-// const { validateObject } = require('@izara_project/izara-core-library-core').validator
-const { validateObject } = require("@izara_project/izara-core-library-core").validator
 
 const schemaFunctionPerAction = {
-  [consts.ACTIONS.create]: validatorSchema.generateValidatorSchemaForCreate,
-  [consts.ACTIONS.update]: validatorSchema.generateValidatorSchemaForUpdate,
-  [consts.ACTIONS.get]: validatorSchema.generateValidatorSchemaForIdentifier,
-  [consts.ACTIONS.delete]: validatorSchema.generateValidatorSchemaForIdentifier,
+  [coreConsts.ACTIONS.create]: validatorSchema.generateValidatorSchemaForCreate,
+  [coreConsts.ACTIONS.update]: validatorSchema.generateValidatorSchemaForUpdate,
+  [coreConsts.ACTIONS.get]: validatorSchema.generateValidatorSchemaForIdentifier,
+  [coreConsts.ACTIONS.delete]: validatorSchema.generateValidatorSchemaForIdentifier,
 }
 
 const explodeDataPerAction = {
-  [consts.ACTIONS.create]: explodedReqParams.explodedDataForCreate,
-  [consts.ACTIONS.get]: explodedReqParams.explodedDataForIdentifiers,
-  [consts.ACTIONS.update]: explodedReqParams.explodedDataForUpdate,
-  [consts.ACTIONS.delete]: explodedReqParams.explodedDataForIdentifiers
+  [coreConsts.ACTIONS.create]: explodedReqParams.explodedDataForCreate,
+  [coreConsts.ACTIONS.get]: explodedReqParams.explodedDataForIdentifiers,
+  [coreConsts.ACTIONS.update]: explodedReqParams.explodedDataForUpdate,
+  [coreConsts.ACTIONS.delete]: explodedReqParams.explodedDataForIdentifiers
 }
 
 
@@ -150,7 +146,7 @@ async function validateSchemaPerRecord(
     let validateStatus = validateObject(generatedSchema, explodedDataRequestParams);
     record._izContext.logger.debug('validateStatus : ', validateStatus);
 
-    // if not pass validate will sent messsage to dlq and throw NoRetryError
+    // 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)
@@ -394,7 +390,7 @@ async function createGetDataDetails(_izContext, objectSchema, settings = { bucke
       }
     }
 
-    if (storageData.storageType === consts.STORAGE_TYPES.graph) {
+    if (storageData.storageType === coreConsts.STORAGE_TYPES.graph) {
 
       let useStorageTag = storageTag;
       let graphServiceTag = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageData.graphServerTag, settings.bucketName);
@@ -439,7 +435,7 @@ async function createGetDataDetails(_izContext, objectSchema, settings = { bucke
         }
       }
 
-    } else if (storageData.storageType === consts.STORAGE_TYPES.dynamoDB) {
+    } else if (storageData.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
       let serviceTag = storageData.serviceTag || process.env.iz_serviceTag
       Object.assign(getDynamoDbDataDetails, {
         [storageTag]: {
@@ -553,14 +549,14 @@ async function generateDynamoDbIdentifiers(_izContext, objectSchema, reqIdentifi
 
   for (let identifier of objectSchema.identifiers) {
     if (identifier.name) {
-      let deliminator = identifier.deliminator || consts.DEFAULT_IDENTIFIER_DELIMINATOR;
+      let deliminator = identifier.deliminator || coreConsts.DEFAULT_IDENTIFIER_DELIMINATOR;
       let currentDeliminatorAmount = 0;
 
       let concatenateValue = [];
       for (let fieldName of identifier.fieldNames) {
         concatenateValue.push(reqIdentifiers[fieldName]);
 
-        let deliminatorTreeFieldName = await generateDeliminatorTreePerFieldName(_izContext, fieldName, objectSchema.fieldNames[fieldName], {}, bucketName);
+        let deliminatorTreeFieldName = await deliminatorTree.generateDeliminatorTreePerFieldName(_izContext, fieldName, objectSchema.fieldNames[fieldName], {}, bucketName);
         _izContext.logger.debug("deliminatorTreeFieldName: ", deliminatorTreeFieldName);
 
         if (deliminatorTreeFieldName[fieldName]?.deliminatorList?.[deliminator]) {
@@ -625,10 +621,10 @@ async function dynamoDbIdentifiersByStorageResource(_izContext, objectSchema, dy
 
   if (dynamoStorageResource.groupByPartitionKeyField) {
 
-    let deliminatorTreeIdentifiers = await generateDeliminatorTreeIdentifier(_izContext, objectSchema, bucketName);
+    let deliminatorTreeIdentifiers = await deliminatorTree.generateDeliminatorTreeIdentifier(_izContext, objectSchema, bucketName);
     _izContext.logger.debug("deliminatorTree: ", deliminatorTreeIdentifiers);
 
-    let compositeKeyDeliminator = objectSchema.compositeKeyDeliminator || consts.DEFAULT_IDENTIFIER_DELIMINATOR;
+    let compositeKeyDeliminator = objectSchema.compositeKeyDeliminator || coreConsts.DEFAULT_IDENTIFIER_DELIMINATOR;
 
     let currentDeliminatorAmount = 0;
 
@@ -698,7 +694,7 @@ function collectGetData(_izContext, getResults, objectSchema, returnSystemFields
     }
 
     // this process will add result from graph and dynamo to collectedData object by add identifiers and fieldName from getData
-    if (getDataDetail.storageType === consts.STORAGE_TYPES.graph) {
+    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)) {
@@ -725,7 +721,7 @@ function collectGetData(_izContext, getResults, objectSchema, returnSystemFields
       if (getData.returnValue.queryResults.refactoredNodes.versionDataSystemFields || returnSystemFieldsName == true) {
         Object.assign(collectedData.versionDataSystemFields, getData.returnValue.queryResults.refactoredNodes.versionDataSystemFields)
       }
-    } else if (getDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
+    } else if (getDataDetail.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
       for (const getDetailFieldName of getDataDetail.fieldNames) {
         if (addedFieldNames.has(getDetailFieldName)) {
           continue;
@@ -776,7 +772,7 @@ async function createUpdateDataDetail(_izContext, objectSchema, settings = { buc
         }
       }
     }
-    if (storageProperties.storageType === consts.STORAGE_TYPES.graph) {
+    if (storageProperties.storageType === coreConsts.STORAGE_TYPES.graph) {
       let graphStorageTagPerGraphServiceTag = {}
       let useStorageTag = storageTag;
       let graphServiceName = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageProperties.graphServerTag, settings.bucketName)
@@ -797,7 +793,7 @@ async function createUpdateDataDetail(_izContext, objectSchema, settings = { buc
       } else {
         getGraphDataDetails[graphServiceName].fieldNames = [...new Set(getGraphDataDetails[useStorageTag].fieldNames.concat(storageFieldNames))]
       }
-    } else if (storageProperties.storageType === consts.STORAGE_TYPES.dynamoDB) {
+    } else if (storageProperties.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
       let serviceTag = storageProperties.serviceTag || process.env.iz_serviceTag;
       Object.assign(getDynamoDbDataDetails, {
         [storageTag]: {
@@ -847,7 +843,7 @@ async function createDataDetailsLib(_izContext, objectSchemas, settings = { buck
       if (!storageResources.hasOwnProperty(eachStorageResourceTag)) {
         throw new Error("storageResources is'n exist"); // should be validate in step upload in s3
       } else {
-        if (storageResources[eachStorageResourceTag].storageType == consts.STORAGE_TYPES.dynamoDB) {
+        if (storageResources[eachStorageResourceTag].storageType == coreConsts.STORAGE_TYPES.dynamoDB) {
           if (createDataDetails.hasOwnProperty(eachStorageResourceTag)) {
             // _izContext.logger.debug("SAME STG DB", eachStorageResourceTag);
             createDataDetails[eachStorageResourceTag].fieldNames.push(keyFieldName);
@@ -855,7 +851,7 @@ async function createDataDetailsLib(_izContext, objectSchemas, settings = { buck
           } else {
             Object.assign(createDataDetails, {
               [eachStorageResourceTag]: {
-                storageType: consts.STORAGE_TYPES.dynamoDB,
+                storageType: coreConsts.STORAGE_TYPES.dynamoDB,
                 tableName: storageResources[eachStorageResourceTag].tableName,
                 serviceTag: storageResources[eachStorageResourceTag].serviceTag || process.env.iz_serviceTag,
                 fieldNames: [keyFieldName]
@@ -868,7 +864,7 @@ async function createDataDetailsLib(_izContext, objectSchemas, settings = { buck
               });
             }
           }
-        } else if (storageResources[eachStorageResourceTag].storageType == consts.STORAGE_TYPES.graph) {
+        } else if (storageResources[eachStorageResourceTag].storageType == coreConsts.STORAGE_TYPES.graph) {
           let checkGraphServerTags = await serviceConfig.getGraphServiceTagWithCache(
             _izContext,
             storageResources[eachStorageResourceTag].graphServerTag,
@@ -883,17 +879,17 @@ async function createDataDetailsLib(_izContext, objectSchemas, settings = { buck
               // _izContext.logger.debug("NEW STG", checkGraphServerTags);
               Object.assign(createDataDetails, {
                 [checkGraphServerTags]: {
-                  storageType: consts.STORAGE_TYPES.graph,
+                  storageType: coreConsts.STORAGE_TYPES.graph,
                   fieldNames: [keyFieldName]
                 }
               });
             };
           };
-        } else if (storageResources[eachStorageResourceTag].storageType === consts.STORAGE_TYPES.externalTopic) {
+        } 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: consts.STORAGE_TYPES.externalTopic,
+              storageType: coreConsts.STORAGE_TYPES.externalTopic,
               fieldNames: [keyFieldName],
               accountId: storageResources[eachStorageResourceTag].accountId,
               region: storageResources[eachStorageResourceTag].region,
@@ -915,7 +911,7 @@ async function createDeleteDataDetail(_izContext, objectSchema, settings = { buc
   let allDeleteDataDetail = {};
 
   for (let [storageTag, storageProperties] of Object.entries(objectSchema.storageResources)) {
-    if (storageProperties.storageType === consts.STORAGE_TYPES.dynamoDB) {
+    if (storageProperties.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
       let serviceTag = storageProperties.serviceTag || process.env.iz_serviceTag;
       Object.assign(deleteDynamoDataDetail, {
         [storageTag]: {
@@ -932,7 +928,7 @@ async function createDeleteDataDetail(_izContext, objectSchema, settings = { buc
           }
         )
       }
-    } else if (storageProperties.storageType === consts.STORAGE_TYPES.graph) {
+    } else if (storageProperties.storageType === coreConsts.STORAGE_TYPES.graph) {
       let dataDetailPerGraphStorage = {};
       let useStorageTag = storageTag
       let graphServiceName = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageProperties.graphServerTag, settings.bucketName);
@@ -1001,8 +997,8 @@ function createFieldForUpdateDynamoDb(_izContext, objectSchema, dynamoDataDetail
  * @param {Boolean} topLevelParent
  */
 function createBasicRelationshipsProperties(from, to, storageResources, baseDirection, topLevelParent = false) {
-  validateObjType({ objectType: from.objectType, serviceTag: from.serviceTag });
-  validateObjType({ objectType: to.objectType, serviceTag: to.serviceTag });
+  validateObjType.validateObjType({ objectType: from.objectType, serviceTag: from.serviceTag });
+  validateObjType.validateObjType({ objectType: to.objectType, serviceTag: to.serviceTag });
 
   let otherDirection;
   if (baseDirection === "to") {
@@ -1090,7 +1086,347 @@ function createFieldNamesFromRequestParamsByObjectSchema(_izContext, requestPara
   return createFieldNameParams
 }
 
-module.exports = {
+async function sharedCreateEndpoint(_izContext, objType, requestParams, callingFlowConfig, settings = { userAgent: false, directInvoke: false, parentObject }) {
+  let objectSchemas = await getObjectSchema.getObjectSchemaCombineFieldNamesWithCache(_izContext, objType)
+  let createDataDetails = await createDataDetailsLib(_izContext, objectSchemas)
+  _izContext.logger.debug("createDataDetails is =", createDataDetails);
+  let listOfObjectForCreates = [];
+  let allAwaitingStepsId = [];
+
+  let objInstanceFull = {
+    identifiers: {},
+    fields: {}
+  }
+
+  for (let fieldName of Object.keys(requestParams.fieldNames)) {
+    if (objectSchemas.identifierFieldNames.includes(fieldName)) {
+      _izContext.logger.debug("identifiers is", fieldName);
+      Object.assign(objInstanceFull.identifiers, {
+        [fieldName]: requestParams.fieldNames[fieldName]
+      });
+    };
+  };
+
+  let objInstanceFullForDynamoDb = lodash.cloneDeep(objInstanceFull);
+  let objInstanceFullForGraph = lodash.cloneDeep(objInstanceFull);
+  let objInstanceFullForExternalTopic = lodash.cloneDeep(objInstanceFull);
+
+  for (const [storageTag, createDataDetail] of Object.entries(createDataDetails)) {
+    if (createDataDetail.storageType == coreConsts.STORAGE_TYPES.dynamoDB) {
+      _izContext.logger.debug("::::::DynamoDB::::::", { storageTag, objInstanceFull });
+
+      if (settings.parentObject) {
+        if (createDataDetail.tableName.includes(firstLetterUpperCase(`${parentObject.objectType}Records`))) {
+          Object.assign(
+            objInstanceFullForDynamoDb.fields, {
+            [`${settings.parentObject.objectType}HandlerServiceTag`]: process.env.iz_serviceTag
+          })
+        }
+      }
+
+      Object.assign(objInstanceFullForDynamoDb.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
+      _izContext.logger.debug("objInstanceFull before create item in dynamoDB", objInstanceFullForDynamoDb)
+
+      let identifiersForCreateData = await dynamoDbIdentifiersByStorageResource(
+        _izContext,
+        objectSchemas,
+        createDataDetail,
+        objInstanceFullForDynamoDb.identifiers
+      )
+      _izContext.logger.debug("identifiersForCreateData", identifiersForCreateData);
+
+      await dynamodbSharedLib.putItem(
+        _izContext,
+        await dynamodbSharedLib.tableName(
+          _izContext,
+          createDataDetail.tableName,
+          createDataDetail.serviceTag
+        ),
+        {
+          ...identifiersForCreateData,
+          ...objInstanceFullForDynamoDb.fields
+        }
+      );
+
+      objInstanceFullForDynamoDb.fields = {} // prevent using fieldNames from other tableName
+      if (allAwaitingStepsId.length == 0) {
+        let messageObject = {
+          objType: objType,
+          objInstanceFull: {
+            identifiers: objInstanceFullForDynamoDb.identifiers,
+            fields: objInstanceFullForDynamoDb.fields
+          }
+        }
+
+        if (callingFlowConfig[callingFlowSharedLib.coreConsts.CALLINGFLOW_PROPERTYNAME]) {
+          // send message to SNS OutCreateNodeComplete
+          _izContext.logger.debug("HAVE CallingFlow");
+          messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
+
+          let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+          let outCreateNodeCompleteTopic = await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
+          let messageParams = {
+            Message: JSON.stringify(messageObject),
+            MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+            TopicArn: outCreateNodeCompleteTopic,
+          };
+
+          _izContext.logger.debug("messageParams OutCreateNode ::::::: ", messageParams);
+          await sns.publishAsync(_izContext, messageParams);
+        }
+        return {
+          objType: objType,
+          objInstanceFull: objInstanceFullForDynamoDb,
+          relationships: requestParams.relationships || [],
+          status: "complete",
+          errorsFound: []
+        }
+      }
+
+    } else if (createDataDetail.storageType == coreConsts.STORAGE_TYPES.graph) {
+      _izContext.logger.debug("::::::Graph::::::", { storageTag, objInstanceFull });
+
+      Object.assign(objInstanceFullForGraph.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
+      _izContext.logger.debug("objInstanceFull before send to Graph", objInstanceFullForGraph)
+
+      // allStorageTagComplete = false;
+      allAwaitingStepsId.push(await asyncFlowSharedLib.createAwaitingStepId(
+        (hash({
+          objType: objType,
+          graphServerTag: storageTag,
+          identifiers: objInstanceFullForGraph.identifiers,
+          callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
+        })),
+        PREFIX.CREATE_OBJECT_ASYNC
+      ));
+      listOfObjectForCreates.push({
+        [storageTag]: {
+          objInstanceFull: {
+            identifiers: objInstanceFullForGraph.identifiers,
+            fields: objInstanceFullForGraph.fields
+          },
+          allStorageTagComplete: false
+        }
+      });
+
+      _izContext.logger.debug("FIRST", listOfObjectForCreates)
+
+    } else if (createDataDetail.storageType === coreConsts.STORAGE_TYPES.externalTopic) {
+      _izContext.logger.debug("::::::externalTopic::::::", { storageTag, createDataDetail });
+      Object.assign(objInstanceFullForExternalTopic.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
+      _izContext.logger.debug("objInstanceFull before send to external topic", objInstanceFullForExternalTopic)
+
+      allAwaitingStepsId.push(await asyncFlowSharedLib.createAwaitingStepId(
+        (hash({
+          objType: objType,
+          graphServerTag: storageTag,
+          identifiers: objInstanceFullForGraph.identifiers,
+          callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
+        })),
+        PREFIX.CREATE_OBJECT_EXTERNAL_TOPIC
+      ));
+
+      let sendToCreateExternalTopic = {
+        Message: JSON.stringify({ objType, objInstanceFull: objInstanceFullForExternalTopic, relationships: requestParams.relationships }),
+        TopicArn: `arn:aws:sns:${createDataDetail.region}:${createDataDetail.accountId}:${createDataDetail.serviceTag}_${createDataDetail.stage}_Create_In`
+      };
+      _izContext.logger.debug("Request params before send to create endpoint:", sendToCreateExternalTopic);
+
+      await sns.publishAsync(_izContext, sendToCreateExternalTopic)
+      return sendToCreateExternalTopic
+    }
+  };
+  _izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
+
+  /// step save awaitingMultipleStep of storageType graph ...........................................................
+  if (!settings.userAgent) {
+    _izContext.logger.debug("not api will create awaitingStep")
+    await asyncFlowSharedLib.createAwaitingMultipleSteps(
+      _izContext,
+      allAwaitingStepsId,
+      asyncFlowSharedLib.createPendingStepId((hash({ objType: objType, identifiers: objInstanceFull.identifiers })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)
+    );
+  }
+  //............................................................................................................
+
+  // process storageType : graph
+  let messageObject = {};
+  for (let objectCreate of listOfObjectForCreates) {
+
+    for (let [graphServiceName, objectForCreate] of Object.entries(objectCreate)) {
+      _izContext.logger.debug("Loop each graph:", {
+        [graphServiceName]: objectForCreate
+      });
+
+      if (objectForCreate.allStorageTagComplete == false) { // needless check because in listOfObjectForCreates push case graph  only!
+        messageObject = {
+          objType: objType,
+          objInstanceFull: objectForCreate.objInstanceFull,
+          relationships: requestParams.relationships || []
+        };
+      };
+
+      _izContext.logger.debug("SENT MESSAGE EACH GRAPH::::", { graphServiceName, messageObject, callingFlowConfig })
+
+      Object.assign(messageObject, {
+        settings: { updatePropertiesOnMatch: false },
+        originTimestamp: Date.now(),
+      });
+      if (settings.userAgent) {
+        _izContext.logger.debug("have userAgent will invoke GraphHandler")
+        let createNodeResult = await graphSharedLibs.createNodeV2(
+          _izContext,
+          graphServiceName,
+          objType,
+          objInstanceFullForGraph,
+          requestParams.relationships || [],
+          Date.now(),
+          {
+            updatePropertiesOnMatch: false
+          }
+        )
+        return createNodeResult
+
+      } else if (settings.directInvoke) {
+        _izContext.logger.debug("Direction Invoke case will invoke GraphHandlerInv")
+        let createNodeResult = await graphSharedLibs.createNodeV2(
+          _izContext,
+          graphServiceName,
+          objType,
+          objInstanceFullForGraph,
+          requestParams.relationships,
+          Date.now(),
+          {
+            updatePropertiesOnMatch: false
+          }
+        );
+
+        return createNodeResult;
+      } else {
+        _izContext.logger.debug("not have userAgent will send Message to GraphHandler")
+        messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+          messageObject,
+          callingFlowSharedLib.addParentCallingFlowConfig(
+            callingFlowConfig, // receive parent callingFlowConfig.
+            callingFlowSharedLib.createCallingFlowConfig( // calling flow own service
+              await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.createNodeComplete), {}
+            )
+          )
+        );
+
+        let messageToCreateObject = {
+          Message: JSON.stringify(messageObject),
+          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GRAPH_HANDLER.inCreateNode, graphServiceName)
+        };
+        _izContext.logger.debug("RequestParams before send to sqs messageToCreateObject ::::::: ", messageToCreateObject);
+        await sns.publishAsync(_izContext, messageToCreateObject);
+
+        return messageObject
+      }
+    };
+  };
+
+  function createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail) {
+    let fields = {};
+    for (let fieldName of Object.keys(requestParams.fieldNames)) {
+      if ((createDataDetails[storageTag].fieldNames.includes(fieldName)) &&
+        (createDataDetail.fieldNames.includes(fieldName))) {
+        if (!objInstanceFull.identifiers.hasOwnProperty(fieldName)) {
+          if (!fields.hasOwnProperty(fieldName)) {
+            Object.assign(fields, {
+              [fieldName]: requestParams.fieldNames[fieldName]
+            })
+          }
+        }
+      }
+    }
+    return fields
+  }
+}
+
+async function sharedCreateCompleteEndpoint(_izContext, returnValue, status, errorsFound, graphServiceTag, passBackProperties) {
+  let existsNode = null;
+  let createNodeFinished = false;
+  if (Object.keys(returnValue.queryResult.returnCreateNode.existsNode).length) {
+    existsNode = {
+      objType: {
+        objectType: returnValue.requestParams.objType.objectType,
+        serviceTag: returnValue.requestParams.objType.serviceTag
+      },
+      objInstanceFull: returnValue.queryResult.returnCreateNode.existsNode.objInstanceFull
+    }
+  }
+
+  let awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
+    (hash({
+      objType: returnValue.requestParams.objType,
+      graphServerTag: graphServiceTag,
+      identifiers: returnValue.requestParams.objInstanceFull.identifiers,
+      callingFlowProperties: passBackProperties.passBackProperties.parentPassBackProperties.callingFlowProperties || {}
+    })),
+    PREFIX.CREATE_OBJECT_ASYNC
+  )
+  _izContext.logger.debug("awaitingStepId:", awaitingStepId);
+
+  let recordAwaitingSteps = await dynamodbSharedLib.query(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, "AwaitingMultipleSteps"),
+    {
+      awaitingStepId: awaitingStepId
+    }
+  );
+  _izContext.logger.debug("record awaitingSteps::", recordAwaitingSteps);
+
+  await Promise.all(
+    recordAwaitingSteps.Items.map(async ({ pendingStepId }) => {
+      if (await asyncFlowSharedLib.checkAllAwaitingStepsFinished(
+        _izContext,
+        pendingStepId,
+        awaitingStepId,
+        errorsFound
+      )) {
+        _izContext.logger.debug("finish all awaitingStep");
+
+        let messageObject = {
+          objType: {
+            objectType: returnValue.requestParams.objType.objectType,
+            serviceTag: returnValue.requestParams.objType.serviceTag
+          },
+          objInstanceFull: returnValue.queryResult.returnCreateNode.objInstanceFull,
+          relationships: returnValue.queryResult.returnCreateNode.relationships,
+          existsNode: existsNode,
+          status: status,
+          errorsFound: errorsFound
+        }
+
+        messageObject = callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(passBackProperties, messageObject)
+        let messageAttributes = callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(passBackProperties, {})
+
+        let sendMessageOutCreateObjectComplete = {
+          Message: JSON.stringify(messageObject),
+          MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
+        };
+        _izContext.logger.debug("Send message to OutCreateObjectComplete :::>", sendMessageOutCreateObjectComplete)
+        await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
+        createNodeFinished = true
+      } else {
+        createNodeFinished = false
+      }
+
+      await asyncFlowSharedLib.removeAwaitingMultipleStep(
+        _izContext,
+        awaitingStepId,
+        pendingStepId,
+        errorsFound
+      );
+
+    })
+  )
+  return createNodeFinished
+}
+
+export default {
   sendMsgOutComplete,
   messageToDlq,
 
@@ -1110,7 +1446,9 @@ module.exports = {
 
   createFieldForUpdateDynamoDb,
   createBasicRelationshipsProperties,
-  createFieldNamesFromRequestParamsByObjectSchema
+  createFieldNamesFromRequestParamsByObjectSchema,
+  sharedCreateEndpoint,
+  sharedCreateCompleteEndpoint
 }
 
 
@@ -1188,7 +1526,7 @@ module.exports = {
 
 //   // reformat request depend on action
 //   switch (action) {
-//     case consts.ACTIONS.create:
+//     case coreConsts.ACTIONS.create:
 //       _izContext.logger.debug("reformatted case create");
 
 //       // initial format
@@ -1235,13 +1573,13 @@ module.exports = {
 //       }
 
 //       break;
-//     case consts.ACTIONS.update:
+//     case coreConsts.ACTIONS.update:
 //       // code block
 //       break;
-//     case consts.ACTIONS.get:
+//     case coreConsts.ACTIONS.get:
 //       // code block
 //       break;
-//     case consts.ACTIONS.delete:
+//     case coreConsts.ACTIONS.delete:
 //       // code block
 //       break;
 //     default:
@@ -1363,7 +1701,7 @@ module.exports = {
 
 //   let returnValue = {}
 
-//   for (let storageType of consts.STORAGE_TYPE_LIST) {
+//   for (let storageType of coreConsts.STORAGE_TYPE_LIST) {
 //     if (!returnValue.hasOwnProperty(storageType)) {
 //       returnValue[storageType] = {}
 //     }
@@ -1381,7 +1719,7 @@ module.exports = {
 //   // separate requestParams by storageType
 //   for (let [storageTag, storageData] of Object.entries(objectSchema.storageResources)) {
 
-//     if (storageData.storageType === consts.STORAGE_TYPES.dynamoDB) {
+//     if (storageData.storageType === coreConsts.STORAGE_TYPES.dynamoDB) {
 
 //       // separate by tableName
 //       let dynamoRequestParams = await separateRequestByDynamoDb(
@@ -1395,13 +1733,13 @@ module.exports = {
 //       _izContext.logger.debug("dynamoRequestParams: ", dynamoRequestParams);
 
 //       let tableName = storageData.tableName;
-//       if (returnValue[consts.STORAGE_TYPES.dynamoDB][tableName]) {
+//       if (returnValue[coreConsts.STORAGE_TYPES.dynamoDB][tableName]) {
 //         throw new NoRetryError(`Have duplicate tableName in storageTag:${storageTag}`);
 //       }
 
-//       Object.assign(returnValue[consts.STORAGE_TYPES.dynamoDB], { [tableName]: dynamoRequestParams });
+//       Object.assign(returnValue[coreConsts.STORAGE_TYPES.dynamoDB], { [tableName]: dynamoRequestParams });
 
-//     } else if (storageData.storageType === consts.STORAGE_TYPES.graph) {
+//     } else if (storageData.storageType === coreConsts.STORAGE_TYPES.graph) {
 
 //       // separate by GraphServiceName
 //       let graphRequestParams = await separateRequestByGraph(
@@ -1418,20 +1756,20 @@ module.exports = {
 //       let graphServiceName = await serviceConfig.getGraphServiceNameFromGraphServerTagWithCache(_izContext, storageData.graphServerTag);
 
 
-//       if (returnValue[consts.STORAGE_TYPES.graph][graphServiceName]) {
+//       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[consts.STORAGE_TYPES.graph][graphServiceName]: ',
-//           returnValue[consts.STORAGE_TYPES.graph][graphServiceName]
+//         _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[consts.STORAGE_TYPES.graph][graphServiceName].properties.hasOwnProperty(graphProperty)) {
+//           if (!returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName].properties.hasOwnProperty(graphProperty)) {
 //             Object.assign(
-//               returnValue[consts.STORAGE_TYPES.graph][graphServiceName].properties,
+//               returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName].properties,
 //               { [graphProperty]: graphRequestParams.properties[graphProperty] }
 //             );
 //           }
@@ -1440,25 +1778,25 @@ module.exports = {
 
 //         /*
 //           if versionedDatas exists in graphRequestParams
-//             - check versionedDatas exists in  returnValue[consts.STORAGE_TYPES.graph][graphServiceName]
+//             - 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[consts.STORAGE_TYPES.graph][graphServiceName].versionedDatas)) {
-//             returnValue[consts.STORAGE_TYPES.graph][graphServiceName].versionedDatas =
-//               returnValue[consts.STORAGE_TYPES.graph][graphServiceName].versionedDatas.concat(graphRequestParams.versionedDatas)
+//           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[consts.STORAGE_TYPES.graph][graphServiceName].versionedDatas = graphRequestParams.versionedDatas
+//             returnValue[coreConsts.STORAGE_TYPES.graph][graphServiceName].versionedDatas = graphRequestParams.versionedDatas
 //           }
 //         }
 
 
 //       } else {
 //         // not exists graphServiceName
-//         Object.assign(returnValue[consts.STORAGE_TYPES.graph], { [graphServiceName]: graphRequestParams });
+//         Object.assign(returnValue[coreConsts.STORAGE_TYPES.graph], { [graphServiceName]: graphRequestParams });
 //       }
 
 //     } else {
@@ -1655,7 +1993,7 @@ module.exports = {
 
 //   //----------------------- prepare additional return data per action   ------------------------
 
-//   if (action === consts.ACTIONS.get) {
+//   if (action === coreConsts.ACTIONS.get) {
 
 //     if (
 //       requestParams?.additionalRequest?.versionedDataLabel
@@ -1684,10 +2022,10 @@ module.exports = {
 //       }
 //     }
 
-//   } else if (action === consts.ACTIONS.create) {
+//   } else if (action === coreConsts.ACTIONS.create) {
 
 
-//   } else if (action === consts.ACTIONS.update) {
+//   } 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)
@@ -1774,7 +2112,7 @@ module.exports = {
 //     }
 
 
-//   } else if (action === consts.ACTIONS.delete) {
+//   } else if (action === coreConsts.ACTIONS.delete) {
 
 //   } else {
 //     throw new NoRetryError("Function:separateRequestByGraph: invalid action")
@@ -1858,7 +2196,7 @@ module.exports = {
 //   }
 
 //   // maybe not need to validate action get and delete because
-//   if (action === consts.ACTIONS.create) {
+//   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
@@ -1877,7 +2215,7 @@ module.exports = {
 
 //       }
 //     }
-//   } else if (action === consts.ACTIONS.update) {
+//   } else if (action === coreConsts.ACTIONS.update) {
 //     for (let versionedFieldName of versionedObjDataSchema.fieldNames) {
 //       if (versionedFieldName.canUpdate === true || versionedFieldName.canUpdate === undefined) {