@izara_project/izara-market-library-service-schemas 1.0.23 → 1.0.24

package/src/reStructure/TemplateData/perActionEndpoint/mainFunction/create/template.ejs

@@ -0,0 +1,629 @@
+/*
+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 izaraShared = require('@izara_project/izara-shared');
+const asyncFlowSharedLib = izaraShared.asyncFlowSharedLib;
+const dynamodbSharedLib = izaraShared.dynamodbSharedLib;
+const lambdaSharedLib = izaraShared.lambdaSharedLib;
+const callingFlowSharedLib = izaraShared.callingFlowSharedLib;
+const snsSharedLib = require('@izara_project/izara-shared/src/SnsSharedLib');
+
+const externalRequest = require('@izara_project/izara-core-library-external-request');
+const sns = externalRequest.sns;
+const lambda = externalRequest.lambda
+
+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"
+}
+//-----------------------------------------------------------------------------------------------------------
+const { TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER, GRAPH_HANDLER_SERVICE_NAME } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/Consts')
+const { createDataDetailsLib } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs')
+const { createLinkTypeId } = require('@izara_project/izara-core-library-service-schemas/src/Utils');
+const { findLinksByObjTypes } = require("@izara_project/izara-core-library-service-schemas/src/libs/RelSchemaLib")
+const lodash = require("lodash")
+
+
+/**
+  - 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.<%- functionName %>Main = async (
+  _izContext,
+  requestParams,
+  callingFlowConfig
+) => {
+  try {
+    _izContext.logger.debug("function <%- functionName %>:", {
+      requestParams,
+      callingFlowConfig
+    });
+
+    let errorsFound = [];
+
+    const userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID);
+    const targetId = _izContext.correlationIds.get(coreConsts.TARGET_ID)
+    if (!userId) {
+      errorsFound.push("Not have userId")
+    }
+
+    const OBJECT_TYPE = "<%- objectType %>";
+    const SERVICE_TAG = process.env.iz_serviceTag;
+    //(<beforeQuery>)
+    //(</beforeQuery>)
+    const MAIN_OBJTYPE = {
+      objectType: OBJECT_TYPE,
+      serviceTag: SERVICE_TAG
+    }
+    let objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
+      _izContext,
+      MAIN_OBJTYPE
+    );
+    _izContext.logger.debug("objectSchema", objectSchema);
+
+    let objectSchemas = uploadUseCase.generateObjectSchemaForCombineFieldNames(
+      _izContext,
+      objectSchema
+    );
+    _izContext.logger.debug("objectSchemas", objectSchemas);
+
+    if (objectSchema.hasOwnProperty("belongTo") && !targetId) {
+      errorsFound.push('not have targetId')
+    }
+
+    let createDataDetails = await createDataDetailsLib(_izContext, objectSchemas);
+    _izContext.logger.debug("createDataDetails is =", createDataDetails);
+
+    let checkCorrectLinks = [];
+
+    //validate linkType
+    if ((requestParams.hasOwnProperty("relationships")) && (requestParams.relationships.length > 0)) {
+
+      for (let relationshipProperties of requestParams.relationships) {
+        _izContext.logger.debug("relationshipProperties", relationshipProperties);
+        _izContext.logger.debug("relType", relationshipProperties.relType);
+        let getObjectRelationship = await getObjectSchema.getRelationshipSchemaWithCache(
+          _izContext,
+          relationshipProperties.relType
+        )
+        _izContext.logger.debug("getObjectRelationship", getObjectRelationship)
+
+        for (const relationshipLink of Object.values(getObjectRelationship.links)) {
+          if (relationshipLink.from.linkType === "many" && relationshipLink.to.linkType === "many") {
+            if (relationshipLink.from.requiredOnCreate === true || relationshipLink.to.requiredOnCreate === true) {
+              errorsFound.push("error many to many linkType can't have requireOnCreate === true")
+            }
+          }
+        }
+        const links = await findLinksByObjTypes(_izContext, [MAIN_OBJTYPE, relationshipProperties.targetObjType], getObjectRelationship.links);
+        _izContext.logger.debug("links", links)
+
+        if (!links.length) {
+          errorsFound.push(`not found link between ${JSON.stringify({ mainObjType: MAIN_OBJTYPE })} and ${JSON.stringify({ toObjType: relationshipProperties.targetObjType })} `)
+        }
+
+        for (let link of links) {
+          const { serviceTag: fromServiceTag, objectType: fromObjectType } = MAIN_OBJTYPE;
+          const { serviceTag: toServiceTag, objectType: toObjectType } = relationshipProperties.targetObjType
+
+          const { serviceTag: firstServiceTag, objectType: firstObjectType } = link.from.objType;
+          const { serviceTag: secondServiceTag, objectType: secondObjectType } = link.to.objType
+
+          const matchesFromTo =
+            fromServiceTag === firstServiceTag && fromObjectType === firstObjectType &&
+            toServiceTag === secondServiceTag && toObjectType === secondObjectType;
+
+          const matchesToFrom =
+            fromServiceTag === secondServiceTag && fromObjectType === secondObjectType &&
+            toServiceTag === firstServiceTag && toObjectType === firstObjectType
+
+          if ((relationshipProperties.relationshipDirection === "from" && matchesFromTo) ||
+            (relationshipProperties.relationshipDirection === "to" && matchesToFrom)) {
+            checkCorrectLinks.push(true)
+          } else {
+            checkCorrectLinks.push(false)
+          }
+        }
+      }
+    }
+    for (const [index, checkCorrectLink] of checkCorrectLinks.entries()) {
+      if (checkCorrectLink === false) {
+        errorsFound.push(`relationship direction ${JSON.stringify(requestParams.relationships[index])} is invalid`)
+      }
+    }
+    _izContext.logger.debug("finish validate Relationships from RequestParams")
+    let requiredOnCreateLinks = {};
+    let createLinkTypeIds = [];
+    // validate relationships link
+    let objectRelationshipSchema = await getObjectSchema.getRequiredOnCreateLinksWithCache(_izContext, MAIN_OBJTYPE);
+    _izContext.logger.debug("objectRelationshipSchema", objectRelationshipSchema);
+
+    // validate requiredOnCreateLinks
+    let filteredRequiredOnCreatedLinks = [];
+
+    await Promise.all(
+      objectRelationshipSchema.map(async (requiredLink) => {
+        const serviceTag = await Promise.all(
+          requiredLink.storageResourceTags.map(async (storageTag) => {
+            let storageResource = requiredLink.storageResources[storageTag];
+            if (storageResource.storageType === consts.STORAGE_TYPES.graph) {
+              return await getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag);
+            }
+          })
+        );
+        if (serviceTag.includes(GRAPH_HANDLER_SERVICE_NAME.graphHandler)) {
+          filteredRequiredOnCreatedLinks.push(requiredLink);
+        }
+      })
+    )
+    _izContext.logger.debug("filteredRequiredOnCreatedLinks", filteredRequiredOnCreatedLinks);
+
+    if (filteredRequiredOnCreatedLinks.length) {
+      if (!requestParams.relationships || !requestParams.relationships.length) {
+        // in case not send relationship to create with
+        for (const requireLink of filteredRequiredOnCreatedLinks) {
+          errorsFound.push(`missing required relationship of relType ${JSON.stringify(requireLink.relType)} when create`)
+        }
+      }
+
+      for (const requireLink of filteredRequiredOnCreatedLinks) {
+        const requiredOnCreateLinkTypeId = createLinkTypeId(
+          _izContext,
+          MAIN_OBJTYPE,
+          requireLink.other.objType,
+          requireLink.relType,
+          requireLink.base.direction
+        );
+
+        Object.assign(requiredOnCreateLinks, {
+          [requiredOnCreateLinkTypeId]: requireLink
+        })
+      }
+
+      if (requestParams.hasOwnProperty("relationships") && requestParams.relationships.length) {
+        for (const createRelationship of requestParams.relationships) {
+          const onCreateLinkTypeId = createLinkTypeId(
+            _izContext,
+            MAIN_OBJTYPE,
+            createRelationship.targetObjType,
+            createRelationship.relType,
+            createRelationship.relationshipDirection
+          );
+
+          if (!requiredOnCreateLinks.hasOwnProperty(onCreateLinkTypeId)) {
+            errorsFound.push(`relType:${JSON.stringify(createRelationship.relType)} not allow to create when use create action`)
+            continue;
+          } else {
+            createLinkTypeIds.push(onCreateLinkTypeId);
+          }
+        }
+      }
+    }
+
+
+    // validate missing relType when create that should create
+    const remainRequiredOnCreateLinkTypeIds = Object.keys(requiredOnCreateLinks)
+      .filter(requiredInCreateLinkTypeId => !createLinkTypeIds.includes(requiredInCreateLinkTypeId))
+
+    if (remainRequiredOnCreateLinkTypeIds.length) {
+      for (const remainRequiredOnCreateLinkTypeId of remainRequiredOnCreateLinkTypeIds) {
+        const missingLink = {
+          relType: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].relType,
+          base: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].base.objType,
+          other: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].other.objType
+        };
+        errorsFound.push(`Missing Link:: ${JSON.stringify(missingLink)} when create`)
+      }
+    }
+    _izContext.logger.debug("createLinkTypeIds", createLinkTypeIds);
+    _izContext.logger.debug("requiredOnCreateLinks", requiredOnCreateLinks);
+    // end validate
+
+    let objInstanceFull = {
+      identifiers: {},
+      fields: {}
+    };
+
+    let listOfRequiredOnCreate = [];
+    let listOfOptionalOnCreate = [];
+
+    let allAwaitingStepsId = [];
+
+    // validate single identifiers
+    if (objectSchemas.identifiers.length === 1 && !objectSchemas.identifiers[0].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)) {
+          Object.assign(requestParams.fieldNames, {
+            [identifier.fieldName]: hash({
+              fieldNames: identifier, //
+              uniqueRequestId: _izContext.uniqueRequestId,
+              callingFlowConfig: callingFlowConfig
+            })
+          });
+          _izContext.logger.debug("Assign requestParams", requestParams)
+
+        } else if ((objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == false) ||
+          (objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == null)) {
+
+          if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate == 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].hasOwnProperty("hashOnCreate")) {
+        if (objectSchemas.fieldNames[identifier.fieldName].hashOnCreate.length &&
+          objectSchemas.fieldNames[identifier.fieldName].hashOnCreate.length > 0) {
+          for (const fieldName of objectSchemas.fieldNames[identifier.fieldName].hashOnCreate) {
+            Object.assign(
+              requestParams.fieldNames, {
+              [identifier.fieldName]: hash({
+                [fieldName]: requestParams.fieldNames[fieldName]
+              })
+            }
+            )
+          }
+        } else {
+          errorsFound.push("[invalid] no data to hash for create")
+        }
+      } else {
+        if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate === false) &&
+          (objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate === false) &&
+          (objectSchemas.fieldNames[identifier.fieldName].canUpdate === false) &&
+          objectSchemas.fieldNames[identifier.fieldName].hashOnCreate === 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) {
+        listOfRequiredOnCreate.push(keyFieldNames)
+      };
+
+      if (valueFieldNames.hasOwnProperty("requiredOnCreate") && valueFieldNames.requiredOnCreate === true) {
+        listOfRequiredOnCreate.push(keyFieldNames)
+      };
+
+      if (valueFieldNames.hasOwnProperty("hashOnCreate") && valueFieldNames.hashOnCreate.length) {
+        listOfRequiredOnCreate.push(keyFieldNames)
+      }
+      
+      if (valueFieldNames.hasOwnProperty("optionalOnCreate") && valueFieldNames.optionalOnCreate === true) {
+        if ((valueFieldNames.requiredOnCreate === false) && valueFieldNames.optionalOnCreate === true) {
+          listOfOptionalOnCreate.push(keyFieldNames)
+        };
+      };
+
+    }; // end iteration of fieldNames
+
+    _izContext.logger.debug("listOfRequriedOnCreate", listOfRequiredOnCreate);
+    _izContext.logger.debug("listOfOptionalOnCreate", listOfOptionalOnCreate);
+    for (let fieldName of Object.keys(requestParams.fieldNames)) {
+
+      if (!listOfRequiredOnCreate.includes(fieldName)) {
+        if (!listOfOptionalOnCreate.includes(fieldName)) {
+          errorsFound.push("[invalid] over fieldNames create object");
+        }
+      };
+
+      if (listOfOptionalOnCreate.length > 0 && listOfRequiredOnCreate.includes(fieldName)) {
+        //(<optionalParams>)
+        //(</optionalParams>)
+      };
+
+      if (objectSchemas.identifierFieldNames.includes(fieldName)) {
+        _izContext.logger.debug("identifiers is", fieldName);
+        Object.assign(objInstanceFull.identifiers, {
+          [fieldName]: requestParams.fieldNames[fieldName]
+        });
+      };
+
+      if (errorsFound.length > 0) {
+        _izContext.logger.debug("HaveError::", errorsFound);
+        break
+      };
+
+    }; // end loop
+
+    let listOfObjectForCreates = [];
+
+    let objInstanceFullForDynamoDb = lodash.cloneDeep(objInstanceFull)
+    let objInstanceFullForGraph = lodash.cloneDeep(objInstanceFull)
+
+    if (errorsFound.length == 0) {
+
+      for (let [storageTag, createDataDetail] of Object.entries(createDataDetails)) {
+
+        if (createDataDetail.storageType == consts.STORAGE_TYPES.dynamoDB) {
+          _izContext.logger.debug("::::::DynamoDB::::::", { storageTag, objInstanceFull });
+
+
+          Object.assign(objInstanceFullForDynamoDb.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
+          _izContext.logger.debug("objInstanceFull before create item in dynamoDB", objInstanceFullForDynamoDb)
+
+          let identifiersForCreateData = await dynamoDbIdentifiersByStorageResource(
+            _izContext,
+            objectSchema,
+            createDataDetails,
+            objInstanceFullForDynamoDb.identifiers
+          )
+          _izContext.logger.debug("identifiersForCreateData", identifiersForCreateData);
+
+          await dynamodbSharedLib.putItem(
+            _izContext,
+            await dynamodbSharedLib.tableName(
+              _izContext,
+              createDataDetail.tableName
+            ),
+            {
+              ...identifiersForCreateData,
+              ...objInstanceFullForDynamoDb.fields
+            }
+          );
+        } else if (createDataDetail.storageType == consts.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: MAIN_OBJTYPE,
+              graphServerTag: storageTag,
+              identifiers: objInstanceFullForGraph.identifiers
+            })),
+            PREFIX.CREATE_OBJECT_ASYNC
+          ));
+          listOfObjectForCreates.push({
+            [storageTag]: {
+              objInstanceFull: {
+                identifiers: objInstanceFullForGraph.identifiers,
+                fields: objInstanceFullForGraph.fields
+              },
+              allStorageTagComplete: false
+            }
+          });
+
+          _izContext.logger.debug("FIRST", listOfObjectForCreates)
+
+        };
+        _izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
+      };
+    };
+
+    function createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail) {
+      _izContext.logger.debug("createObjInstanceFullFieldsByStorageTag : ", { 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]
+              })
+            }
+          }
+        }
+      }
+      _izContext.logger.debug({ fields })
+      return fields
+    }
+    /// step save awiatingMultipleStep of storageType graph ...........................................................
+
+    await asyncFlowSharedLib.createAwaitingMultipleSteps(
+      _izContext,
+      allAwaitingStepsId,
+      asyncFlowSharedLib.createPendingStepId((hash({ objType: MAIN_OBJTYPE, identifiers: objInstanceFull.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,
+            objInstanceFull: objecForCreate.objInstanceFull,
+            relationships: requestParams.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()
+          });
+
+          messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+            messageObject,
+            callingFlowSharedLib.addParentCallingFlowConfig(
+              callingFlowConfig, // resive parent callingFlowConfig.
+              callingFlowSharedLib.createCallingFlowConfig( // callinfflow own service
+                await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.createNodeComplete), {}
+              )
+            )
+          );
+
+          let messageToCreateObject = {
+            Message: JSON.stringify(messageObject),
+            TopicArn: await snsSharedLib.snsTopicArn(_izContext, TOPIC_NAME_GRAPH_HANDLER.inCreateNode, 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: objInstanceFull.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, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
+      };
+      _izContext.logger.debug("Send message to OutCreateObjectComplete :::>", sendMessageOutCreateObjectComplete)
+      await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
+
+      return {
+        objType: MAIN_OBJTYPE,
+        fieldNames: requestParams.fieldNames,
+        relationship: requestParams.relationships,
+        status: "error",
+        errorsFound: errorsFound
+      }
+    } else {
+
+      if (allAwaitingStepsId.length == 0 && listOfObjectForCreates.length == 0) {
+        let messageObject = {
+          objType: {
+            objectType: OBJECT_TYPE,
+            serviceTag: SERVICE_TAG
+          },
+          objInstanceFull: {
+            identifiers: objInstanceFullForDynamoDb.identifiers,
+            fields: objInstanceFullForDynamoDb.fields
+          }
+        }
+
+        if (callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME]) {
+          // send message to SNS OutCreateNodeComplete
+          _izContext.logger.debug("HAVE CallingFlow");
+          messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
+
+          let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+          let outCreateNodeCompleteTopic = await snsSharedLib.snsTopicArn(_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: MAIN_OBJTYPE,
+        fieldNames: requestParams.fieldNames,
+        relationship: requestParams.relationships,
+        status: "complete",
+        errorsFound: errorsFound
+      }
+    }
+  } catch (err) {
+    throw (err)
+  }
+}