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

package/src/TemplateManager/src/PerActionEndpoint/MainFunction/Create/template.ejs

@@ -55,8 +55,9 @@ const PREFIX = {
   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');
 
 /**
   - all storageType( DB and Graph) use objInstance({identifiers,fields})
@@ -91,47 +92,153 @@ module.exports.<%- functionName %>Main = async (
       callingFlowConfig
     });
 
+    let errorsFound = [];
+
     _izContext.correlationIds.set(coreConsts.BASE_USER_ID, "BasDev");
+    const userId = _izContext.correlationIds.get(coreConsts.BASE_USER_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.getObjSchemaS3WithHierarchy(
+    let objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
       _izContext,
-      {
-        objectType: OBJECT_TYPE,
-        serviceTag: SERVICE_TAG
-      },
+      MAIN_OBJTYPE
     );
-    _izContext.logger.debug("objectSchema:", objectSchema)
+    _izContext.logger.debug("objectSchema", objectSchema);
 
-    let objectSchemas = uploadUseCase.generateObjectSchemaForGraphHandler(
+    let objectSchemas = uploadUseCase.generateObjectSchemaForCombineFieldNames(
       _izContext,
       objectSchema
     );
+    _izContext.logger.debug("objectSchemas", objectSchemas);
 
-    let createDataDetails = await createCreateDataDetailsV2(_izContext, objectSchemas);
+    let createDataDetails = await createDataDetailsLib(_izContext, objectSchemas);
     _izContext.logger.debug("createDataDetails is =", createDataDetails);
 
-    let objInstance = {
+    //validate linkType
+    if ((requestParams.hasOwnProperty("relationships")) && (requestParams.relationships.length > 0)) {
+
+      for (let relationshipProperties of requestParams.relationships) {
+        _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")
+            }
+          }
+        }
+      }
+    }
+
+    let requiredOnCreateLinks = {};
+    let createLinkTypeIds = [];
+    // validate relationships link
+    let objectRelationshipSchema = await getObjectSchema.getRequiredOnCreateLinksWithCache(_izContext, MAIN_OBJTYPE);
+    _izContext.logger.debug("objectRelationshipSchema", objectRelationshipSchema);
+
+    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.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
+        );
+
+        Object.assign(requiredOnCreateLinks, {
+          [requiredOnCreateLinkTypeId]: requireLink
+        })
+      }
+
+      for (const createRelationship of requestParams.relationships) {
+        const onCreateLinkTypeId = createLinkTypeId(
+          _izContext,
+          [
+            MAIN_OBJTYPE, createRelationship.targetObjType
+          ],
+          createRelationship.relType
+        );
+
+        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);
+
+    let objInstanceFull = {
       identifiers: {},
       fields: {}
     };
 
-    let listOfRequriedOnCreate = [];
+    let listOfRequiredOnCreate = [];
     let listOfOptionalOnCreate = [];
 
     let allAwaitingStepsId = [];
-    let errorsFound = [];
 
-    if (objectSchemas.identifiers.length === 1 && !identifier.hasOwnProperty("fieldNames")) {
+    // validate single identifiers
+    if (objectSchemas.identifiers.length === 1 && !objectSchemas.identifiers.hasOwnProperty("fieldNames")) {
 
       const identifier = objectSchemas.identifiers[0];
       _izContext.logger.debug(":::::case single identifer:::::", identifier);
@@ -151,10 +258,11 @@ module.exports.<%- functionName %>Main = async (
                 callingFlowConfig: callingFlowConfig
               })
             });
-
+            _izContext.logger.debug("Assign requestParams", requestParams)
           }
 
-        } else if ((objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == false)) {
+        } 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].optionalOnCreate == false) || objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == true) &&
@@ -183,17 +291,15 @@ module.exports.<%- functionName %>Main = async (
 
     _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)
+        listOfRequiredOnCreate.push(keyFieldNames)
       };
 
       if (valueFieldNames.hasOwnProperty("requiredOnCreate") && valueFieldNames.requiredOnCreate === true) {
-        listOfRequriedOnCreate.push(keyFieldNames)
+        listOfRequiredOnCreate.push(keyFieldNames)
       };
 
       if (valueFieldNames.hasOwnProperty("optionalOnCreate") && valueFieldNames.optionalOnCreate === true) {
@@ -204,30 +310,27 @@ module.exports.<%- functionName %>Main = async (
 
     }; // end iteration of fieldNames
 
+    _izContext.logger.debug("listOfRequriedOnCreate", listOfRequiredOnCreate);
+    _izContext.logger.debug("listOfOptionalOnCreate", listOfOptionalOnCreate);
     for (let fieldName of Object.keys(requestParams.fieldNames)) {
 
-      if (!listOfRequriedOnCreate.includes(fieldName)) {
+      if (!listOfRequiredOnCreate.includes(fieldName)) {
         if (!listOfOptionalOnCreate.includes(fieldName)) {
           errorsFound.push("[invalid] over fieldNames create object");
         }
       };
 
-      if (listOfOptionalOnCreate.length > 0 && listOfRequriedOnCreate.includes(fieldName)) {
-        // HookCode
-        // HookCode
+      if (listOfOptionalOnCreate.length > 0 && listOfRequiredOnCreate.includes(fieldName)) {
+        //(<optionalParams>)
+        //(</optionalParams>)
       };
 
-      /*
-        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 (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);
@@ -237,39 +340,40 @@ module.exports.<%- functionName %>Main = async (
     }; // 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)) {
+      for (let [storageTag, createDataDetail] of Object.entries(createDataDetails)) {
 
-          if (createDataDetail.fieldNames.includes(fieldNames) && listOfRequriedOnCreate.includes(fieldNames)) {
-            _izContext.logger.debug("fieldNames match in detail is:", fieldNames);
+        for (let fieldName of Object.keys(requestParams.fieldNames)) {
 
-            if (objInstance.hasOwnProperty("fields")) {
-              Object.assign(objInstance.fields, {
-                [fieldNames]: requestParams.fieldNames[fieldNames]
-              })
-            } else {
-              Object.assign(objInstance, {
-                fields: {
-                  [fieldNames]: requestParams.fieldNames[fieldNames]
-                }
-              })
-            };
+          if (createDataDetail.fieldNames.includes(fieldName) &&
+            listOfOptionalOnCreate.includes(fieldName) || listOfRequiredOnCreate.includes(fieldName)
+          ) {
+            _izContext.logger.debug("fieldNames match in detail is:", fieldName);
+
+            if (!objInstanceFull.identifiers.hasOwnProperty(fieldName))
+              if (objInstanceFull.hasOwnProperty("fields")) {
+                Object.assign(objInstanceFull.fields, {
+                  [fieldName]: requestParams.fieldNames[fieldName]
+                })
+              } else {
+                Object.assign(objInstanceFull, {
+                  fields: {
+                    [fieldName]: requestParams.fieldNames[fieldName]
+                  }
+                })
+              };
           };
         };
 
         if (createDataDetail.storageType == consts.STORAGE_TYPES.dynamoDB) {
-          _izContext.logger.debug("::::::DynamoDB::::::", { serviceName, objInstance });
+          _izContext.logger.debug("::::::DynamoDB::::::", { storageTag, objInstanceFull });
 
           let identifiersForCreateData = await dynamoDbIdentifiersByStorageResource(
             _izContext,
             objectSchema,
             createDataDetails,
-            requestParams.fieldNames
+            objInstanceFull.identifiers
           )
           _izContext.logger.debug("identifiersForCreateData", identifiersForCreateData);
 
@@ -279,27 +383,29 @@ module.exports.<%- functionName %>Main = async (
               _izContext,
               createDataDetail.tableName
             ),
-            identifiersForCreateData
+            {
+              ...identifiersForCreateData,
+              ...objInstanceFull.fields
+            }
           );
 
-
         } else if (createDataDetail.storageType == consts.STORAGE_TYPES.graph) {
-          _izContext.logger.debug("::::::Graphanler::::::", { serviceName, objInstance });
+          _izContext.logger.debug("::::::Graphanler::::::", { storageTag, objInstanceFull });
 
           // allStorageTagComplete = false;
           allAwaitingStepsId.push(asyncFlowSharedLib.createAwaitingStepId(
             (hash({
               objType: MAIN_OBJTYPE,
-              graphServerTag: serviceName,
-              identifiers: objInstance.identifiers
+              graphServerTag: storageTag,
+              identifiers: objInstanceFull.identifiers
             })),
             PREFIX.CREATE_OBJECT_ASYNC
           ));
           listOfObjectForCreates.push({
-            [serviceName]: {
-              objInstance: {
-                identifiers: objInstance.identifiers,
-                fields: objInstance.fields
+            [storageTag]: {
+              objInstanceFull: {
+                identifiers: objInstanceFull.identifiers,
+                fields: objInstanceFull.fields
               },
               allStorageTagComplete: false
             }
@@ -310,7 +416,7 @@ module.exports.<%- functionName %>Main = async (
         };
         _izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
 
-        delete objInstance.fields
+        delete objInstanceFull.fields
       };
     };
 
@@ -319,7 +425,7 @@ module.exports.<%- functionName %>Main = async (
     await asyncFlowSharedLib.createAwaitingMultipleSteps(
       _izContext,
       allAwaitingStepsId,
-      asyncFlowSharedLib.createPendingStepId((hash({ objType: MAIN_OBJTYPE, identifiers: objInstance.identifiers })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)
+      asyncFlowSharedLib.createPendingStepId((hash({ objType: MAIN_OBJTYPE, identifiers: objInstanceFull.identifiers })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)
     );
     //............................................................................................................
 
@@ -336,152 +442,9 @@ module.exports.<%- functionName %>Main = async (
 
           messageObject = {
             objType: MAIN_OBJTYPE,
-            objInstance: objecForCreate.objInstance,
+            objInstanceFull: objecForCreate.objInstanceFull,
+            relationships: requestParams.relationships
           };
-
-          /*
-            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) {
@@ -494,25 +457,19 @@ module.exports.<%- functionName %>Main = async (
             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"),
-                )
+          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, "InCreateNodeV2", graphServiceName)
+            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);
@@ -531,7 +488,7 @@ module.exports.<%- functionName %>Main = async (
         _izContext,
         asyncFlowSharedLib.createPendingStepId((hash({
           objType: MAIN_OBJTYPE,
-          identifiers: objInstance.identifiers
+          identifiers: objInstanceFull.identifiers
         })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)); // pendingStepId
 
       // send message to OutCreateObjectComplete.
@@ -549,33 +506,28 @@ module.exports.<%- functionName %>Main = async (
       let sendMessageOutCreateObjectComplete = {
         Message: JSON.stringify(messageObject),
         MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-        TopicArn: await snsSharedLib.snsTopicArn(_izContext, "OutCreateObjectComplete")
+        TopicArn: await snsSharedLib.snsTopicArn(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
       };
       _izContext.logger.debug("Send message to OutCreateObjectComplete :::>", sendMessageOutCreateObjectComplete)
       await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
 
-      return { returnValue: "function DeliveryMetodStandate have errorFounds" }
+      return {
+        objType: MAIN_OBJTYPE,
+        fieldNames: requestParams.fieldNames,
+        relationship: requestParams.relationships,
+        status: "error",
+        errorsFound: errorsFound
+      }
+    } else {
+      return {
+        objType: MAIN_OBJTYPE,
+        fieldNames: requestParams.fieldNames,
+        relationship: requestParams.relationships,
+        status: "complete",
+      }
     }
-    _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' ]
-  }
-}
-*/
+}