@izara_project/izara-market-library-service-schemas 1.0.74 → 1.0.76

package/index.js

@@ -17,14 +17,18 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 'use strict';
 
-
-
 module.exports = {
   templateMgr: require('./src/TemplateManager'),
   sourceMgr: require('./src/SourceManager'),
   generateCodeLibs: require('./src/GenerateCodeLibs'),
   utils: require('./src/MainLibs'),
-  generateSchemaWithTemplate: require('./src/TemplateManager/src/GenerateSchema').generateSchemaWithTemplate,
-  generateCodeWithTemplate: require('./src/reStructure/GenerateCode').generateCodeWithTemplate,
-  generateSchema: require('./src/reStructure/GenerateSchema')
-}
+  generateSchemaWithTemplate:
+    require('./src/TemplateManager/src/GenerateSchema')
+      .generateSchemaWithTemplate,
+  generateCodeWithTemplate: require('./src/reStructure/GenerateCode')
+    .generateCodeWithTemplate,
+  generateSchema: require('./src/reStructure/GenerateSchema'),
+
+  // Libs
+  checkPermission: require('./src/CheckPermission/CheckPermission')
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izara_project/izara-market-library-service-schemas",
-  "version": "1.0.74",
+  "version": "1.0.76",
   "description": "Schemas for Izara Market project",
   "main": "index.js",
   "scripts": {
@@ -14,7 +14,7 @@
   "license": "AGPL-3.0-or-later",
   "homepage": "https://bitbucket.org/izara-market-libraries/izara-market-library-service-schemas/src/master/README.md",
   "devDependencies": {
-    "jest": "^30.0.5"
+    "jest": "^30.2.0"
   },
   "jest": {
     "testEnvironment": "node"
@@ -22,18 +22,20 @@
   "dependencies": {
     "@izara_project/izara-core-library-calling-flow": "^1.0.3",
     "@izara_project/izara-core-library-core": "^1.0.20",
+    "@izara_project/izara-core-library-dynamodb": "^1.0.11",
     "@izara_project/izara-core-library-external-request": "^1.0.20",
+    "@izara_project/izara-core-library-lambda": "^1.0.5",
     "@izara_project/izara-core-library-logger": "^1.0.7",
-    "@izara_project/izara-core-library-service-schemas": "^1.0.96",
+    "@izara_project/izara-core-library-service-schemas": "^1.0.100",
     "@izara_project/izara-core-library-sns": "^1.0.6",
     "@izara_project/izara-core-library-sqs": "^1.0.4",
     "@izara_project/izara-shared": "^1.0.126",
-    "@izara_project/izara-shared-service-schemas": "^1.0.31",
     "@izara_project/izara-shared-core": "^1.0.2",
+    "@izara_project/izara-shared-service-schemas": "^1.0.31",
     "ejs": "^3.1.10",
     "js-beautify": "^1.15.4",
     "lodash": "^4.17.21",
     "object-hash": "^3.0.0",
-    "yaml": "^2.8.0"
+    "yaml": "^2.8.1"
   }
 }

package/src/CheckPermission/CheckPermission.js

@@ -0,0 +1,148 @@
+/*
+Copyright (C) 2021 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+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 {
+  lambdaFunctionName
+} = require('@izara_project/izara-core-library-lambda');
+const {
+  lambda: { invokeSync }
+} = require('@izara_project/izara-core-library-external-request');
+const { consts } = require('@izara_project/izara-core-library-core');
+
+/**
+ * Checks a user's permission by invoking another Lambda function.
+ * Adheres to Izara.io backend syntax guidelines.
+ *
+ * @param {object} _izContext - The context object containing logger, credentials, etc.
+ * @param {object} payload - The data payload for the permission check.
+ * @param {string} [payload.objectType] - The type of the object (e.g., 'INVOICE'). Must be used with `action`.
+ * @param {string} [payload.action] - The action to perform (e.g., 'READ', 'APPROVE'). Must be used with `objectType`.
+ * @param {string} [payload.flowTag] - The tag for a flow-based permission check. Used instead of `objectType`/`action`.
+ * @param {string} [payload.serviceName] - The name of the calling service (optional).
+ * @returns {Promise<{status: boolean, errorFound?: string}>}
+ * Resolves with the result of the permission check:
+ * - `status`: Whether the user has permission.
+ * - `errorFound`: Optional error message if the permission check failed.
+ *
+ * @throws {Error} If the payload is invalid or Lambda invocation fails.
+ */
+async function checkPermission(_izContext, payload) {
+  // Validate that the payload object itself is provided.
+  if (!payload || typeof payload !== 'object') {
+    const error = new Error('Payload object is required.');
+    _izContext.logger.error(error.message);
+    throw error;
+  }
+
+  const userId = _izContext.correlationIds.get(consts.BASE_USER_ID);
+  const targetId = _izContext.correlationIds.get(consts.TARGET_ID);
+
+  // Validate the required 'userId' field.
+  if (!userId || typeof userId !== 'string' || userId.trim() === '') {
+    const error = new Error(
+      'userId is required and must be a non-empty string.'
+    );
+    _izContext.logger.error(error.message);
+    throw error;
+  } else {
+    payload.userId = userId;
+  }
+
+  if (targetId) {
+    payload.targetId = targetId;
+  }
+
+  // Define validation flags for business rules.
+  const hasObjectParams = payload.objectType || payload.action;
+  const hasFlowTag = payload.flowTag;
+
+  // Rule: Cannot mix object-based and flow-based parameters.
+  if (hasObjectParams && hasFlowTag) {
+    const error = new Error(
+      'Invalid payload: Cannot provide flowTag together with objectType or action.'
+    );
+    _izContext.logger.error(error.message, { payload });
+    throw error;
+  }
+
+  // Rule: If using object-based, both objectType and action are required.
+  if (hasObjectParams && (!payload.objectType || !payload.action)) {
+    const error = new Error(
+      'Invalid payload: Both objectType and action must be provided together.'
+    );
+    _izContext.logger.error(error.message, { payload });
+    throw error;
+  }
+
+  // Rule: Must provide at least one of the two valid schemas.
+  if (!hasObjectParams && !hasFlowTag) {
+    const error = new Error(
+      'Invalid payload: Must provide either (objectType and action) or flowTag.'
+    );
+    _izContext.logger.error(error.message, { payload });
+    throw error;
+  }
+
+  // Log the payload for debugging before invoking the next service.
+  _izContext.logger.debug('Checking permission with payload:', payload);
+
+  try {
+    const lambdaName = await lambdaFunctionName(
+      _izContext,
+      'CheckPermissionHdrInv',
+      'UserAccount'
+    );
+
+    const result = await invokeSync(_izContext, lambdaName, payload);
+
+    _izContext.logger.info('Permission check invoked successfully.');
+
+    // example result = { status: boolean , errorFound: string }
+    return result;
+
+  } catch (err) {
+    // Log the full error object for better traceability.
+    _izContext.logger.error(
+      'Error invoking CheckPermissionHdrInv Lambda: ',
+      err
+    );
+    throw err;
+  }
+}
+
+module.exports = {
+  checkPermission
+};

package/src/GenerateCodeLibs/src/Consts.js

@@ -26,7 +26,12 @@ const PREFIX = {
   updateNode: "updateNodeEndpoint",
   createNode: "createNodeEndpoint",
   getRel: "getRelationshipEndpoint",
-  changeRel: "changeRelationshipEndpoint"
+  changeRel: "changeRelationshipEndpoint",
+  ONE: "one",
+  MANY: "many",
+  CREATE_OBJECT_ASYNC: "createObjectAsync",
+  CREATE_OBJECT_ASYNC_COMPLETE: "createObjectAsyncComplete",
+  CREATE_OBJECT_EXTERNAL_TOPIC: "createObjectExternalTopic",
 }
 
 // const TOPIC_NAME_GRAPH_HANDLER = {
@@ -119,7 +124,6 @@ const EXTERNAL_SERVICE_NAME = {
   accountLimits: "AccountLimits"
 }
 
-
 module.exports = {
   TOPIC_NAME_GENERATE_CODE,
   TOPIC_NAME_GRAPH_HANDLER,

package/src/GenerateCodeLibs/src/GenerateCodeLibs.js

@@ -19,10 +19,7 @@ along with this program.If not, see < http://www.gnu.org/licenses/>.
 
 const lodash = require('lodash');
 const hash = require('@izara_project/izara-shared-core').objectHash;
-const snsSharedLib = require('@izara_project/izara-core-library-sns');
-const sqsSharedLib = require('@izara_project/izara-core-library-sqs');
 const inMemoryCacheLib = require('@izara_project/izara-core-library-core').inMemoryCacheLib;
-const callingFlowSharedLib = require('@izara_project/izara-core-library-calling-flow');
 const sns = require('@izara_project/izara-core-library-external-request/src/resources/Sns');
 const sqs = require('@izara_project/izara-core-library-external-request/src/resources/Sqs');
 const NoRetryError = require('@izara_project/izara-core-library-core/src/NoRetryError');
@@ -42,6 +39,20 @@ const nodeLabelRegexPattern = "^[a-zA-Z0-9_-]+(?:\:[a-zA-Z0-9_-]+)?$"
 const { validateObjType } = require('@izara_project/izara-shared-service-schemas').validateObjType;
 // const { validateObject } = require('@izara_project/izara-core-library-core').validator
 const { validateObject } = require("@izara_project/izara-core-library-core").validator
+// core libs
+const dynamodbSharedLib = require('@izara_project/izara-core-library-dynamodb');
+const asyncFlowSharedLib = require('@izara_project/izara-core-library-asynchronous-flow')
+const callingFlowSharedLib = require('@izara_project/izara-core-library-calling-flow');
+const sqsSharedLib = require('@izara_project/izara-core-library-sqs');
+const snsSharedLib = require('@izara_project/izara-core-library-sns');
+const graphSharedLibs = require('@izara_project/izara-core-library-graph-service');
+const lambdaSharedLib = require('@izara_project/izara-core-library-lambda')
+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 { PREFIX } = require('./Consts')
 
 const schemaFunctionPerAction = {
   [consts.ACTIONS.create]: validatorSchema.generateValidatorSchemaForCreate,
@@ -1090,6 +1101,348 @@ function createFieldNamesFromRequestParamsByObjectSchema(_izContext, requestPara
   return createFieldNameParams
 }
 
+async function sharedCreateEndpoint(_izContext, objType, requestParams, callingFlowConfig, settings = { userAgent: false, directInvoke: false, parentObject }) {
+  let objectSchemas = await getObjectSchema.getObjectSchemaCombineFieldNamesWithCache(_izContext, objType)
+  let createDataDetails = await createDataDetailsLib(_izContext, objectSchemas)
+  _izContext.logger.debug("createDataDetails is =", createDataDetails);
+  let listOfObjectForCreates = [];
+  let allAwaitingStepsId = [];
+
+  let objInstanceFull = {
+    identifiers: {},
+    fields: {}
+  }
+
+  for (let fieldName of Object.keys(requestParams.fieldNames)) {
+    if (objectSchemas.identifierFieldNames.includes(fieldName)) {
+      _izContext.logger.debug("identifiers is", fieldName);
+      Object.assign(objInstanceFull.identifiers, {
+        [fieldName]: requestParams.fieldNames[fieldName]
+      });
+    };
+  };
+
+  let objInstanceFullForDynamoDb = lodash.cloneDeep(objInstanceFull);
+  let objInstanceFullForGraph = lodash.cloneDeep(objInstanceFull);
+  let objInstanceFullForExternalTopic = lodash.cloneDeep(objInstanceFull);
+
+  for (const [storageTag, createDataDetail] of Object.entries(createDataDetails)) {
+    if (createDataDetail.storageType == consts.STORAGE_TYPES.dynamoDB) {
+      _izContext.logger.debug("::::::DynamoDB::::::", { storageTag, objInstanceFull });
+
+      if (settings.parentObject) {
+        if (createDataDetail.tableName.includes(firstLetterUpperCase(`${parentObject.objectType}Records`))) {
+          Object.assign(
+            objInstanceFullForDynamoDb.fields, {
+            [`${settings.parentObject.objectType}HandlerServiceTag`]: process.env.iz_serviceTag
+          })
+        }
+      }
+
+      Object.assign(objInstanceFullForDynamoDb.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
+      _izContext.logger.debug("objInstanceFull before create item in dynamoDB", objInstanceFullForDynamoDb)
+
+      let identifiersForCreateData = await dynamoDbIdentifiersByStorageResource(
+        _izContext,
+        objectSchemas,
+        createDataDetail,
+        objInstanceFullForDynamoDb.identifiers
+      )
+      _izContext.logger.debug("identifiersForCreateData", identifiersForCreateData);
+
+      await dynamodbSharedLib.putItem(
+        _izContext,
+        await dynamodbSharedLib.tableName(
+          _izContext,
+          createDataDetail.tableName,
+          createDataDetail.serviceTag
+        ),
+        {
+          ...identifiersForCreateData,
+          ...objInstanceFullForDynamoDb.fields
+        }
+      );
+
+      objInstanceFullForDynamoDb.fields = {} // prevent using fieldNames from other tableName
+      if (allAwaitingStepsId.length == 0) {
+        let messageObject = {
+          objType: objType,
+          objInstanceFull: {
+            identifiers: objInstanceFullForDynamoDb.identifiers,
+            fields: objInstanceFullForDynamoDb.fields
+          }
+        }
+
+        if (callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOW_PROPERTYNAME]) {
+          // send message to SNS OutCreateNodeComplete
+          _izContext.logger.debug("HAVE CallingFlow");
+          messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
+
+          let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+          let outCreateNodeCompleteTopic = await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete)
+          let messageParams = {
+            Message: JSON.stringify(messageObject),
+            MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+            TopicArn: outCreateNodeCompleteTopic,
+          };
+
+          _izContext.logger.debug("messageParams OutCreateNode ::::::: ", messageParams);
+          await sns.publishAsync(_izContext, messageParams);
+        }
+        return {
+          objType: objType,
+          objInstanceFull: objInstanceFullForDynamoDb,
+          relationships: requestParams.relationships || [],
+          status: "complete",
+          errorsFound: []
+        }
+      }
+
+    } else if (createDataDetail.storageType == consts.STORAGE_TYPES.graph) {
+      _izContext.logger.debug("::::::Graph::::::", { storageTag, objInstanceFull });
+
+      Object.assign(objInstanceFullForGraph.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
+      _izContext.logger.debug("objInstanceFull before send to Graph", objInstanceFullForGraph)
+
+      // allStorageTagComplete = false;
+      allAwaitingStepsId.push(await asyncFlowSharedLib.createAwaitingStepId(
+        (hash({
+          objType: objType,
+          graphServerTag: storageTag,
+          identifiers: objInstanceFullForGraph.identifiers,
+          callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
+        })),
+        PREFIX.CREATE_OBJECT_ASYNC
+      ));
+      listOfObjectForCreates.push({
+        [storageTag]: {
+          objInstanceFull: {
+            identifiers: objInstanceFullForGraph.identifiers,
+            fields: objInstanceFullForGraph.fields
+          },
+          allStorageTagComplete: false
+        }
+      });
+
+      _izContext.logger.debug("FIRST", listOfObjectForCreates)
+
+    } else if (createDataDetail.storageType === consts.STORAGE_TYPES.externalTopic) {
+      _izContext.logger.debug("::::::externalTopic::::::", { storageTag, createDataDetail });
+      Object.assign(objInstanceFullForExternalTopic.fields, createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail))
+      _izContext.logger.debug("objInstanceFull before send to external topic", objInstanceFullForExternalTopic)
+
+      allAwaitingStepsId.push(await asyncFlowSharedLib.createAwaitingStepId(
+        (hash({
+          objType: objType,
+          graphServerTag: storageTag,
+          identifiers: objInstanceFullForGraph.identifiers,
+          callingFlowProperties: callingFlowConfig.callingFlowProperties || {}
+        })),
+        PREFIX.CREATE_OBJECT_EXTERNAL_TOPIC
+      ));
+
+      let sendToCreateExternalTopic = {
+        Message: JSON.stringify({ objType, objInstanceFull: objInstanceFullForExternalTopic, relationships: requestParams.relationships }),
+        TopicArn: `arn:aws:sns:${createDataDetail.region}:${createDataDetail.accountId}:${createDataDetail.serviceTag}_${createDataDetail.stage}_Create_In`
+      };
+      _izContext.logger.debug("Request params before send to create endpoint:", sendToCreateExternalTopic);
+
+      await sns.publishAsync(_izContext, sendToCreateExternalTopic)
+      return sendToCreateExternalTopic
+    }
+  };
+  _izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
+
+  /// step save awaitingMultipleStep of storageType graph ...........................................................
+  if (!settings.userAgent) {
+    _izContext.logger.debug("not api will create awaitingStep")
+    await asyncFlowSharedLib.createAwaitingMultipleSteps(
+      _izContext,
+      allAwaitingStepsId,
+      asyncFlowSharedLib.createPendingStepId((hash({ objType: objType, identifiers: objInstanceFull.identifiers })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)
+    );
+  }
+  //............................................................................................................
+
+  // process storageType : graph
+  let messageObject = {};
+  for (let objectCreate of listOfObjectForCreates) {
+
+    for (let [graphServiceName, objectForCreate] of Object.entries(objectCreate)) {
+      _izContext.logger.debug("Loop each graph:", {
+        [graphServiceName]: objectForCreate
+      });
+
+      if (objectForCreate.allStorageTagComplete == false) { // needless check because in listOfObjectForCreates push case graph  only!
+        messageObject = {
+          objType: objType,
+          objInstanceFull: objectForCreate.objInstanceFull,
+          relationships: requestParams.relationships || []
+        };
+      };
+
+      _izContext.logger.debug("SENT MESSAGE EACH GRAPH::::", { graphServiceName, messageObject, callingFlowConfig })
+
+      Object.assign(messageObject, {
+        settings: { updatePropertiesOnMatch: false },
+        originTimestamp: Date.now(),
+      });
+      if (settings.userAgent) {
+        _izContext.logger.debug("have userAgent will invoke GraphHandler")
+        let createNodeResult = await graphSharedLibs.createNodeV2(
+          _izContext,
+          graphServiceName,
+          objType,
+          objInstanceFullForGraph,
+          requestParams.relationships || [],
+          Date.now(),
+          {
+            updatePropertiesOnMatch: false
+          }
+        )
+        return createNodeResult
+
+      } else if (settings.directInvoke) {
+        _izContext.logger.debug("Direction Invoke case will invoke GraphHandlerInv")
+        let createNodeResult = await graphSharedLibs.createNodeV2(
+          _izContext,
+          graphServiceName,
+          objType,
+          objInstanceFullForGraph,
+          requestParams.relationships,
+          Date.now(),
+          {
+            updatePropertiesOnMatch: false
+          }
+        );
+
+        return createNodeResult;
+      } else {
+        _izContext.logger.debug("not have userAgent will send Message to GraphHandler")
+        messageObject = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+          messageObject,
+          callingFlowSharedLib.addParentCallingFlowConfig(
+            callingFlowConfig, // receive parent callingFlowConfig.
+            callingFlowSharedLib.createCallingFlowConfig( // calling flow own service
+              await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.createNodeComplete), {}
+            )
+          )
+        );
+
+        let messageToCreateObject = {
+          Message: JSON.stringify(messageObject),
+          TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GRAPH_HANDLER.inCreateNode, graphServiceName)
+        };
+        _izContext.logger.debug("RequestParams before send to sqs messageToCreateObject ::::::: ", messageToCreateObject);
+        await sns.publishAsync(_izContext, messageToCreateObject);
+
+        return messageObject
+      }
+    };
+  };
+
+  function createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, createDataDetail) {
+    let fields = {};
+    for (let fieldName of Object.keys(requestParams.fieldNames)) {
+      if ((createDataDetails[storageTag].fieldNames.includes(fieldName)) &&
+        (createDataDetail.fieldNames.includes(fieldName))) {
+        if (!objInstanceFull.identifiers.hasOwnProperty(fieldName)) {
+          if (!fields.hasOwnProperty(fieldName)) {
+            Object.assign(fields, {
+              [fieldName]: requestParams.fieldNames[fieldName]
+            })
+          }
+        }
+      }
+    }
+    return fields
+  }
+}
+
+async function sharedCreateCompleteEndpoint(_izContext, returnValue, status, errorsFound, graphServiceTag, passBackProperties) {
+  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
+    }
+  }
+
+  let awaitingStepId = await asyncFlowSharedLib.createAwaitingStepId(
+    (hash({
+      objType: returnValue.requestParams.objType,
+      graphServerTag: graphServiceTag,
+      identifiers: returnValue.requestParams.objInstanceFull.identifiers,
+      callingFlowProperties: passBackProperties.passBackProperties.parentPassBackProperties.callingFlowProperties || {}
+    })),
+    PREFIX.CREATE_OBJECT_ASYNC
+  )
+  _izContext.logger.debug("awaitingStepId:", awaitingStepId);
+
+  let recordAwaitingSteps = await dynamodbSharedLib.query(
+    _izContext,
+    await dynamodbSharedLib.tableName(_izContext, "AwaitingMultipleSteps"),
+    {
+      awaitingStepId: awaitingStepId
+    }
+  );
+  _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
+        }
+
+        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 asyncFlowSharedLib.removeAwaitingMultipleStep(
+        _izContext,
+        awaitingStepId,
+        pendingStepId,
+        errorsFound
+      );
+
+    })
+  )
+
+  return {
+    returnValue: returnValue,
+    status: status,
+    errorsFound: errorsFound
+  }
+}
+
 module.exports = {
   sendMsgOutComplete,
   messageToDlq,
@@ -1110,7 +1463,9 @@ module.exports = {
 
   createFieldForUpdateDynamoDb,
   createBasicRelationshipsProperties,
-  createFieldNamesFromRequestParamsByObjectSchema
+  createFieldNamesFromRequestParamsByObjectSchema,
+  sharedCreateEndpoint,
+  sharedCreateCompleteEndpoint
 }
 
 

package/src/reStructure/TemplateData/EndpointPerService/mainFunction/get/template.ejs

@@ -106,16 +106,18 @@ module.exports.getMain = async (
     let throwWhenNotFoundSomeRecord = true;
     let returnVersionedData = true;
 
-    if (requestParams.additionalParams.hasOwnProperty("settings")) {
-      if (requestParams.additionalParams.settings.hasOwnProperty("returnSystemFieldsName") && requestParams.additionalParams.settings.returnSystemFieldsName === true) {
-        returnSystemFieldsName = true;
-      }
-      if (requestParams.additionalParams.settings.hasOwnProperty("throwWhenNotFoundSomeRecord") && requestParams.additionalParams.settings.throwWhenNotFoundSomeRecord === false) {
-        throwWhenNotFoundSomeRecord = false;
-      }
-      if (requestParams.additionalParams.settings.hasOwnProperty("returnVersionedData") && requestParams.additionalParams.settings.returnVersionedData === false) {
-        returnVersionedData = false;
-      }
+    if (requestParams.hasOwnProperty("additionalParams")) {
+      if (requestParams.additionalParams.hasOwnProperty("settings")) {
+        if (requestParams.additionalParams.settings.hasOwnProperty("returnSystemFieldsName") && requestParams.additionalParams.settings.returnSystemFieldsName === true) {
+          returnSystemFieldsName = true;
+        };
+        if (requestParams.additionalParams.settings.hasOwnProperty("throwWhenNotFoundSomeRecord") && requestParams.additionalParams.settings.throwWhenNotFoundSomeRecord === false) {
+          throwWhenNotFoundSomeRecord = false;
+        };
+        if (requestParams.additionalParams.settings.hasOwnProperty("returnVersionedData") && requestParams.additionalParams.settings.returnVersionedData === false) {
+          returnVersionedData = false;
+        };
+      };
     };
 
     //(<beforeQuery>)

package/src/reStructure/TemplateData/EndpointPerService/mainFunction/update/template.ejs

@@ -91,15 +91,18 @@ module.exports.updateMain = async (
     let returnSystemFieldsName = false;
     let returnOldData = false;
 
-    if (requestParams.additionalParams.hasOwnProperty("settings")) {
-      if (requestParams.additionalParams.settings.hasOwnProperty("returnSystemFieldsName") && requestParams.additionalParams.settings.returnSystemFieldsName === true) {
-        returnSystemFieldsName = true;
-      }
-      if (requestParams.additionalParams.settings.hasOwnProperty("returnOldData") && requestParams.additionalParams.settings.returnOldData === true) {
-        returnOldData = true;
-      }
+    if (requestParams.hasOwnProperty("additionalParams")) {
+      if (requestParams.additionalParams.hasOwnProperty("settings")) {
+        if (requestParams.additionalParams.settings.hasOwnProperty("returnSystemFieldsName") && requestParams.additionalParams.settings.returnSystemFieldsName === true) {
+          returnSystemFieldsName = true;
+        }
+        if (requestParams.additionalParams.settings.hasOwnProperty("returnOldData") && requestParams.additionalParams.settings.returnOldData === true) {
+          returnOldData = true;
+        }
+      };
     };
 
+
     let errorsFound = [];
 
     const objType = createObjType(requestParams.objectType);