@izara_project/izara-core-generate-service-code 1.0.66 → 1.0.68

package/src/emit/relationship/templates/CreateRelationship_Main.ejs

@@ -15,37 +15,35 @@ 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/>.
 */
 
-
-import { objectHash as hash, identifierUuid } from '@izara_project/izara-shared-core';
+import {
+  objectHash as hash,
+  identifierUuid
+} from '@izara_project/izara-shared-core';
 
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
-import lambdaSharedLib from "@izara_project/izara-core-library-lambda";
-import snsSharedLib from "@izara_project/izara-core-library-sns";
-import asyncFlowSharedLib from "@izara_project/izara-core-library-asynchronous-flow";
-import dynamodbSharedLib from "@izara_project/izara-core-library-dynamodb";
-
-import { sns } from "@izara_project/izara-core-library-external-request";
-import { getObjectSchema, utils, serviceConfig, consts, relSchemaLib, identifiersObject } from '@izara_project/izara-core-library-service-schemas'
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+
+import { sns } from '@izara_project/izara-core-library-external-request';
+import {
+  getObjectSchema,
+  utils,
+  serviceConfig,
+  consts,
+  relSchemaLib,
+  identifiersObject
+} from '@izara_project/izara-core-library-service-schemas';
 const { findLinksByObjTypes } = relSchemaLib;
-const {
-  getRelationshipSchemaWithCache,
-  getObjSchemaS3WithHierarchy
-} = getObjectSchema
-
-const {
-  createLinkTypeId
-} = utils;
+const { getRelationshipSchemaWithCache, getObjSchemaS3WithHierarchy } =
+  getObjectSchema;
 
-const {
-  getGraphServiceTagWithCache
-} = serviceConfig;
+const { createLinkTypeId } = utils;
 
-const {
-  PREFIX,
-  TOPIC_NAME_GENERATE_CODE,
-  TOPIC_NAME_GRAPH_HANDLER
-} = consts;
+const { getGraphServiceTagWithCache } = serviceConfig;
 
+const { PREFIX, TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER } = consts;
 
 //(<optionalRequire>)
 //(</optionalRequire>)
@@ -63,17 +61,20 @@ const {
 export default async function createRelationship(
   _izContext,
   requestParams,
-  callingFlowConfig = {},
+  callingFlowConfig = {}
   //(<additionalParams>)
   //(</additionalParams>)
 ) {
-
-
   try {
     _izContext.logger.debug('createRelationship _izContext: ', _izContext);
-    _izContext.logger.debug('createRelationship requestParams: ', requestParams);
-    _izContext.logger.debug('createRelationship callingFlowConfig: ', callingFlowConfig);
-
+    _izContext.logger.debug(
+      'createRelationship requestParams: ',
+      requestParams
+    );
+    _izContext.logger.debug(
+      'createRelationship callingFlowConfig: ',
+      callingFlowConfig
+    );
 
     const {
       firstObject,
@@ -94,34 +95,56 @@ export default async function createRelationship(
     //(<beforeValidateCreateRel>)
     //(</beforeValidateCreateRel>).
     // validate object and identifiers
-    async function validateIdentifiersExists(_izContext, objType, identifiersObject) {
-
+    async function validateIdentifiersExists(
+      _izContext,
+      objType,
+      identifiersObject
+    ) {
       const objTypeString = `objType:{ serviceTag:${objType.serviceTag}, objectType:${objType.objectType} }`;
-      const objectSchema = await getObjSchemaS3WithHierarchy(_izContext, objType);
+      const objectSchema = await getObjSchemaS3WithHierarchy(
+        _izContext,
+        objType
+      );
 
       if (!objectSchema) {
-        errorsFound.push(`validateIdentifiers, not found schema of ${objTypeString}`);
+        errorsFound.push(
+          `validateIdentifiers, not found schema of ${objTypeString}`
+        );
       }
 
       for (const schemaIdentifier of objectSchema.identifiers) {
-        let identifierNames = schemaIdentifier.fieldNames || [schemaIdentifier.fieldName];
+        let identifierNames = schemaIdentifier.fieldNames || [
+          schemaIdentifier.fieldName
+        ];
         for (const identifierName of identifierNames) {
           if (!identifiersObject.hasOwnProperty(identifierName)) {
-            errorsFound.push(`validateIdentifiers, ${objTypeString} property:${identifierName} not exists`);
+            errorsFound.push(
+              `validateIdentifiers, ${objTypeString} property:${identifierName} not exists`
+            );
           } else {
             if (
-              typeof (identifiersObject[identifierName]) !== "string" &&
-              typeof (identifiersObject[identifierName]) !== "number"
+              typeof identifiersObject[identifierName] !== 'string' &&
+              typeof identifiersObject[identifierName] !== 'number'
             ) {
-              errorsFound.push(`validateIdentifiers, ${objTypeString} property:${identifierName} should be string or number`);
+              errorsFound.push(
+                `validateIdentifiers, ${objTypeString} property:${identifierName} should be string or number`
+              );
             }
           }
         }
       }
     }
 
-    await validateIdentifiersExists(_izContext, firstObject.objType, firstObject.identifiers);
-    await validateIdentifiersExists(_izContext, secondObject.objType, secondObject.identifiers);
+    await validateIdentifiersExists(
+      _izContext,
+      firstObject.objType,
+      firstObject.identifiers
+    );
+    await validateIdentifiersExists(
+      _izContext,
+      secondObject.objType,
+      secondObject.identifiers
+    );
     // finished validate object and identifiers
 
     //(<afterValidateCreateRel>)
@@ -130,125 +153,177 @@ export default async function createRelationship(
     //(<beforeGetRelCreateRel>)
     //(</beforeGetRelCreateRel>)
 
-    const relationshipSchema = await getRelationshipSchemaWithCache(_izContext, relType);
-    _izContext.logger.debug("relationshipSchema: ", relationshipSchema);
-
-    const firstObjectHie = await getObjectSchema.getObjSchemaS3WithHierarchy(_izContext, firstObject.objType);
-    const secondObjectHie = await getObjectSchema.getObjSchemaS3WithHierarchy(_izContext, secondObject.objType);
-
-    const links = await findLinksByObjTypes(_izContext, [firstObject.objType, secondObject.objType], relationshipSchema.links)
-    _izContext.logger.debug("links", links)
+    const relationshipSchema = await getRelationshipSchemaWithCache(
+      _izContext,
+      relType
+    );
+    _izContext.logger.debug('relationshipSchema: ', relationshipSchema);
+
+    const firstObjectHie = await getObjectSchema.getObjSchemaS3WithHierarchy(
+      _izContext,
+      firstObject.objType
+    );
+    const secondObjectHie = await getObjectSchema.getObjSchemaS3WithHierarchy(
+      _izContext,
+      secondObject.objType
+    );
+
+    const links = await findLinksByObjTypes(
+      _izContext,
+      [firstObject.objType, secondObject.objType],
+      relationshipSchema.links
+    );
+    _izContext.logger.debug('links', links);
     if (!links.length) {
-      errorsFound.push(`not found link between ${JSON.stringify({ firstObject: firstObject.objType })} ${JSON.stringify({ secondObject: secondObject.objType })}`)
-    };
+      errorsFound.push(
+        `not found link between ${JSON.stringify({ firstObject: firstObject.objType })} ${JSON.stringify({ secondObject: secondObject.objType })}`
+      );
+    }
 
     let checkCorrectLink = false;
     for (let link of links) {
-      const { serviceTag: fromServiceTag, objectType: fromObjectType } = link.from.objType;
-      const { serviceTag: toServiceTag, objectType: toObjType } = link.to.objType;
-
-      const { serviceTag: firstServiceTag, objectType: firstObjectType } = firstObject.objType;
-      const { serviceTag: secondServiceTag, objectType: secondObjectType } = secondObject.objType;
-
-      const matchFromTo = fromServiceTag === firstServiceTag && fromObjectType === firstObjectType &&
-        toServiceTag === secondServiceTag && toObjType === secondObjectType;
-
-      const matchToFrom = fromServiceTag === secondServiceTag && fromObjectType === secondObjectType &&
-        toServiceTag === firstServiceTag && toObjType === firstObjectType;
-
-      if ((relationshipDirection === "from" && matchFromTo) ||
-        (relationshipDirection === "to" && matchToFrom)) {
-        checkCorrectLink = true
+      const { serviceTag: fromServiceTag, objectType: fromObjectType } =
+        link.from.objType;
+      const { serviceTag: toServiceTag, objectType: toObjType } =
+        link.to.objType;
+
+      const { serviceTag: firstServiceTag, objectType: firstObjectType } =
+        firstObject.objType;
+      const { serviceTag: secondServiceTag, objectType: secondObjectType } =
+        secondObject.objType;
+
+      const matchFromTo =
+        fromServiceTag === firstServiceTag &&
+        fromObjectType === firstObjectType &&
+        toServiceTag === secondServiceTag &&
+        toObjType === secondObjectType;
+
+      const matchToFrom =
+        fromServiceTag === secondServiceTag &&
+        fromObjectType === secondObjectType &&
+        toServiceTag === firstServiceTag &&
+        toObjType === firstObjectType;
+
+      if (
+        (relationshipDirection === 'from' && matchFromTo) ||
+        (relationshipDirection === 'to' && matchToFrom)
+      ) {
+        checkCorrectLink = true;
         break;
       }
-    };
+    }
 
     if (checkCorrectLink == false) {
-      errorsFound.push(`Wrong Relationship Direction`)
-    };
+      errorsFound.push(`Wrong Relationship Direction`);
+    }
 
     let targetStorageResources = [];
 
     if (relationshipSchema) {
       // find targetStorageResources and validate each storageResources
       await Promise.all(
-        relationshipSchema.links.map(async ({ from, to, storageResourceTags }) => {
-          const { serviceTag: fromServiceTag, objectType: fromObjectType } = from.objType
-          const { serviceTag: toServiceTag, objectType: toObjectType } = to.objType
-
-          const { serviceTag: firstServiceTag, objectType: firstObjectType } = firstObjectHie.extendObjType || firstObject.objType;
-          const { serviceTag: secondServiceTag, objectType: secondObjectType } = secondObjectHie.extendObjType || secondObject.objType;
-
-          // find exists link
-          if (
-            (
-              (firstServiceTag === fromServiceTag && firstObjectType === fromObjectType) &&
-              (secondServiceTag === toServiceTag && secondObjectType === toObjectType)
-            ) ||
-            (
-              (firstServiceTag === toServiceTag && firstObjectType === toObjectType) &&
-              (secondServiceTag === fromServiceTag && secondObjectType === fromObjectType)
-            )
-          ) {
-
-            // check founded storageResource of link and collect used storageResources
-            await Promise.all(storageResourceTags.map(async storageResourceTag => {
-              const usedStorageResource = relationshipSchema.storageResources[storageResourceTag];
-
-              if (usedStorageResource.storageType === consts.STORAGE_TYPES.graph) {
-                const graphServiceTag = await getGraphServiceTagWithCache(_izContext, usedStorageResource.graphServerTag);
-                if (!graphServiceTag) {
-                  errorsFound.push(`storageResourceTag: ${storageResourceTag} invalid, not found graph serviceTag from graphServerTag: ${usedStorageResource.graphServerTag}`)
-                }
-
-                targetStorageResources.push({
-                  ...usedStorageResource,
-                  graphServiceTag: graphServiceTag
-                });
-              } else {
-                targetStorageResources.push(usedStorageResource);
-              }
-            }));
+        relationshipSchema.links.map(
+          async ({ from, to, storageResourceTags }) => {
+            const { serviceTag: fromServiceTag, objectType: fromObjectType } =
+              from.objType;
+            const { serviceTag: toServiceTag, objectType: toObjectType } =
+              to.objType;
+
+            const { serviceTag: firstServiceTag, objectType: firstObjectType } =
+              firstObjectHie.extendObjType || firstObject.objType;
+            const {
+              serviceTag: secondServiceTag,
+              objectType: secondObjectType
+            } = secondObjectHie.extendObjType || secondObject.objType;
+
+            // find exists link
+            if (
+              (firstServiceTag === fromServiceTag &&
+                firstObjectType === fromObjectType &&
+                secondServiceTag === toServiceTag &&
+                secondObjectType === toObjectType) ||
+              (firstServiceTag === toServiceTag &&
+                firstObjectType === toObjectType &&
+                secondServiceTag === fromServiceTag &&
+                secondObjectType === fromObjectType)
+            ) {
+              // check founded storageResource of link and collect used storageResources
+              await Promise.all(
+                storageResourceTags.map(async (storageResourceTag) => {
+                  const usedStorageResource =
+                    relationshipSchema.storageResources[storageResourceTag];
+
+                  if (
+                    usedStorageResource.storageType ===
+                    consts.STORAGE_TYPES.graph
+                  ) {
+                    const graphServiceTag = await getGraphServiceTagWithCache(
+                      _izContext,
+                      usedStorageResource.graphServerTag
+                    );
+                    if (!graphServiceTag) {
+                      errorsFound.push(
+                        `storageResourceTag: ${storageResourceTag} invalid, not found graph serviceTag from graphServerTag: ${usedStorageResource.graphServerTag}`
+                      );
+                    }
+
+                    targetStorageResources.push({
+                      ...usedStorageResource,
+                      graphServiceTag: graphServiceTag
+                    });
+                  } else {
+                    targetStorageResources.push(usedStorageResource);
+                  }
+                })
+              );
+            }
           }
-        })
+        )
       );
       //(<afterGetRelCreateRel>)
       //(</afterGetRelCreateRel>)
-      _izContext.logger.debug("targetStorageResources: ", targetStorageResources);
+      _izContext.logger.debug(
+        'targetStorageResources: ',
+        targetStorageResources
+      );
 
       if (!targetStorageResources.length) {
         errorsFound.push(`Not found link from relationship schema`);
       }
 
-
       // validate properties exists with schema
       for (const propKey in relationshipProperties) {
         if (!relationshipSchema.fieldNames.hasOwnProperty(propKey)) {
-          errorsFound.push(`property: ${propKey} not exists in relationshipSchema`);
+          errorsFound.push(
+            `property: ${propKey} not exists in relationshipSchema`
+          );
         }
       }
 
       // validate canCreate properties relationship
-      for (const [propName, propSetting] of Object.entries(relationshipSchema.fieldNames)) {
+      for (const [propName, propSetting] of Object.entries(
+        relationshipSchema.fieldNames
+      )) {
         if (propSetting.requiredOnCreate === true) {
           if (!relationshipProperties.hasOwnProperty(propName)) {
             errorsFound.push(`Missing requiredOnCreate property: ${propName}`);
           }
         }
 
-        if (!propSetting.optionalOnCreate && !propSetting.requiredOnCreate && relationshipProperties.hasOwnProperty(propName)) {
+        if (
+          !propSetting.optionalOnCreate &&
+          !propSetting.requiredOnCreate &&
+          relationshipProperties.hasOwnProperty(propName)
+        ) {
           errorsFound.push(`property: ${propName} cannot create`);
         }
       }
-
     } else {
       errorsFound.push(`relationshipSchema not exists`);
     }
 
-
     // if found errors will stop processing
     if (errorsFound.length) {
-
       let createRelCompleteMsg = {
         firstObject: firstObject,
         secondObject: secondObject,
@@ -263,35 +338,60 @@ export default async function createRelationship(
       };
 
       // if have callingFlow will send to message complete
-      if (callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME]) {
-        _izContext.logger.debug("HAVE CallingFlow");
-
-        createRelCompleteMsg = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, createRelCompleteMsg);
-        let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+      if (
+        callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME]
+      ) {
+        _izContext.logger.debug('HAVE CallingFlow');
+
+        createRelCompleteMsg =
+          callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
+            callingFlowConfig,
+            createRelCompleteMsg
+          );
+        let messageAttributes =
+          callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+            callingFlowConfig,
+            {}
+          );
 
         let messageParams = {
           Message: JSON.stringify(createRelCompleteMsg),
-          MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateRelComplete),
+          MessageAttributes: sns.createStringMessageAttributes(
+            _izContext,
+            messageAttributes
+          ),
+          TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+            _izContext,
+            TOPIC_NAME_GENERATE_CODE.outCreateRelComplete
+          )
         };
 
-        _izContext.logger.debug("messageParams OutCreateRelationshipComplete ::::::: ", messageParams);
+        _izContext.logger.debug(
+          'messageParams OutCreateRelationshipComplete ::::::: ',
+          messageParams
+        );
         await sns.publishAsync(_izContext, messageParams);
       }
 
       return createRelCompleteMsg;
     }
 
-
     // before create awaitingStepId per graph storageResource
-    const linkTypeId = createLinkTypeId(_izContext, firstObject.objType, secondObject.objType, relType, relationshipDirection);
+    const linkTypeId = createLinkTypeId(
+      _izContext,
+      firstObject.objType,
+      secondObject.objType,
+      relType,
+      relationshipDirection
+    );
 
     let usedGraphServiceTag = []; // collect used graph serviceTag, use to check duplicate graph serviceTag across graph serverTag
     let targetGraphStorageResources = []; // collect used graph storageResources, filtered duplicate graphServiceTag from graphServerTag out
     let awaitingStepIds = [];
 
     for (const targetStorageResource of targetStorageResources) {
-      if (targetStorageResource.storageType === consts.STORAGE_TYPES.graph &&
+      if (
+        targetStorageResource.storageType === consts.STORAGE_TYPES.graph &&
         !usedGraphServiceTag.includes(targetStorageResource.graphServiceTag)
       ) {
         usedGraphServiceTag.push(targetStorageResource.graphServiceTag);
@@ -307,31 +407,45 @@ export default async function createRelationship(
       }
 
       // if have storageResource.storageType === "dynamoDB" will create relationship here
-      else if (targetStorageResource.storageType === consts.STORAGE_TYPES.dynamoDB) {
+      else if (
+        targetStorageResource.storageType === consts.STORAGE_TYPES.dynamoDB
+      ) {
         let tableNameFrom = `${firstObject.objType.serviceTag}_${firstObject.objType.objectType}__${relType.relationshipTag}__${secondObject.objType.serviceTag}_${secondObject.objType.objectType}`;
         let tableNameTo = `${secondObject.objType.serviceTag}_${secondObject.objType.objectType}__${relType.relationshipTag}__${firstObject.objType.serviceTag}_${firstObject.objType.objectType}`;
 
-        let identifiersConcatFirstObject = await identifiersObject.identifiersConcatFromIdentifiers(_izContext, firstObject.objType, firstObject.identifiers);
-        let identifiersConcatSecondObject = await identifiersObject.identifiersConcatFromIdentifiers(_izContext, secondObject.objType, secondObject.identifiers);
+        let identifiersConcatFirstObject =
+          await identifiersObject.identifiersConcatFromIdentifiers(
+            _izContext,
+            firstObject.objType,
+            firstObject.identifiers
+          );
+        let identifiersConcatSecondObject =
+          await identifiersObject.identifiersConcatFromIdentifiers(
+            _izContext,
+            secondObject.objType,
+            secondObject.identifiers
+          );
         const firstObjectIdentifiersConcat = `${firstObject.objType.serviceTag}_${firstObject.objType.objectType}__identifiersConcat`;
         const secondObjectIdentifiersConcat = `${secondObject.objType.serviceTag}_${secondObject.objType.objectType}__identifiersConcat`;
         // putItem first Object DynamoDb
-        await dynamodbSharedLib.putItem(_izContext,
+        await dynamodbSharedLib.putItem(
+          _izContext,
           await dynamodbSharedLib.tableName(_izContext, tableNameFrom),
           {
             [firstObjectIdentifiersConcat]: identifiersConcatFirstObject,
             [secondObjectIdentifiersConcat]: identifiersConcatSecondObject
           }
-        )
+        );
 
         // put Item second Object DynamoDb
-        await dynamodbSharedLib.putItem(_izContext,
+        await dynamodbSharedLib.putItem(
+          _izContext,
           await dynamodbSharedLib.tableName(_izContext, tableNameTo),
           {
             [secondObjectIdentifiersConcat]: identifiersConcatSecondObject,
             [firstObjectIdentifiersConcat]: identifiersConcatFirstObject
           }
-        )
+        );
       }
     }
 
@@ -340,7 +454,8 @@ export default async function createRelationship(
       await asyncFlowSharedLib.createAwaitingMultipleSteps(
         _izContext,
         awaitingStepIds, // awaitingStepIds
-        asyncFlowSharedLib.createPendingStepId( // pendingStepId
+        asyncFlowSharedLib.createPendingStepId(
+          // pendingStepId
           _izContext.uniqueRequestId, // hash id
           PREFIX.createRel // prefix, use constant further
         )
@@ -355,46 +470,59 @@ export default async function createRelationship(
         relationshipProperties,
         deepPathConditional: deepPathConditional || [],
         parentFlowId,
-        settings: {createOnConditionalFail: createOnConditionalFail}
+        settings: { createOnConditionalFail: createOnConditionalFail }
         //(<inCreateRelMessageBodyCreateRel>)
         //(</inCreateRelMessageBodyCreateRel>)
 
         // assign originTimestamp if not exists in relationshipProperties
-      }
+      };
       _izContext.logger.debug('createRelMessageBody: ', createRelMessageBody);
 
       await Promise.all(
         targetGraphStorageResources.map(async (storageResource) => {
           if (storageResource.storageType === consts.STORAGE_TYPES.graph) {
-
-            createRelMessageBody = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-              createRelMessageBody,
-              callingFlowSharedLib.addParentCallingFlowConfig(
-                callingFlowConfig, // receive parent callingFlowConfig.
-                callingFlowSharedLib.createCallingFlowConfig( // calling flow own service
-                  //(<callingFlowProperties>)
-                  await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.createRelComplete),
-                  //(</callingFlowProperties>)
-                  {
-                    graphServiceTag: storageResource.graphServiceTag
-                  }
+            createRelMessageBody =
+              callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+                createRelMessageBody,
+                callingFlowSharedLib.addParentCallingFlowConfig(
+                  callingFlowConfig, // receive parent callingFlowConfig.
+                  callingFlowSharedLib.createCallingFlowConfig(
+                    // calling flow own service
+                    //(<callingFlowProperties>)
+                    await lambdaSharedLib.lambdaFunctionName(
+                      _izContext,
+                      TOPIC_NAME_GENERATE_CODE.createRelComplete
+                    ),
+                    //(</callingFlowProperties>)
+                    {
+                      graphServiceTag: storageResource.graphServiceTag
+                    }
+                  )
                 )
-              )
+              );
+            _izContext.logger.debug(
+              'messageObject before send message:',
+              createRelMessageBody
             );
-            _izContext.logger.debug("messageObject before send message:", createRelMessageBody)
 
             let messageToInCreateRelationship = {
               Message: JSON.stringify(createRelMessageBody),
-              TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GRAPH_HANDLER.inCreateRel, storageResource.graphServiceTag),
+              TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+                _izContext,
+                TOPIC_NAME_GRAPH_HANDLER.inCreateRel,
+                storageResource.graphServiceTag
+              )
             };
-            _izContext.logger.debug("RequestParams before send to sqs messageToInUpdateRelationship ::::::: ", messageToInCreateRelationship);
+            _izContext.logger.debug(
+              'RequestParams before send to sqs messageToInUpdateRelationship ::::::: ',
+              messageToInCreateRelationship
+            );
             await sns.publishAsync(_izContext, messageToInCreateRelationship);
           }
         })
-      )
-
+      );
     } else if (!awaitingStepIds.length) {
-      _izContext.logger.debug("dynamoDb storageResourceTag")
+      _izContext.logger.debug('dynamoDb storageResourceTag');
       // if relationshipSchema stored in dynamoDB only will send message to outComplete
       let messageObject = {
         firstObject: firstObject,
@@ -405,20 +533,38 @@ export default async function createRelationship(
         parentFlowId
       };
 
-      if (callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME]) {
-        _izContext.logger.debug("have callingFlow");
-        messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
-
-        let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+      if (
+        callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME]
+      ) {
+        _izContext.logger.debug('have callingFlow');
+        messageObject =
+          callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(
+            callingFlowConfig,
+            messageObject
+          );
+
+        let messageAttributes =
+          callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+            callingFlowConfig,
+            {}
+          );
         let sendMessageToOutCreateRelComplete = {
           Message: JSON.stringify(messageObject),
-          MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateRelComplete)
-        }
-        _izContext.logger.debug("send Message to outCreateRelationshipComplete :::", sendMessageToOutCreateRelComplete);
+          MessageAttributes: sns.createStringMessageAttributes(
+            _izContext,
+            messageAttributes
+          ),
+          TopicArn: snsSharedLib.snsTopicArnByFlowSchema(
+            _izContext,
+            TOPIC_NAME_GENERATE_CODE.outCreateRelComplete
+          )
+        };
+        _izContext.logger.debug(
+          'send Message to outCreateRelationshipComplete :::',
+          sendMessageToOutCreateRelComplete
+        );
         await sns.publishAsync(_izContext, sendMessageToOutCreateRelComplete);
       }
-
     }
 
     return {
@@ -427,12 +573,10 @@ export default async function createRelationship(
       relType: relType,
       relationshipDirection,
       relationshipProperties,
-      status: "complete"
+      status: 'complete'
     };
-
-
   } catch (err) {
-    _izContext.logger.error('error updateRelationship: ', err)
-    throw (err)
+    _izContext.logger.error('error updateRelationship: ', err);
+    throw err;
   }
 }