@izara_project/izara-core-generate-service-code 1.0.1 → 1.0.3

package/src/TemplateData/EndpointPerService/mainFunction/create/data.js

@@ -0,0 +1,51 @@
+/*
+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/>.
+*/
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import consts from '../../../../libs/Consts.js';
+import utils from '../../../../libs/Utils.js';
+const { ACTIONS, SOURCE_PATH } = consts;
+const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = utils;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+function data(_izContext, srcPath) {
+  return [createSource(_izContext, srcPath)];
+}
+
+function createSource(_izContext, srcPath) {
+  let functionName = upperCase(ACTIONS.create);
+
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.endpointPerService),
+      saveFileName: `${upperCase(functionName)}_Main`,
+      fileExtension: '.js',
+      isAppend: false
+    }
+  };
+}
+
+export default data;

package/src/TemplateData/EndpointPerService/mainFunction/create/template.ejs

@@ -0,0 +1,616 @@
+/*
+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/>.
+*/
+
+// ──────────────────────── Core Node Modules ────────────────────────
+import lodash from "lodash";
+
+// ──────────────────────── Shared Core Libraries ────────────────────────
+import { objectHash as hash } from '@izara_project/izara-shared-core';
+
+// ──────────────────────── Izara Core Libraries ────────────────────────
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+import { consts as coreConsts } from '@izara_project/izara-core-library-core';
+import identifierLib from '@izara_project/izara-core-library-identifiers';
+const { createRandomIdentifier } = identifierLib
+
+// ──────────────────────── Middleware / External ────────────────────────
+import { consts as middlewareConsts } from '@izara_project/izara-middleware';
+import { sns } from '@izara_project/izara-core-library-external-request';
+
+
+// ──────────────────────── Service Schemas ────────────────────────
+import { utils, createNodeLib, uploadUseCase, consts, getObjectSchema, identifiersObject, dataDetailsLib } from '@izara_project/izara-core-library-service-schemas';
+const { createObjType } = utils
+const { createDataDetailsLib } = dataDetailsLib
+const { dynamoDbIdentifiersByStorageResource } = identifiersObject
+// ──────────────────────── Graph Service Libraries ────────────────────────
+import graphSharedLibs from '@izara_project/izara-core-library-graph-service';
+
+// ──────────────────────── Market Library Service Schemas ────────────────────────
+import { consts as generateCodeConsts, utils as generateCodeUtils } from '@izara_project/izara-core-generate-service-code';
+
+const {
+  TOPIC_NAME_GENERATE_CODE,
+  TOPIC_NAME_GRAPH_HANDLER
+} = generateCodeConsts;
+
+const { firstLetterUpperCase } = generateCodeUtils;
+
+//(<optionalRequire>)
+//(</optionalRequire>)
+
+//-----------------------------------------------------------------------------------------------------------
+const PREFIX = {
+  ONE: "one",
+  MANY: "many",
+  CREATE_OBJECT_ASYNC: "createObjectAsync",
+  CREATE_OBJECT_ASYNC_COMPLETE: "createObjectAsyncComplete",
+  CREATE_OBJECT_EXTERNAL_TOPIC: "createObjectExternalTopic"
+}
+//-----------------------------------------------------------------------------------------------------------
+
+/**
+ *
+ * @param {*} _izContext
+ * @param {Object} requestParams = {fieldNames,relationships = []}
+ * @param {*} callingFlowConfig
+ */
+
+export default async function createMain(
+  _izContext,
+  requestParams,
+  //(<additionalParams>)
+  //(</additionalParams>)
+  callingFlowConfig = {}
+) {
+  try {
+    _izContext.logger.debug("function CreateMain:", {
+      requestParams,
+      callingFlowConfig
+    });
+
+    let errorsFound = [];
+
+    const objType = createObjType(requestParams.objectType);
+
+    let objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
+      _izContext,
+      objType,
+    );
+    _izContext.logger.debug("objectSchema", objectSchema);
+
+    let userId;
+    let targetId;
+    if (objectSchema.generatedBy === "userGenerated") {
+      userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID);
+      targetId = _izContext.correlationIds.get(coreConsts.TARGET_ID)
+
+      if (!userId) {
+        errorsFound.push("Not have userId")
+      }
+
+      if (objectSchema.hasOwnProperty("belongTo") && !targetId) {
+        errorsFound.push('not have targetId')
+      }
+    }
+
+    //(<beforeQuery>)
+    //(</beforeQuery>)
+
+
+    let objectSchemas = uploadUseCase.generateObjectSchemaForCombineFieldNames(
+      _izContext,
+      objectSchema
+    );
+    _izContext.logger.debug("objectSchemas", objectSchemas);
+
+    let parentObject
+    if (objectSchemas.hasOwnProperty("extendObjType")) {
+      parentObject = await getObjectSchema.getObjSchemaS3WithHierarchy(_izContext, objectSchema.extendObjType)
+    }
+
+    let userAgent = false;
+    let directInvoke = false;
+    if (_izContext.correlationIds.get(middlewareConsts.USER_AGENT)) {
+      userAgent = true;
+    } else if (requestParams.hasOwnProperty("__context__") && requestParams.izEventSource.eventSourceTag === "DirectInvoke") {
+      directInvoke = true;
+    }
+
+    let createDataDetails = await createDataDetailsLib(
+      _izContext,
+      objectSchemas,
+    );
+    _izContext.logger.debug("createDataDetails is =", createDataDetails);
+
+
+    if ((requestParams.hasOwnProperty("relationships")) && (requestParams.relationships.length > 0)) {
+      //(<beforeValidateRelationships>)
+      //(</beforeValidateRelationships>)
+    }
+    errorsFound.push(
+      ...await createNodeLib.validateRequiredOnCreateLinks(
+        _izContext,
+        objType,
+        requestParams.relationships,
+      )
+    )
+    _izContext.logger.debug("errorsFound", errorsFound)
+
+    // end validate
+    let objInstanceFull = {
+      identifiers: {},
+      fields: {}
+    };
+
+    //(<optionalObjInstanceFull>)
+    //(</optionalObjInstanceFull>)
+
+    let listOfRequiredOnCreate = [];
+    let listOfOptionalOnCreate = [];
+
+    let allAwaitingStepsId = [];
+
+    // validate single identifiers
+    if (objectSchemas.identifiers.length === 1 && !objectSchemas.identifiers[0].hasOwnProperty("fieldNames")) {
+
+      const identifier = objectSchemas.identifiers[0];
+      _izContext.logger.debug(":::::case single identifier:::::", identifier);
+
+      if (objectSchemas.fieldNames[identifier.fieldName].hasOwnProperty("randomOnCreate") && (objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == true)) {
+        Object.assign(
+          requestParams.fieldNames, {
+          [identifier.fieldName]: await createRandomIdentifier(
+            _izContext,
+            objType
+          )
+        });
+        _izContext.logger.debug("Assign requestParams", requestParams)
+      } else if (objectSchemas.fieldNames[identifier.fieldName].hasOwnProperty("hashOnCreate")) {
+        let hashFieldName = {}
+        if (objectSchemas.fieldNames[identifier.fieldName].hashOnCreate.length &&
+          objectSchemas.fieldNames[identifier.fieldName].hashOnCreate.length > 0) {
+          for (const fieldName of objectSchemas.fieldNames[identifier.fieldName].hashOnCreate) {
+            Object.assign(hashFieldName, {
+              [fieldName]: requestParams.fieldNames[fieldName]
+            })
+          }
+
+          Object.assign(
+            requestParams.fieldNames, {
+            [identifier.fieldName]: hash(hashFieldName)
+          }
+          )
+
+        } else {
+          errorsFound.push("[invalid] no data to hash for create")
+        }
+      } else if (objectSchemas.fieldNames[identifier.fieldName].hasOwnProperty("optionalOnCreate")) {
+        if ((objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate == true)) {
+          //(<createOptionalOnCreateIdentifiers>)
+          let optionalOnCreateIdentifiers
+          //(</createOptionalOnCreateIdentifiers>)
+          Object.assign(
+            requestParams.fieldNames, {
+            [identifier.fieldName]: hash(optionalOnCreateIdentifiers)
+          }
+          )
+        }
+      } else if (objectSchemas.fieldNames[identifier.fieldName].hasOwnProperty("randomOnCreate") && objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == false ||
+        objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == null) {
+
+        if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate == true) &&
+          (objectSchemas.fieldNames[identifier.fieldName].canUpdate == false)) {
+          // check Fns have receive
+
+          if (requestParams.fieldNames.hasOwnProperty([identifier.fieldName])) {
+            _izContext.logger.debug("identifier is exist:", {
+              [identifier.fieldName]: requestParams.fieldNames[identifier.fieldName]
+            });
+
+          } else {
+            errorsFound.push("[invalid]requestParams not have data fieldNames of requiredOnCreate");
+          }
+        }
+      } else {
+        if ((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate === false) &&
+          (objectSchemas.fieldNames[identifier.fieldName].optionalOnCreate === false) &&
+          (objectSchemas.fieldNames[identifier.fieldName].canUpdate === false) &&
+          objectSchemas.fieldNames[identifier.fieldName].hashOnCreate === false) {
+          errorsFound.push("[invalid]case single identifier invalid objectSchemas");
+        };
+      };
+    }
+
+    _izContext.logger.debug("requestParams is:", requestParams);
+
+    // check settingObjSchemas
+    for (const [keyFieldNames, valueFieldNames] of Object.entries(objectSchemas.fieldNames)) {
+
+      if (valueFieldNames.hasOwnProperty("randomOnCreate") && valueFieldNames.randomOnCreate === true) {
+        listOfRequiredOnCreate.push(keyFieldNames)
+      };
+
+      if (valueFieldNames.hasOwnProperty("requiredOnCreate") && valueFieldNames.requiredOnCreate === true) {
+        listOfRequiredOnCreate.push(keyFieldNames)
+      };
+
+      if (valueFieldNames.hasOwnProperty("hashOnCreate") && valueFieldNames.hashOnCreate.length) {
+        listOfRequiredOnCreate.push(keyFieldNames)
+      }
+
+      if (valueFieldNames.hasOwnProperty("optionalOnCreate") && valueFieldNames.optionalOnCreate === true) {
+        if ((valueFieldNames.requiredOnCreate === false) && valueFieldNames.optionalOnCreate === true) {
+          listOfOptionalOnCreate.push(keyFieldNames)
+        };
+      };
+
+    }; // end iteration of fieldNames
+
+    _izContext.logger.debug("listOfRequiredOnCreate", listOfRequiredOnCreate);
+    _izContext.logger.debug("listOfOptionalOnCreate", listOfOptionalOnCreate);
+    for (let fieldName of Object.keys(requestParams.fieldNames)) {
+
+      if (!listOfRequiredOnCreate.includes(fieldName)) {
+        if (!listOfOptionalOnCreate.includes(fieldName)) {
+          errorsFound.push("[invalid] over fieldNames create object");
+        }
+      };
+
+      if (listOfOptionalOnCreate.length > 0 && listOfRequiredOnCreate.includes(fieldName)) {
+        //(<optionalParams>)
+        //(</optionalParams>)
+      };
+
+      if (objectSchemas.identifierFieldNames.includes(fieldName)) {
+        _izContext.logger.debug("identifiers is", fieldName);
+        Object.assign(objInstanceFull.identifiers, {
+          [fieldName]: requestParams.fieldNames[fieldName]
+        });
+      };
+
+      if (errorsFound.length > 0) {
+        _izContext.logger.debug("HaveError::", errorsFound);
+        break
+      };
+
+    }; // end loop
+
+    let listOfObjectForCreates = [];
+
+    let objInstanceFullForDynamoDb = lodash.cloneDeep(objInstanceFull);
+    let objInstanceFullForGraph = lodash.cloneDeep(objInstanceFull);
+    let objInstanceFullForExternalTopic = lodash.cloneDeep(objInstanceFull);
+
+    if (errorsFound.length == 0) {
+      //(<validateBeforeCreate>)
+      //(</validateBeforeCreate>)
+      for (let [storageTag, createDataDetail] of Object.entries(createDataDetails)) {
+        //(<beforeCreate>)
+        //(</beforeCreate>)
+        if (createDataDetail.storageType == consts.STORAGE_TYPES.dynamoDB) {
+          //(<beforeCreateRecordDynamo>)
+          //(</beforeCreateRecordDynamo>)
+          _izContext.logger.debug("::::::DynamoDB::::::", { storageTag, objInstanceFull });
+
+          if (parentObject) {
+            if (createDataDetail.tableName.includes(firstLetterUpperCase(`${parentObject.objectType}Records`))) {
+              Object.assign(
+                objInstanceFullForDynamoDb.fields, {
+                [`${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,
+            objectSchema,
+            createDataDetails,
+            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
+
+          //(<afterCreateRecordDynamo>)
+          //(</afterCreateRecordDynamo>)
+        } else if (createDataDetail.storageType == consts.STORAGE_TYPES.graph) {
+          //(<beforeCreateNode>)
+          //(</beforeCreateNode>)
+          _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
+          ),
+            //(<additionalAttributeCreateObjectAsync>)
+            //(</additionalAttributeCreateObjectAsync>)
+          );
+          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 });
+          //(<beforeSendMessageToExternalTopic>)
+          //(</beforeSendMessageToExternalTopic>)
+          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
+          ),
+            //(<additionalAttributeCreateExternalObjectAsync>)
+            //(</additionalAttributeCreateExternalObjectAsync>)
+          );
+
+          let sendToCreateExternalTopic = {
+            Message: JSON.stringify(objInstanceFullForExternalTopic),
+            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)
+        }
+      };
+      _izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
+    };
+
+    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
+    }
+    /// step save awaitingMultipleStep of storageType graph ...........................................................
+    if (!userAgent) {
+      _izContext.logger.debug("not api will create awaitingStep")
+      await asyncFlowSharedLib.createAwaitingMultipleStepsWithAdditionalAttributes(
+        _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!
+          //(<beforeSendMessageToGraph>)
+          //(</beforeSendMessageToGraph>)
+          messageObject = {
+            objType: objType,
+            objInstanceFull: objectForCreate.objInstanceFull,
+            relationships: requestParams.relationships || []
+          };
+        };
+
+        if (errorsFound.length > 0) {
+          break;
+        } else {
+          _izContext.logger.debug("SENT MESSAGE EACH GRAPH::::", { graphServiceName, messageObject, callingFlowConfig })
+
+          Object.assign(messageObject, {
+            settings: { updatePropertiesOnMatch: false },
+            originTimestamp: Date.now(),
+          });
+          if (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 (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
+                  //(<callingFlowProperties>)
+                  await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.createNodeComplete), {}
+                  //(</callingFlowProperties>)
+                )
+              )
+            );
+
+            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);
+          }
+
+          //(<afterSendMessageToGraph>)
+          //(</afterSendMessageToGraph>)
+          return {
+            objType: objType,
+            objInstanceFull: objInstanceFullForGraph,
+            relationships: requestParams.relationships || [],
+            status: "complete",
+            errorsFound: errorsFound
+          }
+        };
+      }; // end loop of objectCreate.
+      if (errorsFound.length > 0) {
+        break;
+      }
+    }; // end loop listOfObjectForCreates
+
+    if (errorsFound.length > 0) {
+      _izContext.logger.debug("Case have errorFound:::", errorsFound);
+
+      // remove awaitingMultipleStep. [[[[[[[open when not test local.]]]]]]]
+      await asyncFlowSharedLib.clearAllAwaitingSteps(
+        _izContext,
+        asyncFlowSharedLib.createPendingStepId((hash({
+          objType: objType,
+          identifiers: objInstanceFull.identifiers
+        })), PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)); // pendingStepId
+
+      // send message to OutCreateObjectComplete.
+      //..
+      messageObject = {
+        objType: objType,
+        identifiers: null, // or {}
+        errorsFound: errorsFound
+      };
+
+      //  pass back property.
+      messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
+      let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+
+      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);
+
+      return {
+        objType: objType,
+        objInstanceFull: objInstanceFull,
+        relationships: requestParams.relationships || [],
+        status: "error",
+        errorsFound: errorsFound
+      }
+    } else {
+
+      if (allAwaitingStepsId.length == 0 && listOfObjectForCreates.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: errorsFound
+      }
+    }
+  } catch (err) {
+    throw (err)
+  }
+}