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

package/src/TemplateManager/src/OutPerActionComplete/OutCreateComplete/sns-out/data.js

@@ -0,0 +1,62 @@
+/*
+Copyright (C) 2020 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 path = require('path');
+const fs = require('fs');
+
+const { ACTIONS, HANDLER } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+
+const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase, firstLetterUpperCase } = require("../../../../../MainLibs/src/Utils")
+const { DEFAULT_HANDLER_PER_ACTION, SOURCE_PATH, SAVE_FILE_NAME, FUNCTION_NAME } = require("../../../libs/Consts");
+
+const templatePath = path.join(__dirname, "../../../ResourceYaml/sns-out/template.ejs")
+// /ResourceYaml/sns-out/template.ejs
+// /OutPerActionComplete/OutUpdateComplete/sns-out/data.js
+/**
+ * create data for dynamoDbYaml tempalte from objectSchema
+ * return array of dynamoDb data
+ * because one objectSchema can create multiple dynamoDb table
+ *
+ * @param {Object} _izContext
+ * @param {String} saveFilePath
+ * @returns {Object[]}              - data of multiple dynamoDb template
+ */
+
+function data(_izContext, srcPath) {
+  const createSourceParams = createParamsForCreateSource(_izContext, srcPath)
+  return [createSourceParams]
+}
+
+function createParamsForCreateSource(_izContext, srcPath) {
+  let queueName = FUNCTION_NAME.createObjectComplete
+  return {
+    templatePath: templatePath,
+    templateData: {
+      queueName: upperCase(queueName)
+    },
+    setting: {
+      initialData: 'Resources:\n',
+      savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
+      saveFileName: SAVE_FILE_NAME.snsOutYaml,
+      fileExtension: '.yml',
+      isAppend: true
+    }
+  }
+}
+
+module.exports = data

package/src/TemplateManager/src/OutPerActionComplete/OutCreateComplete/sns-out/template.ejs

@@ -0,0 +1,10 @@
+##--------- [Create Topic Out]
+  Out<%- firstLetterUpperCase(queueName) %>:
+    Type: AWS::SNS::Topic
+    Properties:
+      DisplayName: "SNS Message out"
+      TopicName: ${self:custom.iz_resourcePrefix}Out<%- firstLetterUpperCase(queueName) %>
+
+  <%_ function firstLetterUpperCase(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1)
+  } _%>

package/src/TemplateManager/src/PerActionEndpoint/FunctionYaml/HdrApi/data.js

@@ -89,7 +89,6 @@ function data(_izContext, objectSchema, srcPath) {
 
 function createParamForCreateSource(objectSchema, action, srcPath) {
   let objectType = objectSchema.objectType;
-  let actionHandler = action;
   let functionName = objectType + upperCase(actionHandler);
   let additionalResourcePermission = defaultIamRolePerAction();
   let tableForGetItem = [];
@@ -146,7 +145,7 @@ function createParamForCreateSource(objectSchema, action, srcPath) {
       createIamRole({
         [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
       },
-        resourceNames(RESOURCE_CLASSES.sns, "Out", upperCase(FUNCTION_NAME.updateNodeComplete)))
+        resourceNames(RESOURCE_CLASSES.sns, "Out" + upperCase(FUNCTION_NAME.updateNodeComplete)))
     )
   }
 
@@ -159,7 +158,7 @@ function createParamForCreateSource(objectSchema, action, srcPath) {
       additionalResourcePermission,
       event: event,
       objectType: objectType,
-      action: actionHandler
+      action: action
     },
     setting: {
       savePath: path.join(srcPath, SOURCE_PATH.appYaml),

package/src/TemplateManager/src/PerActionEndpoint/FunctionYaml/HdrInv/data.js

@@ -156,7 +156,9 @@ function createParamForCreateSource(objectSchema, action, srcPath) {
     additionalResourcePermission.push(
       createIamRole(
         {
-          [RESOURCE_CLASSES.dynamoDbTable]: [DYNAMO_RESOURCE.putItem]
+          [RESOURCE_CLASSES.dynamoDbTable]: [DYNAMO_RESOURCE.putItem,
+          DYNAMO_RESOURCE.deleteItem, DYNAMO_RESOURCE.query
+          ]
         },
         [
           resourceNames(RESOURCE_CLASSES.dynamoDbTable, "AwaitingMultipleSteps"),
@@ -170,7 +172,7 @@ function createParamForCreateSource(objectSchema, action, srcPath) {
           [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
         },
         [
-          resourceNames(RESOURCE_CLASSES.sns, "Out" + upperCase(FUNCTION_NAME.createNodeComplete))
+          resourceNames(RESOURCE_CLASSES.sns, "Out" + upperCase(FUNCTION_NAME.createObjectComplete))
         ]
       )
     )

package/src/TemplateManager/src/PerActionEndpoint/Handler/HdrApi/data.js

@@ -61,7 +61,6 @@ function data(_izContext, objectSchema, srcPath) {
 
 function createParamForCreateSource(objectSchema, action, srcPath) {
   let objectType = objectSchema.objectType;
-  let actionHandler = action;
   let functionName = objectType + firstLetterUpperCase(action);
   const handler = HANDLER.hdrApi
   return {
@@ -69,7 +68,7 @@ function createParamForCreateSource(objectSchema, action, srcPath) {
     templateData: {
       functionName: functionName,
       objectType: objectType,
-      actionHandler: actionHandler,
+      action: action,
       isCreateMainFunction: checkOverWriteGenerateMainFunction(objectSchema, action)
     },
     setting: {

package/src/TemplateManager/src/PerActionEndpoint/Handler/HdrInv/data.js

@@ -57,15 +57,15 @@ function data(_izContext, objectSchema, srcPath) {
     } else {
       // if not have overWriteHander of action will use default handler
       const defaultHandler = DEFAULT_HANDLER_PER_ACTION[action]
-      if (action = ACTIONS.get) {
+      if (action == ACTIONS.get) {
         if (defaultHandler.includes(HANDLER.hdrInv)) {
           // create template data and object for create source
           const createHandlerGet = createParamForCreateHandlerGet(objectSchema, action, HANDLER.hdrInv, srcPath)
           createHandlerGet && createSourceArray.push(createHandlerGet)
         }
-      } else if (action = ACTIONS.update) {
+      } else if (action == ACTIONS.update) {
         const createHandlerUpdate = createParamForCreateHandlerUpdate(objectSchema, action, HANDLER.hdrInv, srcPath)
-        createHandlerGet && createSourceArray.push(createHandlerUpdate);
+        createHandlerUpdate && createSourceArray.push(createHandlerUpdate);
       }
     }
   }

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

@@ -56,7 +56,8 @@ const PREFIX = {
 }
 //-----------------------------------------------------------------------------------------------------------
 
-const { createDataDetailsLib } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs')
+const { createCreateDataDetailsV2 } = 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})
@@ -103,24 +104,158 @@ module.exports.<%- functionName %>Main = async (
       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(
       _izContext,
       objectSchema
     );
+    _izContext.logger.debug("objectSchemas", objectSchemas);
 
     let createDataDetails = await createCreateDataDetailsV2(_izContext, objectSchemas);
     _izContext.logger.debug("createDataDetails is =", createDataDetails);
 
-    let objInstance = {
+    let errorsFound = [];
+
+    //validate linkType
+    if ((requestParams.hasOwnProperty("relationships")) && (requestParams.relationship.length > 0)) {
+
+      for (let relationshipProperties of requestParams.relationship) {
+        _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")
+            }
+          }
+        }
+      }
+    }
+
+    // validate relationship link
+    let requiredOnCreateLinks = await getObjectSchema.getRequiredOnCreateLinksGraphHandlerWithCache(_izContext, MAIN_OBJTYPE);
+    _izContext.logger.debug("requiredOnCreateLinks", requiredOnCreateLinks);
+
+    let filterRequireOnCreateRels = {};
+
+    for (const [relationshipTag, relationshipProperties] of Object.entries(requiredOnCreateLinks)) {
+      let filterRequiredLinks = [];
+
+      for (const link of relationshipProperties.links) {
+        _izContext.logger.debug("linkObjectRelationship", link)
+        const serviceTags = await Promise.all(
+          link.storageResourceTags.map(async (storageTag) => {
+            let storageResource = relationshipProperties.storageResources[storageTag];
+            if (storageResource.storageType === consts.STORAGE_TYPES.graph) {
+              return await getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag)
+            }
+          })
+        )
+        _izContext.logger.debug('serviceTags: ', serviceTags);
+
+        if (serviceTags.includes("GraphHandler")) {
+          filterRequiredLinks.push(link)
+        }
+      }
+
+      if (filterRequiredLinks.length) {
+        Object.assign(filterRequireOnCreateRels,
+          {
+            [relationshipTag]: {
+              ...relationshipProperties,
+              links: filterRequiredLinks
+            }
+          })
+      }
+    }
+    _izContext.logger.debug("filterRequireOnCreateRels", filterRequireOnCreateRels)
+
+    if (Object.keys(filterRequireOnCreateRels).length) {
+      if (!requestParams.relationship.length) {
+        for (const relTag in filterRequireOnCreateRels) {
+          errorsFound.push(`missing required relationship of relType: serviceTag: ${filterRequireOnCreateRels[relTag].relationshipServiceTag}, relationshipTag: ${relTag} when create`);
+        }
+      }
+
+      let requiredOnCreateLinks = {};
+      let createLinkTypeIds = [];
+
+      for (const [relTag, relationshipProperties] of Object.entries(filterRequireOnCreateRels)) {
+        _izContext.logger.debug("relationshipProperties", relationshipProperties);
+
+        for (const link of relationshipProperties.links) {
+          const requiredOnCreateLinkTypeId = createLinkTypeId(
+            _izContext,
+            [link.from.objType, link.to.objType],
+            {
+              relationshipTag: relTag,
+              serviceTag: relationshipProperties.relationshipServiceTag
+            }
+          )
+
+          Object.assign(requiredOnCreateLinks,
+            {
+              [requiredOnCreateLinkTypeId]: {
+                relType: {
+                  relationshipTag: relTag,
+                  serviceTag: relationshipProperties.relationshipServiceTag
+                },
+                link: link
+              }
+            })
+          _izContext.logger.debug("requiredOnCreateLinks", requiredOnCreateLinks)
+        }
+      }
+
+      for (const createRelationship of requestParams.relationship) {
+        const onCreateLinkTypeId = createLinkTypeId(
+          _izContext,
+          [MAIN_OBJTYPE, createRelationship.targetObjType],
+          createRelationship.relType
+        )
+
+        if (!requiredOnCreateLinks.hasOwnProperty(onCreateLinkTypeId)) {
+          errorsFound.push(`relType:${JSON.stringify(createRelationship.relType)} are not relationshipSchema for this objType`)
+          continue;
+        } else {
+          createLinkTypeIds.push(onCreateLinkTypeId)
+        }
+        // validate missing relType that should create
+        const remainRequiredOnCreateLinkTypeIds = Object.keys(requiredOnCreateLinks)
+          .filter(requiredOnCreateLinkTypeId => !createLinkTypeIds.includes(requiredOnCreateLinkTypeId));
+
+        if (remainRequiredOnCreateLinkTypeIds.length) {
+          for (const remainRequiredOnCreateLinkTypeId of remainRequiredOnCreateLinkTypeIds) {
+            const missingLink = {
+              from: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].link.from,
+              to: requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].link.to,
+            };
+            errorsFound.push(`Missing link:${JSON.stringify(missingLink)} when create`);
+          }
+        }
+
+        _izContext.logger.debug("requiredOnCreateLinks: ", requiredOnCreateLinks);
+        _izContext.logger.debug("onCreateLinkTypeIds: ", createLinkTypeIds);
+
+      }
+    } else {
+
+      if (requestParams.relationships.length) {
+        errorsFound.push(`objType:${JSON.stringify(objType)} not need relationships when create`);
+      }
+    }
+
+    let objInstanceFull = {
       identifiers: {},
       fields: {}
     };
@@ -129,8 +264,9 @@ module.exports.<%- functionName %>Main = async (
     let listOfOptionalOnCreate = [];
 
     let allAwaitingStepsId = [];
-    let errorsFound = [];
 
+
+    // validate single identifiers
     if (objectSchemas.identifiers.length === 1 && !identifier.hasOwnProperty("fieldNames")) {
 
       const identifier = objectSchemas.identifiers[0];
@@ -151,10 +287,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) &&
@@ -202,9 +339,12 @@ module.exports.<%- functionName %>Main = async (
         };
       };
 
+
     }; // end iteration of fieldNames
 
-    for (let fieldName of Object.keys(requestParams.fieldNames)) {
+    _izContext.logger.debug("listOfRequriedOnCreate", listOfRequriedOnCreate);
+    _izContext.logger.debug("listOfOptionalOnCreate", listOfOptionalOnCreate);
+    for (let fieldName of Object.keys(requestParams.objInstanceFull.fieldNames)) {
 
       if (!listOfRequriedOnCreate.includes(fieldName)) {
         if (!listOfOptionalOnCreate.includes(fieldName)) {
@@ -237,39 +377,37 @@ 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 [serviceName, createDataDetail] of Object.entries(createDataDetails)) {
 
-        for (let fieldNames of Object.keys(requestParams.fieldNames)) {
+        for (let fieldNames of Object.keys(requestParams.objInstanceFull.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]
+            if (objInstanceFull.hasOwnProperty("fields")) {
+              Object.assign(objInstanceFull.fields, {
+                [fieldNames]: requestParams.objInstanceFull.fieldNames[fieldNames]
               })
             } else {
-              Object.assign(objInstance, {
+              Object.assign(objInstanceFull, {
                 fields: {
-                  [fieldNames]: requestParams.fieldNames[fieldNames]
+                  [fieldNames]: requestParams.objInstanceFull.fieldNames[fieldNames]
                 }
               })
             };
           };
         };
-
+        _izContext.logger.debug("objInstanceFull", objInstanceFull)
         if (createDataDetail.storageType == consts.STORAGE_TYPES.dynamoDB) {
-          _izContext.logger.debug("::::::DynamoDB::::::", { serviceName, objInstance });
+          _izContext.logger.debug("::::::DynamoDB::::::", { serviceName, objInstanceFull });
 
           let identifiersForCreateData = await dynamoDbIdentifiersByStorageResource(
             _izContext,
             objectSchema,
             createDataDetails,
-            requestParams.fieldNames
+            requestParams.objInstanceFull.fieldNames
           )
           _izContext.logger.debug("identifiersForCreateData", identifiersForCreateData);
 
@@ -284,22 +422,22 @@ module.exports.<%- functionName %>Main = async (
 
 
         } else if (createDataDetail.storageType == consts.STORAGE_TYPES.graph) {
-          _izContext.logger.debug("::::::Graphanler::::::", { serviceName, objInstance });
+          _izContext.logger.debug("::::::Graphanler::::::", { serviceName, objInstanceFull });
 
           // allStorageTagComplete = false;
           allAwaitingStepsId.push(asyncFlowSharedLib.createAwaitingStepId(
             (hash({
               objType: MAIN_OBJTYPE,
               graphServerTag: serviceName,
-              identifiers: objInstance.identifiers
+              identifiers: objInstanceFull.identifiers
             })),
             PREFIX.CREATE_OBJECT_ASYNC
           ));
           listOfObjectForCreates.push({
             [serviceName]: {
-              objInstance: {
-                identifiers: objInstance.identifiers,
-                fields: objInstance.fields
+              objInstanceFull: {
+                identifiers: objInstanceFull.identifiers,
+                fields: objInstanceFull.fields
               },
               allStorageTagComplete: false
             }
@@ -310,7 +448,7 @@ module.exports.<%- functionName %>Main = async (
         };
         _izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
 
-        delete objInstance.fields
+        delete objInstanceFull.fields
       };
     };
 
@@ -319,7 +457,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 +474,8 @@ module.exports.<%- functionName %>Main = async (
 
           messageObject = {
             objType: MAIN_OBJTYPE,
-            objInstance: objecForCreate.objInstance,
+            objInstanceFull: objecForCreate.objInstanceFull,
           };
-
-          /*
-            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) {
@@ -531,7 +525,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.

package/src/TemplateManager/src/ProcessLogical/mainFunction/template.ejs

@@ -32,6 +32,9 @@ const { getUsedFieldNamesOfIdentifiers } = serviceSchemas.utils;
 
 const sns = require('@izara_project/izara-core-library-external-request').sns;
 
+//(<additionalModule>)
+//(</additionalModule>)
+
 /**
  * performs the logical operation/filter/search in the element, saves into LogicalResultsData table
  * @param {Object} _izContext
@@ -62,13 +65,18 @@ module.exports.processLogical = async (
       callingFlow: callingFlow
     });
 
+    let removeAttributes = ["paginateProcessLogicalUniqueRequestId"];
+
+    //(<removeAttributes>)
+    //(</removeAttributes>)
+
     // Check/Create logicalResultsMain
     let [logicalResultsMainStatus, logicalResultId, logicalResultMain] = await logicalResultsSharedLib.checkLogicalMainStatus(
       _izContext,
       element, // for create logicalResultId
       objType,
       callingFlow,
-      ["paginateProcessLogicalUniqueRequestId"]
+      removeAttributes
     );
     _izContext.logger.debug("After check logicalMainStatus: ", {
       logicalResultsMainStatus: logicalResultsMainStatus,