@izara_project/izara-core-generate-service-code 1.0.22 → 1.0.24

package/src/generateCode/generateSchema/actionEndpointCompleteComponent/create/mainFunction/template.ejs

@@ -22,25 +22,154 @@ import snsSharedLib from '@izara_project/izara-core-library-sns';
 import { sns } from '@izara_project/izara-core-library-external-request';
 import _ from 'lodash';
 import { objectHash as hash } from '@izara_project/izara-shared-core';
-import { consts } from '@izara_project/izara-core-library-service-schemas';
+import {
+  consts,
+  errors,
+} from '@izara_project/izara-core-library-service-schemas';
+
 const { TOPIC_NAME_GENERATE_CODE } = consts;
+const { NoRetryError } = errors;
 const PREFIX = {
-  CREATE_OBJECT_ASYNC: "createObjectAsync",
-  CREATE_OBJECT_ASYNC_COMPLETE: "createObjectAsyncComplete"
-}
+  CREATE_OBJECT_ASYNC: 'createObjectAsync',
+  CREATE_OBJECT_ASYNC_COMPLETE: 'createObjectAsyncComplete',
+};
+
 //(<optionalRequire>)
 //(</optionalRequire>)
 
 /**
- *
- * @param {*} _izContext
  * @param {*} returnValue
  * @param {*} status
- * @param {*} errorsFounds
  * @param {*} graphServiceTag
+ * @param {*} errorsFound
+ */
+function validateInput(returnValue, status, graphServiceTag, errorsFound) {
+  if (!Object.prototype.hasOwnProperty.call(returnValue, 'queryResult')) {
+    errorsFound.push(
+      'message is not have property queryResult, should be not happen',
+    );
+  }
+  if (
+    !Object.prototype.hasOwnProperty.call(returnValue.requestParams, 'objType')
+  ) {
+    errorsFound.push(
+      'message is not have property objType, should be not happen',
+    );
+  }
+  if (
+    !Object.prototype.hasOwnProperty.call(
+      returnValue.requestParams,
+      'objInstanceFull',
+    )
+  ) {
+    errorsFound.push(
+      'message is not have property objInstance, should be not objInstance',
+    );
+  }
+
+  if (status == 'error' && errorsFound.length > 0) {
+    errorsFound.push('error before validate');
+  } else if (status == 'error' && errorsFound.length == 0) {
+    errorsFound.push(
+      '[invalid]status is error not have errorsFound form graphService',
+    );
+  }
+  if (status === 'complete' && errorsFound.length > 0) {
+    errorsFound.push(
+      '[Invalid] status is complete should be not have errorsFound',
+    );
+  }
+  if (graphServiceTag == null) {
+    errorsFound.push('[Invalid] graphServerTag is not empty string');
+  }
+}
+
+/**
+ * @param {*} returnValue
+ * @returns {object|null}
+ */
+function buildExistsNode(returnValue) {
+  const { existsNode } = returnValue.queryResult.returnCreateNode;
+  if (!Object.keys(existsNode).length) return null;
+
+  const { objType } = returnValue.requestParams;
+  return {
+    objType: {
+      objectType: objType.objectType,
+      serviceTag: objType.serviceTag,
+    },
+    objInstanceFull: existsNode.objInstanceFull,
+  };
+}
+
+/**
+ * @param {*} returnValue
+ * @param {*} existsNode
+ * @param {*} status
+ * @param {*} errorsFound
+ * @returns {object}
+ */
+function buildMessageObject(returnValue, existsNode, status, errorsFound) {
+  const { objType } = returnValue.requestParams;
+  const { returnCreateNode } = returnValue.queryResult;
+
+  return {
+    objType: {
+      objectType: objType.objectType,
+      serviceTag: objType.serviceTag,
+    },
+    objInstanceFull: returnCreateNode.objInstanceFull,
+    relationships: returnCreateNode.relationships,
+    existsNode,
+    status,
+    errorsFound,
+  };
+}
+
+/**
+ * @param {*} _izContext
  * @param {*} passBackProperties
+ * @param {*} messageObject
  */
+async function sendSnsMessage(_izContext, passBackProperties, messageObject) {
+  const enrichedMessage =
+    callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
+      passBackProperties,
+      messageObject,
+    );
+  const messageAttributes =
+    callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
+      passBackProperties,
+      {},
+    );
+
+  const snsPayload = {
+    Message: JSON.stringify(enrichedMessage),
+    MessageAttributes: sns.createStringMessageAttributes(
+      _izContext,
+      messageAttributes,
+    ),
+    TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete,
+    ),
+  };
 
+  _izContext.logger.debug(
+    'Send message to OutCreateObjectComplete :::>',
+    snsPayload,
+  );
+  await sns.publishAsync(_izContext, snsPayload);
+}
+
+/**
+ * @param {*} _izContext
+ * @param {*} returnValue
+ * @param {*} status
+ * @param {*} errorsFound
+ * @param {*} graphServiceTag
+ * @param {*} passBackProperties
+ */
 export default async function createObjectComplete(
   _izContext,
   returnValue,
@@ -50,7 +179,7 @@ export default async function createObjectComplete(
   passBackProperties,
 ) {
   try {
-    _izContext.logger.debug("function createObjectComplete:", {
+    _izContext.logger.debug('function createObjectComplete:', {
       returnValue,
       status,
       errorsFound,
@@ -59,106 +188,63 @@ export default async function createObjectComplete(
     });
 
     if (_.isEmpty(returnValue.requestParams)) {
-      _izContext.logger.debug("message callingFlowProperties is empty");
-      throw new NoRetryError("message not an object")
-    };
-    // validate.
-    if (!returnValue.hasOwnProperty("queryResult")) {
-      errorsFound.push("message is not have property queryResult, should be not happen");
-    };
-    if (!returnValue.requestParams.hasOwnProperty("objType")) {
-      errorsFound.push("message is not have property objType, should be not happen");
-    };
-    if (!returnValue.requestParams.hasOwnProperty("objInstanceFull")) {
-      errorsFound.push("message is not have property objInstance, should be not objInstance");
-    };
-
-    if (status == "error" && errorsFound.length > 0) {
-      errorsFound.push("error before validate");
-    } else if (status == "error" && errorsFound.length == 0) {
-      errorsFound.push("[invalid]status is error not have errorsFound form graphService");
-
-    };
-    if (status === "complete" && errorsFound.length > 0) {
-      errorsFound.push("[Invalid] status is complete should be not have errorsFound");
-    };
-    if (graphServiceTag == null) {
-      errorsFound.push("[Invalid] graphServerTag is not empty string");
-    };
+      _izContext.logger.debug('message callingFlowProperties is empty');
+      throw new NoRetryError('message not an object');
+    }
+
+    validateInput(returnValue, status, graphServiceTag, errorsFound);
 
     if (errorsFound.length > 0) {
-      _izContext.logger.debug("Have error form graphServerTag:", errorsFound);
-      errorsFound = errorsFound.concat(errorsFound.join(","));
-    };
-
-    let existsNode = null;
-
-    if (Object.keys(returnValue.queryResult.returnCreateNode.existsNode).length) {
-      existsNode = {
-        objType: {
-          objectType: returnValue.requestParams.objType.objectType,
-          serviceTag: returnValue.requestParams.objType.serviceTag
-        },
-        objInstanceFull: returnValue.queryResult.returnCreateNode.existsNode.objInstanceFull
-      }
+      _izContext.logger.debug('Have error form graphServerTag:', errorsFound);
+      errorsFound.push(errorsFound.join(','));
     }
 
-    let awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
-      (hash({
-        objType: returnValue.requestParams.objType,
+    const existsNode = buildExistsNode(returnValue);
+
+    const { requestParams } = returnValue;
+    const awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
+      hash({
+        objType: requestParams.objType,
         graphServerTag: graphServiceTag,
-        identifiers: returnValue.requestParams.objInstanceFull.identifiers,
-        callingFlowProperties: passBackProperties.passBackProperties.parentPassBackProperties.callingFlowProperties || {}
-      })),
-      PREFIX.CREATE_OBJECT_ASYNC
-    )
-    _izContext.logger.debug("awaitingStepId:", awaitingStepId);
+        identifiers: requestParams.objInstanceFull.identifiers,
+        callingFlowProperties:
+          passBackProperties.passBackProperties.parentPassBackProperties
+            .callingFlowProperties || {},
+      }),
+      PREFIX.CREATE_OBJECT_ASYNC,
+    );
+    _izContext.logger.debug('awaitingStepId:', awaitingStepId);
 
-    let recordAwaitingSteps = await dynamodbSharedLib.query(
+    const recordAwaitingSteps = await dynamodbSharedLib.query(
       _izContext,
-      await dynamodbSharedLib.tableName(_izContext, "AwaitingMultipleSteps"),
-      {
-        awaitingStepId: awaitingStepId
-      }
+      await dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
+      { awaitingStepId },
     );
-    _izContext.logger.debug("record awaitingSteps::", recordAwaitingSteps);
+    _izContext.logger.debug('record awaitingSteps::', recordAwaitingSteps);
 
     await Promise.all(
       recordAwaitingSteps.Items.map(async ({ pendingStepId }) => {
-        if (await asyncFlowSharedLib.checkAllAwaitingStepsFinished(
-          _izContext,
-          pendingStepId,
-          awaitingStepId,
-          errorsFound
-        )) {
-          _izContext.logger.debug("finish all awaitingStep");
-
-          let messageObject = {
-            objType: {
-              objectType: returnValue.requestParams.objType.objectType,
-              serviceTag: returnValue.requestParams.objType.serviceTag
-            },
-            objInstanceFull: returnValue.queryResult.returnCreateNode.objInstanceFull,
-            relationships: returnValue.queryResult.returnCreateNode.relationships,
-            existsNode: existsNode,
-            status: status,
-            errorsFound: errorsFound
-          }
+        if (
+          await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithError(
+            _izContext,
+            pendingStepId,
+            awaitingStepId,
+            errorsFound,
+          )
+        ) {
+          _izContext.logger.debug('finish all awaitingStep');
+
+          const messageObject = buildMessageObject(
+            returnValue,
+            existsNode,
+            status,
+            errorsFound,
+          );
 
           //(<beforeSendMessage>)
           //(</beforeSendMessage>)
 
-          messageObject = callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(passBackProperties, messageObject)
-          let messageAttributes = callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(passBackProperties, {})
-
-          let sendMessageOutCreateObjectComplete = {
-            Message: JSON.stringify(messageObject),
-            MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-            TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
-          };
-          _izContext.logger.debug("Send message to OutCreateObjectComplete :::>", sendMessageOutCreateObjectComplete)
-          await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete);
-
+          await sendSnsMessage(_izContext, passBackProperties, messageObject);
 
           //(<afterSendMessage>)
           //(</afterSendMessage>)
@@ -168,20 +254,16 @@ export default async function createObjectComplete(
           _izContext,
           awaitingStepId,
           pendingStepId,
-          errorsFound
+          errorsFound,
         );
+      }),
+    );
 
-      })
-    )
     //(<beforeReturn>)
     //(</beforeReturn>)
-    return {
-      returnValue: returnValue,
-      status: status,
-      errorsFound: errorsFound
-    }
-
+    return { returnValue, status, errorsFound };
   } catch (err) {
-    throw (err)
+    _izContext.logger.error('createObjectComplete error:', err);
+    throw err;
   }
 }

package/src/generateCode/generateSchema/actionEndpointCompleteComponent/create/sns-out/data.js

@@ -60,7 +60,8 @@ function createParamsForCreateSource(_izContext, srcPath) {
       savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
       saveFileName: SAVE_FILE_NAME.snsOutYaml,
       fileExtension: '.yml',
-      isAppend: true
+      isAppend: true,
+      fromFile: 'actionEndpointCom/create/sns-out/data.js'
     }
   };
 }

package/src/generateCode/generateSchema/actionEndpointCompleteComponent/delete/sns-out/data.js

@@ -60,7 +60,8 @@ function createParamsForCreateSource(_izContext, srcPath) {
       savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
       saveFileName: SAVE_FILE_NAME.snsOutYaml,
       fileExtension: '.yml',
-      isAppend: true
+      isAppend: true,
+      fromFile: 'actionEndpointCom/delete/sns-out/data.js'
     }
   };
 }

package/src/generateCode/generateSchema/actionEndpointCompleteComponent/get/sns-out/data.js

@@ -60,7 +60,8 @@ function createParamsForCreateSource(_izContext, srcPath) {
       savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
       saveFileName: SAVE_FILE_NAME.snsOutYaml,
       fileExtension: '.yml',
-      isAppend: true
+      isAppend: true,
+      fromFile: 'actionEndpointCom/get/sns-out/data.js'
     }
   };
 }

package/src/generateCode/generateSchema/actionEndpointCompleteComponent/update/mainFunction/template.ejs

@@ -15,119 +15,185 @@ 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 } from '@izara_project/izara-shared-core';
 import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
 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 { sns } from '@izara_project/izara-core-library-external-request';
+import {
+  consts,
+} from '@izara_project/izara-core-library-service-schemas';
 
-import { consts } from '@izara_project/izara-core-library-service-schemas';
 const { TOPIC_NAME_GENERATE_CODE } = consts;
+const PREFIX = {
+  updateNode: 'updateNode',
+};
 
 //(<optionalRequire>)
 //(</optionalRequire>)
 
+/**
+ * @param {*} returnValue
+ * @returns {string}
+ */
+function buildAwaitingStepId(returnValue) {
+  const { objType, objInstanceFull } = returnValue.requestParams;
+  return asyncFlowSharedLib.createAwaitingStepId(
+    hash({
+      objectType: objType.objectType,
+      serviceTag: objType.serviceTag,
+      identifiers: objInstanceFull.identifiers,
+      fields: objInstanceFull.fields,
+    }),
+    PREFIX.updateNode,
+  );
+}
+
+/**
+ * @param {*} returnValue
+ * @param {*} status
+ * @param {*} errorsFound
+ * @returns {object}
+ */
+function buildUpdateCompleteMsg(returnValue, status, errorsFound) {
+  const { objType, objInstanceFull } = returnValue.requestParams;
+  return {
+    objType: {
+      objectType: objType.objectType,
+      serviceTag: objType.serviceTag,
+    },
+    objInstanceFull: {
+      identifiers: objInstanceFull.identifiers,
+      fields: objInstanceFull.fields,
+    },
+    status,
+    errorsFound,
+  };
+}
+
+/**
+ * @param {*} _izContext
+ * @param {*} passBackProperties
+ * @param {*} message
+ */
+async function sendSnsMessage(_izContext, passBackProperties, message) {
+  const enrichedMessage =
+    callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(
+      passBackProperties,
+      message,
+    );
+  _izContext.logger.debug(
+    'after addCallingFlow to SnsResponseMessageObject',
+    enrichedMessage,
+  );
+
+  const messageAttributes =
+    callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(
+      passBackProperties,
+      {},
+    );
+  _izContext.logger.debug(
+    'after addCallingFlow to SnsResponseMessageAttributes',
+    enrichedMessage,
+  );
+
+  const snsPayload = {
+    Message: JSON.stringify(enrichedMessage),
+    MessageAttributes: sns.createStringMessageAttributes(
+      _izContext,
+      messageAttributes,
+    ),
+    TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(
+      _izContext,
+      TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete,
+    ),
+  };
+  _izContext.logger.debug(
+    'Send Message to OutUpdateNodeComplete::',
+    snsPayload,
+  );
+  await sns.publishAsync(_izContext, snsPayload);
+}
+
+/**
+ * @param {*} _izContext
+ * @param {*} returnValue
+ * @param {*} status
+ * @param {*} errorsFound
+ * @param {*} passBackProperties
+ */
 export default async function updateNodeComplete(
   _izContext,
   returnValue,
   status,
   errorsFound,
-  passBackProperties = {}
+  passBackProperties = {},
 ) {
   try {
-    _izContext.logger.debug("Function:updateNodeComplete", {
-      _izContext: _izContext,
-      returnValue: returnValue,
-      status: status,
-      errorsFound: errorsFound,
-      passBackProperties: passBackProperties
+    _izContext.logger.debug('Function:updateNodeComplete', {
+      returnValue,
+      status,
+      errorsFound,
+      passBackProperties,
     });
 
-    // start create AwaitingStepId
-    let awaitingStepId = asyncFlowSharedLib.createAwaitingStepId(
-      hash({
-        objectType: returnValue.requestParams.objType.objectType,
-        serviceTag: returnValue.requestParams.objType.serviceTag,
-        identifiers: returnValue.requestParams.objInstanceFull.identifiers,
-        fields: returnValue.requestParams.objInstanceFull.fields
-      }),
-      PREFIX.updateNode
-    )
+    const awaitingStepId = buildAwaitingStepId(returnValue);
 
-    let updateNodePendingObjects = await dynamodbSharedLib.query(
+    const updateNodePendingObjects = await dynamodbSharedLib.query(
       _izContext,
-      await dynamodbSharedLib.tableName(_izContext, "AwaitingMultipleSteps"),
-      {
-        awaitingStepId: awaitingStepId
-      }
+      await dynamodbSharedLib.tableName(_izContext, 'AwaitingMultipleSteps'),
+      { awaitingStepId },
+    );
+    _izContext.logger.debug(
+      'updateNodePendingObjects',
+      updateNodePendingObjects,
     );
-    _izContext.logger.debug("updateNodePendingObjects", updateNodePendingObjects);
 
     await Promise.all(
       updateNodePendingObjects.Items.map(async ({ pendingStepId }) => {
-        if (await asyncFlowSharedLib.checkAllAwaitingStepsFinished(
-          _izContext,
-          pendingStepId,
-          awaitingStepId,
-          errorsFound
-        )) {
-          _izContext.logger.debug("finished all awaitingStep");
-
-          let updateCompleteMsg = {
-            objType: {
-              objectType: returnValue.requestParams.objType.objectType,
-              serviceTag: returnValue.requestParams.objType.serviceTag
-            },
-            objInstanceFull: {
-              identifiers: returnValue.requestParams.objInstanceFull.identifiers,
-              fields: returnValue.requestParams.objInstanceFull.fields
-            },
-            status: status,
-            errorsFound: errorsFound,
-          };
+        if (
+          await asyncFlowSharedLib.checkAllAwaitingStepsFinishedWithError(
+            _izContext,
+            pendingStepId,
+            awaitingStepId,
+            errorsFound,
+          )
+        ) {
+          _izContext.logger.debug('finished all awaitingStep');
+
+          const updateCompleteMsg = buildUpdateCompleteMsg(
+            returnValue,
+            status,
+            errorsFound,
+          );
 
           //(<additionalProperties>)
           //(</additionalProperties>)
 
-          updateCompleteMsg = callingFlowSharedLib.addParentPassBackPropertiesToSnsResponseMessageObject(passBackProperties, updateCompleteMsg);
-          _izContext.logger.debug("after addCallingFlow to SnsResponseMessageObject", updateCompleteMsg);
-
-          let messageAttributes = callingFlowSharedLib.addParentPassBackCallingFlowToSnsResponseMessageAttributes(passBackProperties, {});
-          _izContext.logger.debug("after addCallingFlow to SnsResponseMessageAttributes", updateCompleteMsg);
-
-          let sendMessageToOutUpdateNodeComplete = {
-            Message: JSON.stringify(updateCompleteMsg),
-            MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
-            TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete)
-          };
-          _izContext.logger.debug("Send Message to OutUpdateNodeComplete::", sendMessageToOutUpdateNodeComplete);
-          await sns.publishAsync(_izContext, sendMessageToOutUpdateNodeComplete)
-
+          await sendSnsMessage(_izContext, passBackProperties, updateCompleteMsg);
         }
 
         await asyncFlowSharedLib.removeAwaitingMultipleStep(
           _izContext,
           awaitingStepId,
           pendingStepId,
-          errorsFound
+          errorsFound,
         );
-      })
-    )
+      }),
+    );
 
     //(<beforeReturn>)
     //(</beforeReturn>)
 
+    const { queryResult } = returnValue;
     return {
-      objType: returnValue.queryResult.objType,
-      objInstanceFull: returnValue.queryResult.objInstanceFull,
-      errorsFound: errorsFound
-    }
-
+      objType: queryResult.objType,
+      objInstanceFull: queryResult.objInstanceFull,
+      errorsFound,
+    };
   } catch (err) {
-    _izContext.logger.error("error UpdateNodeComplete : ", err)
-    throw (err)
+    _izContext.logger.error('error UpdateNodeComplete:', err);
+    throw err;
   }
 }

package/src/generateCode/generateSchema/actionEndpointCompleteComponent/update/sns-out/data.js

@@ -57,7 +57,8 @@ function createParamsForCreateSource(_izContext, srcPath) {
       savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
       saveFileName: SAVE_FILE_NAME.snsOutYaml,
       fileExtension: '.yml',
-      isAppend: true
+      isAppend: true,
+      fromFile: 'actionEndpointCom/update/sns-out/data.js'
     }
   };
 }

package/src/generateCode/generateSchema/actionEndpointComponent/mainFunction/create/main/template.ejs

@@ -576,7 +576,7 @@ export default async function createMain(
 
         const topicArn = snsSharedLib.snsTopicArnByFlowSchema(
           _izContext,
-          ${recordMsg.flowTag}_In`
+          `${recordMsg.flowTag}_In`
         );
 
         await sns.publishAsync(_izContext, {