@izara_project/izara-market-library-service-schemas 1.0.4 → 1.0.6

package/src/TemplateManager/src/PerActionEndpoint/MainFunction/Create/CreateObject_main.js

@@ -0,0 +1,760 @@
+/*
+Copyright (C) 2021 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+'use strict';
+const asyncFlowSharedLib = require('@izara_project/izara-shared/src/AsyncFlowSharedLib');
+const dynamodbSharedLib = require('@izara_project/izara-shared/src/DynamodbSharedLib');
+const lambdaSharedLib = require('@izara_project/izara-shared/src/LambdaSharedLib')
+const callingFlowSharedLib = require('@izara_project/izara-shared/src/CallingFlowSharedLib');
+
+const sns = require('@izara_project/izara-core-library-external-request/src/resources/Sns');
+const snsSharedLib = require('@izara_project/izara-shared/src/SnsSharedLib');
+const getObjectSchema = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
+const serviceConfigLib = require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig')
+
+const uploadUseCase = require('@izara_project/izara-core-library-service-schemas/src/libs/UploadUseCase')
+
+
+const hash = require("object-hash")
+const NoRetryError = require('@izara_project/izara-core-library-core/src/NoRetryError');
+const path = require('path')
+const schemasPath = path.join(__dirname, '../schemas');
+const consts = require('@izara_project/izara-core-library-service-schemas/src/Consts');
+const coreConsts = require("@izara_project/izara-core-library-core/src/Consts");
+
+const {
+  generateDynamoDbIdentifiers,
+  dynamoDbIdentifiersByStorageResource,
+  collectGetData
+} = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs');
+
+const {
+  getGraphServiceTagWithCache,
+  getServiceNameWithCache
+} = require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig');
+
+//-----------------------------------------------------------------------------------------------------------
+const PREFIX = {
+  ONE: "one",
+  MANY: "many",
+  CREATE_OBJECT_ASYNC: "createObjectAsync",
+  CREATE_OBJECT_ASYNC_COMPLETE: "createObjectAsyncComplete"
+}
+//-----------------------------------------------------------------------------------------------------------
+
+/**
+  - all storageType( DB and Graph) use objInstance({identifiers,fields})
+  - storageType[DB] async
+  - storageType[Graph] sync (should be have lambda complete)
+  -- before DB and Graph have boolend check (allStorageTagComplete = true) if storageType == graph set allStorageTagComplete = false,
+      and save awaitingMultiplastep prefix(serviceTag_CreateObject{identifierId})
+
+  >>> in lambdaComplete resive message from GrapHandler
+  1.1 check have returnValue.errorsFould.length > 0
+  -- Delete all awitingMultiplestep and senf message to callingFlow have errorFound.
+  1.2 check awaitingmultipleStepall finish
+  -- Delete awaitingStep in come if have other multiplestep(not finish)== not send message.
+  --- if check awaitingmultipleStepall finish not have record  ===> sendmessage to callingFlow.
+ */
+//=========================================================================================
+/**
+ *
+ * @param {*} _izContext
+ * @param {Object} requestParams = {fieldNames,relationships = []}
+ * @param {*} callingFlowConfig
+ */
+
+module.exports.createObject = async (
+  _izContext,
+  requestParams,
+  callingFlowConfig
+) => {
+  try {
+    _izContext.logger.debug("function createObject:", {
+      requestParams,
+      callingFlowConfig
+    });
+
+    _izContext.correlationIds.set(coreConsts.BASE_USER_ID, "BasDev");
+
+    const OBJECT_TYPE = "<%- objectType %>";
+    const SERVICE_TAG = process.env.iz_serviceTag
+
+    const MAIN_OBJTYPE = {
+      objectType: OBJECT_TYPE,
+      serviceTag: SERVICE_TAG
+    }
+
+    let getLocalObjectSchemas = await getObjectSchema.getLocalObjectSchemasWithHierarchy(
+      _izContext,
+      OBJECT_TYPE,
+
+    )
+
+
+    _izContext.logger.debug("getLocalObjectSchemas:", getLocalObjectSchemas)
+    let objectSchemas = uploadUseCase.generateObjectSchemaForGraphHandler(
+      _izContext,
+      getLocalObjectSchemas
+    );
+
+    let createDataDetails = await createDataDetailsLib(_izContext, objectSchemas);
+    _izContext.logger.debug("createDataDetails is =", createDataDetails);
+
+    //...............................................
+    let objInstance = {};
+    /* // seagame: can initial identifiers and fields properties inside objInstance
+    let objInstance = {
+      identifiers:{},
+      fields:{}
+    };
+    */
+
+    let listOfRequriedOnCreate = [];
+    let listOfOptionalOnCreate = [];
+
+    let allAwaitingStepsId = [];
+    let errorsFound = [];
+
+    //................................................
+
+    // // // validate for create identifer.
+    // for (let identifier of objectSchemas.identifiers) {
+    //   // check  single and cancat identifier in objectType
+    //   // can use all dynamodb and graph.
+
+    //   if (objectSchemas.identifiers.length === 1 && !identifier.hasOwnProperty("fieldNames")) {
+    //     _izContext.logger.debug(":::::case single identifer:::::", identifier);
+
+    //     if (objectSchemas.fieldNames[identifier.fieldName].hasOwnProperty("randomOnCreate")) {
+
+    //       if ((objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == true)) {
+    //         if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate == false)
+    //           && (objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == false)
+    //           && (objectSchemas.fieldNames[identifier.fieldName].canUpdate == false)
+    //         ) {
+
+    //           Object.assign(requestParams.fieldNames, {
+    //             [identifier.fieldName]: hash({
+    //               fieldNames: identifier, //
+    //               uniqueRequestId: _izContext.uniqueRequestId,
+    //               callingFlowConfig: callingFlowConfig
+    //             })
+    //           })
+    //         }
+    //       } else if ((objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == false)) {
+
+    //         if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate == true)
+    //           && ((objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == false) || objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == true)
+    //           && (objectSchemas.fieldNames[identifier.fieldName].canUpdate == false)) {
+    //           // check Fns have resive
+
+    //           if (requestParams.fieldNames.hasOwnProperty([identifier.fieldName])) {
+    //             _izContext.logger.debug("identifier is exist:", {
+    //               [identifier.fieldName]: requestParams.fieldNames[identifier.fieldName]
+    //             });
+
+    //           } else {
+    //             errorsFound.push("[invalid]requestParams not have data fieldNames of requriedOnCreate");
+    //           }
+    //         }
+    //       };
+    //     } else {
+    //       if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate == false)
+    //         && (objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == false)
+    //         && (objectSchemas.fieldNames[identifier.fieldName].canUpdate == false)) {
+    //         errorsFound.push("[invalid]case single identifier invalid objectSchemass");
+    //       };
+    //     };
+    //   }
+
+    //   if (errorsFound.length > 0) {
+    //     _izContext.logger.debug("HaveError::", errorsFound);
+    //     break
+    //   };
+    // };
+
+
+
+    if (objectSchemas.identifiers.length === 1 && !identifier.hasOwnProperty("fieldNames")) {
+
+      const identifier = objectSchemas.identifiers[0];
+      _izContext.logger.debug(":::::case single identifer:::::", identifier);
+
+      if (objectSchemas.fieldNames[identifier.fieldName].hasOwnProperty("randomOnCreate")) {
+
+        if ((objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == true)) {
+          if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate == false)
+            && (objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == false)
+            && (objectSchemas.fieldNames[identifier.fieldName].canUpdate == false)
+          ) {
+
+            Object.assign(requestParams.fieldNames, {
+              [identifier.fieldName]: hash({
+                fieldNames: identifier, //
+                uniqueRequestId: _izContext.uniqueRequestId,
+                callingFlowConfig: callingFlowConfig
+              })
+            });
+
+          }
+
+        } else if ((objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == false)) {
+
+          if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate == true)
+            && ((objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == false) || objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == true)
+            && (objectSchemas.fieldNames[identifier.fieldName].canUpdate == false)) {
+            // check Fns have resive
+
+            if (requestParams.fieldNames.hasOwnProperty([identifier.fieldName])) {
+              _izContext.logger.debug("identifier is exist:", {
+                [identifier.fieldName]: requestParams.fieldNames[identifier.fieldName]
+              });
+
+            } else {
+              errorsFound.push("[invalid]requestParams not have data fieldNames of requriedOnCreate");
+            }
+          }
+        };
+      } else {
+        if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate == false)
+          && (objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == false)
+          && (objectSchemas.fieldNames[identifier.fieldName].canUpdate == false)) {
+          errorsFound.push("[invalid]case single identifier invalid objectSchemass");
+        };
+      };
+    }
+
+
+    _izContext.logger.debug("requestParams is:", requestParams);
+
+
+
+    // check settingObjSchemas
+    for (let [keyFieldNames, valueFieldNames] of Object.entries(objectSchemas.fieldNames)) {
+
+      if (valueFieldNames.hasOwnProperty("randomOnCreate") && valueFieldNames.randomOnCreate === true) {
+        listOfRequriedOnCreate.push(keyFieldNames)
+      };
+
+      if (valueFieldNames.hasOwnProperty("requiredOnCreate") && valueFieldNames.requiredOnCreate === true) {
+        listOfRequriedOnCreate.push(keyFieldNames)
+      };
+
+      if (valueFieldNames.hasOwnProperty("optionalOnCreate") && valueFieldNames.optionalOnCreate === true) {
+        if ((valueFieldNames.requiredOnCreate === false) && valueFieldNames.optionalOnCreate === true) {
+          listOfOptionalOnCreate.push(keyFieldNames)
+        };
+      };
+
+    };// end iteration of fieldNames
+
+    for (let fieldName of Object.keys(requestParams.fieldNames)) {
+
+      if (!listOfRequriedOnCreate.includes(fieldName)) {
+        if (!listOfOptionalOnCreate.includes(fieldName)) {
+          errorsFound.push("[invalid] over fieldNames create object");
+        }
+      };
+
+      if (listOfOptionalOnCreate.length > 0 && listOfRequriedOnCreate.includes(fieldName)) {
+        // HookCode
+        // HookCode
+      };
+
+      if (listOfRequriedOnCreate.includes(fieldName)) { // seagame: can delete this condition or move to else condition of !listOfRequiredOnCreate.includes(fieldName)
+        //check idnetifier
+        _izContext.logger.debug("check",
+          objectSchemas.identifierFieldNames,
+          { listOfRequriedOnCreate, fieldNames: fieldName });
+
+        if (objectSchemas.identifierFieldNames.includes(fieldName)) {
+          _izContext.logger.debug("identifiers is", fieldName);
+
+          if (objInstance.hasOwnProperty("identifiers")) {
+            Object.assign(objInstance.identifiers, {
+              [fieldName]: requestParams.fieldNames[fieldName]
+            })
+          } else {
+            Object.assign(objInstance, {
+              identifiers: {
+                [fieldName]: requestParams.fieldNames[fieldName]
+              }
+            });
+          };
+        };
+
+      };
+
+
+      /*
+        fix version if change objInstance initial
+        can delete condition if (listOfRequriedOnCreate.includes(fieldName))
+      */
+
+      // if (objectSchemas.identifierFieldNames.includes(fieldName)) {
+      //   _izContext.logger.debug("identifiers is", fieldName);
+      //   Object.assign(objInstance.identifiers, {
+      //     [fieldName]: requestParams.fieldNames[fieldName]
+      //   });
+      // };
+
+      if (errorsFound.length > 0) {
+        _izContext.logger.debug("HaveError::", errorsFound);
+        break
+      };
+
+    };// end loop
+
+    let listOfObjectForCreates = [];
+    let serviceName;
+    let createDataDetail;
+    if (errorsFound.length == 0) {
+
+      for ([serviceName, createDataDetail] of Object.entries(createDataDetails)) {
+
+        for (let fieldNames of Object.keys(requestParams.fieldNames)) {
+
+          if (createDataDetail.fieldNames.includes(fieldNames) && listOfRequriedOnCreate.includes(fieldNames)
+          ) {
+            _izContext.logger.debug("fieldNames match in detail is:", fieldNames);
+
+            if (objInstance.hasOwnProperty("fields")) {
+              Object.assign(objInstance.fields, {
+                [fieldNames]: requestParams.fieldNames[fieldNames]
+              })
+            } else {
+              Object.assign(objInstance, {
+                fields: {
+                  [fieldNames]: requestParams.fieldNames[fieldNames]
+                }
+              })
+            };
+          };
+        };
+
+        if (createDataDetail.storageType == consts.STORAGE_TYPES.dynamoDB) {
+          _izContext.logger.debug("::::::DynamoDB::::::", { serviceName, objInstance });
+
+          await dynamodbSharedLib.putItem(
+            _izContext,
+            await dynamodbSharedLib.tableName(
+              _izContext,
+              createDataDetail.tableName
+            ),
+            objInstance
+          );
+
+
+        } else if (createDataDetail.storageType == consts.STORAGE_TYPES.graph) {
+          _izContext.logger.debug("::::::Graphanler::::::", { serviceName, objInstance });
+
+          // allStorageTagComplete = false;
+          allAwaitingStepsId.push(asyncFlowSharedLib.createAwaitingStepId(
+            (hash({
+              objType: MAIN_OBJTYPE,
+              graphServerTag: serviceName,
+              identifiers: objInstance.identifiers
+            })),
+            PREFIX.CREATE_OBJECT_ASYNC
+          ));
+          listOfObjectForCreates.push({
+            [serviceName]: {
+              objInstance: {
+                identifiers: objInstance.identifiers,
+                fields: objInstance.fields
+              },
+              allStorageTagComplete: false
+            }
+          });
+
+          _izContext.logger.debug("FIRST", listOfObjectForCreates)
+
+        };
+        _izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
+
+        delete objInstance.fields
+      };
+    };
+
+    /// step save awiatingMultipleStep of storageType graph ...........................................................
+
+    await asyncFlowSharedLib.createAwaitingMultipleSteps(
+      _izContext,
+      allAwaitingStepsId,
+      asyncFlowSharedLib.createPendingStepId((hash({ objType: MAIN_OBJTYPE, identifiers: objInstance.identifiers })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)
+    );
+    //............................................................................................................
+
+    // process storageType : graph
+    let messageObject = {};
+    for (let objectCreate of listOfObjectForCreates) {
+
+      for (let [graphServiceName, objecForCreate] of Object.entries(objectCreate)) {
+        _izContext.logger.debug("Loop each graph:", { [graphServiceName]: objecForCreate });
+
+        if (objecForCreate.allStorageTagComplete == false) { // needless check because in listOfObjectForCreates push case graph  only!
+
+          messageObject = {
+            objType: MAIN_OBJTYPE,
+            objInstance: objecForCreate.objInstance,
+          };
+
+          /*
+            seagame: should getRequiredOnCreateLinksGraphHandler before match with requestParams.relationships
+            this condition will miss validation when objType have requiredOnCreateLink but not send relationships from requestParams
+          */
+
+          if (requestParams.hasOwnProperty("relationships") && requestParams.relationships.length > 0) {
+            _izContext.logger.debug("SHOW RELATIONSHIP:", requestParams.relationships);
+
+            // validate relationship only.
+            let getRelationhsipSchemas = await getObjectSchema.getRequiredOnCreateLinksGraphHandler(
+              _izContext,
+              {
+                objectType: OBJECT_TYPE,
+                serviceTag: SERVICE_TAG
+              }
+            );
+
+            _izContext.logger.debug("getRelationhsipSchemas is:::", getRelationhsipSchemas);
+
+            if (Object.keys(getRelationhsipSchemas).length !== requestParams.relationships.length) {
+              errorsFound.push("[invalid]relationships missmatch requiredOnCreateLink form relationshipschemas");
+            } else {
+
+              for (let eachRelationships of requestParams.relationships) {
+                _izContext.logger.debug("eachRelationships is:", eachRelationships);
+
+                // validate porperty in relatoinships.
+                if (!eachRelationships.hasOwnProperty("relType") || Object.keys(eachRelationships.relType).length == 0) {
+                  errorsFound.push("[invalid relationsips] property relType in relationsips");
+                };
+                if (!eachRelationships.hasOwnProperty("targetObjType") || Object.keys(eachRelationships.targetObjType).length == 0) {
+                  errorsFound.push("[invalid relationsips] property targetObjType in relationsips");
+                };
+                if (!eachRelationships.hasOwnProperty("targetIdentifiers") || Object.keys(eachRelationships.targetIdentifiers).length == 0) {
+                  errorsFound.push("[invalid relationsips] property targetIdentifiers in relationsips");
+                };
+
+                let relationshipTag = eachRelationships.relType.relationshipTag
+                let eachRelationhsipSchemas = getRelationhsipSchemas[eachRelationships.relType.relationshipTag]
+                let targetObjType = eachRelationships.targetObjType
+
+                _izContext.logger.debug("each Relationhsip is:::::", {
+                  relationshipTag,
+                  eachRelationhsipSchemas: eachRelationhsipSchemas,
+                  targetObjType
+                });
+
+                if (!eachRelationhsipSchemas) {
+                  errorsFound.push("misMatch relationhsipSchemas requriOnCreate");
+                };
+
+                if (errorsFound.length > 0) {
+                  break
+                };
+
+                let objTypeRequiredOnCreate = null;
+                for (let link of eachRelationhsipSchemas.links) {
+                  /*
+                    seagame: one relationshipSchema probably have 2 or more links that contain mainObjType but have difference targetObjType
+                  */
+
+                  let objectSides = {
+                    from: MAIN_OBJTYPE,
+                    to: targetObjType
+                  };
+
+                  if (link.from.objType.serviceTag == targetObjType.serviceTag
+                    && link.from.objType.objectType == targetObjType.objectType) {
+                    objectSides = {
+                      from: targetObjType,
+                      to: MAIN_OBJTYPE
+                    };
+                  };
+                  _izContext.logger.debug("check side:", objectSides);
+
+                  // test both sides of link
+                  // let otherLinkConfigKey = "from";
+                  for (let linkKey of Object.keys(link)) {
+                    // _izContext.logger.debug("linkKey is:", linkKey);
+                    if (linkKey == "to" || linkKey == "from") {
+                      // set other side key
+                      let otherLinkConfigKey = "from";
+                      if (linkKey == "from") {
+                        otherLinkConfigKey = "to";
+                      }
+
+                      // case ONE-to-ONE
+                      if (link[linkKey].linkType == "one"
+                        && link[otherLinkConfigKey].linkType == "one") {
+                        _izContext.logger.debug("case ONE-to-ONE");
+                        if (link[linkKey].requiredOnCreate == true) {
+
+                          objTypeRequiredOnCreate = objectSides[linkKey];
+                        };
+                      };
+
+                      // case ONE-to-MANY
+                      if (link[linkKey].linkType == "many"
+                        && link[otherLinkConfigKey].linkType == "one") {
+                        _izContext.logger.debug("case ONE-to-MANY");
+
+                        if (link[linkKey].requiredOnCreate == true) {
+
+                          objTypeRequiredOnCreate = objectSides[linkKey];
+                        };
+                      };
+
+                      if ((objTypeRequiredOnCreate !== null && link[otherLinkConfigKey].objType !== null)) {
+                        /*
+                          seagame: one relationshipSchema probably have 2 or more links that contain mainObjType but have difference targetObjType
+                          if check other side with targetObjType will cause errors
+                        */
+                        if (
+                          ((objTypeRequiredOnCreate.objectType == MAIN_OBJTYPE.objectType) && (objTypeRequiredOnCreate.serviceTag == MAIN_OBJTYPE.serviceTag))
+                          && ((link[otherLinkConfigKey].objType.objectType == targetObjType.objectType) && (link[otherLinkConfigKey].objType.serviceTag == targetObjType.serviceTag))) {
+
+                          // seagame:
+                          // this line will re assign every time when validate requestParams.relationships
+                          // should finished validate all requestParams.relationships before assign to messageObject
+                          Object.assign(messageObject, { relationships: requestParams.relationships });
+                          _izContext.logger.debug("messageObject case relationships", messageObject)
+
+                        } else {
+                          errorsFound.push("[Invalid]main objType is not requriOnCreate")
+                        };
+
+                      }
+
+                      if (errorsFound.length > 0) {
+                        break
+                      };
+                    };
+
+
+                  }; // end check linkKey.
+                }; // end links
+              }; // end loop requestParams.relationships
+            };//  end  eachRelationships
+
+            if (errorsFound.length > 0) {
+              break
+            };
+          }; // case relationships
+        };
+
+        if (errorsFound.length > 0) {
+          break;
+        } else {
+          _izContext.logger.debug("SENT MESSAGE EACH GRAPH::::", { graphServiceName, messageObject, callingFlowConfig })
+
+          Object.assign(messageObject, {
+            settings: { updatePropertiesOnMatch: false },
+            originTimestamp: Date.now()
+          });
+
+          // seagame: not need to check callingFlow before send to graph, Just add callingFlow and parent callingFlow before send to graph
+          if (callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME]) {
+            _izContext.logger.debug("Have callingFlow", callingFlowConfig);
+            _izContext.logger.debug("callingFlowProperties", callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOWPROPERTIES_PROPERTYNAME])
+
+            messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+              messageObject,
+              callingFlowSharedLib.addParentCallingFlowConfig(
+                callingFlowConfig,                              // resive parent callingFlowConfig.
+                callingFlowSharedLib.createCallingFlowConfig(   // callinfflow own service
+                  await lambdaSharedLib.lambdaFunctionName(_izContext, "CreateObjectCompleteHdrSqs"),
+                )
+              )
+            );
+          };
+
+          let messageToCreateObject = {
+            Message: JSON.stringify(messageObject),
+            TopicArn: await snsSharedLib.snsTopicArn(_izContext, "InCreateNodeV2", graphServiceName)
+          };
+          _izContext.logger.debug("RequestParams before send to sqs messageToCreateObject ::::::: ", messageToCreateObject);
+          await sns.publishAsync(_izContext, messageToCreateObject);
+        };
+      };// end loop of objectCreate.
+      if (errorsFound.length > 0) {
+        break;
+      }
+    }; // end loop listOfObjectForCreates
+
+    if (errorsFound.length > 0) {
+      _izContext.logger.debug("Case have errorFound:::", errorsFound);
+
+      // remove awaitngMultiplestep. [[[[[[[open when not test lolcal.]]]]]]]
+      await asyncFlowSharedLib.clearAllAwaitingSteps(
+        _izContext,
+        asyncFlowSharedLib.createPendingStepId((hash({
+          objType: MAIN_OBJTYPE,
+          identifiers: objInstance.identifiers
+        })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)); // pendingStepId
+
+      // send message to OutCreateObjectComplete.
+      //..
+      messageObject = {
+        objType: MAIN_OBJTYPE,
+        identifiers: null, // or {}
+        errorsFound: errorsFound
+      };
+
+      //  pass back property.
+      messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
+      let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+
+      let sendMessageOutCreateObjectComplete = {
+        Message: JSON.stringify(messageObject),
+        MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+        TopicArn: await snsSharedLib.snsTopicArn(_izContext, "OutCreateObjectComplete")
+      };
+      _izContext.logger.debug("Send message to OutCreateObjectComplete :::>", sendMessageOutCreateObjectComplete)
+      await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
+
+      return { returnValue: "function DeliveryMetodStandate have errorFounds" }
+    }
+    _izContext.logger.debug("end errorsFound is:", errorsFound);
+
+  } catch (err) {
+    throw (err)
+  }
+
+}
+
+/*
+example return
+* identifierFieldNames will not includes inside fieldNames of createObjectDetails
+{
+  dynamoDBStorageTag:{
+    storageType:"dynamoDB",
+    tableName:"xxx",
+    fieldNames:[...fieldName]
+  },
+  GraphServiceTag:{
+    storageType: 'graph',
+    fieldNames: [ 'bookId2', 'bookName' ]
+  }
+}
+*/
+async function createDataDetailsLib(
+  _izContext,
+  objectSchemas
+) {
+  _izContext.logger.debug("Lib: createDataDetailsLib:", { objectSchemas: objectSchemas });
+
+  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 });
+
+    // check fiend is identifier
+    if (objectSchemas.identifierFieldNames.includes(keyFieldName)) {
+      continue
+    };
+    // validate storageResourceTags.
+    _izContext.logger.debug("storageResourceTags is", settingFieldName.storageResourceTags);
+
+    for (let eachStorageResourceTags of settingFieldName.storageResourceTags) {
+      _izContext.logger.debug("Loop eachStorageResourceTags", eachStorageResourceTags);
+
+      if (!storageResources.hasOwnProperty(eachStorageResourceTags)) {
+        throw new Error("storageResources is'n exist");// should be validata in step uplode in s3
+      } else {
+
+        if (storageResources[eachStorageResourceTags].storageType == consts.STORAGE_TYPES.dynamoDB) {
+          if (createDataDetails.hasOwnProperty(eachStorageResourceTags)) {
+            _izContext.logger.debug("SAME STG DB", eachStorageResourceTags);
+            createDataDetails[eachStorageResourceTags].fieldNames.push(keyFieldName);
+
+          } else {
+            _izContext.logger.debug("NEW STG DB", eachStorageResourceTags);
+            Object.assign(createDataDetails, {
+              [eachStorageResourceTags]: {
+                storageType: consts.STORAGE_TYPES.dynamoDB,
+                tableName: storageResources[eachStorageResourceTags].tableName,
+                fieldNames: [keyFieldName]
+              }
+            });
+
+            if (storageResources[eachStorageResourceTags].hasOwnProperty("groupByPartitionKeyField")) {
+              Object.assign(createDataDetails[eachStorageResourceTags], {
+                groupByPartitionKeyField: storageResources[eachStorageResourceTags].groupByPartitionKeyField
+              });
+            }
+          }
+
+        } else if (storageResources[eachStorageResourceTags].storageType == consts.STORAGE_TYPES.graph) {
+          let checkGraphServerTags = await serviceConfigLib.getGraphServiceTag(
+            _izContext,
+            storageResources[eachStorageResourceTags].graphServerTag
+          );
+          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: consts.STORAGE_TYPES.graph,
+                  fieldNames: [keyFieldName]
+                }
+              });
+            };
+          };
+        };
+      };
+    };// end loop storageResourceTags
+
+  };// end loop
+  _izContext.logger.debug("_______All createDataDetails_____", createDataDetails);
+  return createDataDetails;
+};
+
+(async () => {
+  const path = require("path")
+  const schemaPath = path.join(__dirname, '../schemas');
+
+  const _izContext = {
+    logger: require("@izara_project/izara-core-library-logger")
+  };
+
+
+  const objSchema = await getObjectSchema.getLocalObjectSchemasWithHierarchy(
+    _izContext,
+    "book",
+    schemasPath // for test own local (part local not same link in aws.)
+  ).then(data => data.records[0]);
+
+  _izContext.logger.debug("objSchema: ", objSchema);
+
+  const objSchemaGraph = uploadUseCase.generateObjectSchemaForGraphHandler(
+    _izContext,
+    objSchema
+  );
+
+  const createDataDetail = await createDataDetailsLib(_izContext, objSchemaGraph);
+  _izContext.logger.debug("createDataDetail: ", createDataDetail);
+})()