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

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

@@ -0,0 +1,339 @@
+/* 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/>. */
+const dynamodbSharedLib = require('@izara_project/izara-core-library-dynamodb');
+const snsSharedLib = require('@izara_project/izara-core-library-sns'); const
+asyncFlowSharedLib =
+require('@izara_project/izara-core-library-asynchronous-flow'); const
+callingFlowSharedLib =
+require('@izara_project/izara-core-library-calling-flow'); const lambdaSharedLib
+= require('@izara_project/izara-core-library-lambda'); const externalRequest =
+require('@izara_project/izara-core-library-external-request'); const sns =
+externalRequest.sns; const lambda = externalRequest.lambda const getObjectSchema
+=
+require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
+const serviceConfigLib =
+require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig')
+const uploadUseCase =
+require('@izara_project/izara-core-library-service-schemas/src/libs/UploadUseCase')
+const hash = require('@izara_project/izara-shared-core').objectHash; const
+NoRetryError =
+require('@izara_project/izara-core-library-core/src/NoRetryError'); const path =
+require('path') const schemasPath = path.join(__dirname, '../schemas'); const
+consts =
+require('@izara_project/izara-core-library-service-schemas/src/Consts'); const
+coreConsts = require("@izara_project/izara-core-library-core/src/Consts"); const
+{ generateDynamoDbIdentifiers, dynamoDbIdentifiersByStorageResource,
+collectGetData } =
+require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs/index.js');
+const { getGraphServiceTagWithCache, getServiceNameWithCache } =
+require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig');
+//-----------------------------------------------------------------------------------------------------------
+const PREFIX = { ONE: "one", MANY: "many", CREATE_OBJECT_ASYNC:
+"createObjectAsync", CREATE_OBJECT_ASYNC_COMPLETE: "createObjectAsyncComplete" }
+//-----------------------------------------------------------------------------------------------------------
+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 { createDataDetailsLib } =
+require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs/index.js')
+const { createLinkTypeId } =
+require('@izara_project/izara-core-library-service-schemas/src/Utils'); const {
+findLinksByObjTypes } =
+require("@izara_project/izara-core-library-service-schemas/src/libs/RelSchemaLib")
+const lodash = require("lodash") /** - all storageType( DB and Graph) use
+objInstance({identifiers,fields}) - storageType[DB] async - storageType[Graph]
+sync (should be have lambda complete) -- before DB and Graph have boolend check
+(allStorageTagComplete = true) if storageType == graph set allStorageTagComplete
+= false, and save awaitingMultiplastep
+prefix(serviceTag_CreateObject{identifierId}) >>> in lambdaComplete resive
+message from GrapHandler 1.1 check have returnValue.errorsFould.length > 0 --
+Delete all awitingMultiplestep and senf message to callingFlow have errorFound.
+1.2 check awaitingmultipleStepall finish -- Delete awaitingStep in come if have
+other multiplestep(not finish)== not send message. --- if check
+awaitingmultipleStepall finish not have record ===> sendmessage to callingFlow.
+*/
+//=========================================================================================
+/** * * @param {*} _izContext * @param {Object} requestParams =
+{fieldNames,relationships = []} * @param {*} callingFlowConfig */
+module.exports.<%- functionName %>Main = async ( _izContext, requestParams,
+callingFlowConfig ) => { try { _izContext.logger.debug("function <%-
+functionName %>:", { requestParams, callingFlowConfig }); let errorsFound = [];
+const userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID); const
+targetId = _izContext.correlationIds.get(coreConsts.TARGET_ID) if (!userId) {
+errorsFound.push("Not have userId") } const OBJECT_TYPE = "<%- objectType %>";
+const SERVICE_TAG = process.env.iz_serviceTag; //(<beforeQuery
+  >) //(</beforeQuery
+>) const MAIN_OBJTYPE = { objectType: OBJECT_TYPE, serviceTag: SERVICE_TAG } let
+objectSchema = await getObjectSchema.getObjSchemaS3WithCache( _izContext,
+MAIN_OBJTYPE ); _izContext.logger.debug("objectSchema", objectSchema); let
+objectSchemas = uploadUseCase.generateObjectSchemaForCombineFieldNames(
+_izContext, objectSchema ); _izContext.logger.debug("objectSchemas",
+objectSchemas); if (objectSchema.hasOwnProperty("belongTo") && !targetId) {
+errorsFound.push('not have targetId') } let createDataDetails = await
+createDataDetailsLib(_izContext, objectSchemas);
+_izContext.logger.debug("createDataDetails is =", createDataDetails); let
+checkCorrectLinks = []; //validate linkType if
+((requestParams.hasOwnProperty("relationships")) &&
+(requestParams.relationships.length > 0)) { for (let relationshipProperties of
+requestParams.relationships) { _izContext.logger.debug("relationshipProperties",
+relationshipProperties); _izContext.logger.debug("relType",
+relationshipProperties.relType); let getObjectRelationship = await
+getObjectSchema.getRelationshipSchemaWithCache( _izContext,
+relationshipProperties.relType )
+_izContext.logger.debug("getObjectRelationship", getObjectRelationship) for
+(const relationshipLink of Object.values(getObjectRelationship.links)) { if
+(relationshipLink.from.linkType === "many" && relationshipLink.to.linkType ===
+"many") { if (relationshipLink.from.requiredOnCreate === true ||
+relationshipLink.to.requiredOnCreate === true) { errorsFound.push("error many to
+many linkType can't have requireOnCreate === true") } } } const links = await
+findLinksByObjTypes(_izContext, [MAIN_OBJTYPE,
+relationshipProperties.targetObjType], getObjectRelationship.links);
+_izContext.logger.debug("links", links) if (!links.length) {
+errorsFound.push(`not found link between ${JSON.stringify({ mainObjType:
+MAIN_OBJTYPE })} and ${JSON.stringify({ toObjType:
+relationshipProperties.targetObjType })} `) } for (let link of links) { const {
+serviceTag: fromServiceTag, objectType: fromObjectType } = MAIN_OBJTYPE; const {
+serviceTag: toServiceTag, objectType: toObjectType } =
+relationshipProperties.targetObjType const { serviceTag: firstServiceTag,
+objectType: firstObjectType } = link.from.objType; const { serviceTag:
+secondServiceTag, objectType: secondObjectType } = link.to.objType const
+matchesFromTo = fromServiceTag === firstServiceTag && fromObjectType ===
+firstObjectType && toServiceTag === secondServiceTag && toObjectType ===
+secondObjectType; const matchesToFrom = fromServiceTag === secondServiceTag &&
+fromObjectType === secondObjectType && toServiceTag === firstServiceTag &&
+toObjectType === firstObjectType if
+((relationshipProperties.relationshipDirection === "from" && matchesFromTo) ||
+(relationshipProperties.relationshipDirection === "to" && matchesToFrom)) {
+checkCorrectLinks.push(true) } else { checkCorrectLinks.push(false) } } } } for
+(const [index, checkCorrectLink] of checkCorrectLinks.entries()) { if
+(checkCorrectLink === false) { errorsFound.push(`relationship direction
+${JSON.stringify(requestParams.relationships[index])} is invalid`) } }
+_izContext.logger.debug("finish validate Relationships from RequestParams") let
+requiredOnCreateLinks = {}; let createLinkTypeIds = []; // validate
+relationships link let objectRelationshipSchema = await
+getObjectSchema.getRequiredOnCreateLinksWithCache(_izContext, MAIN_OBJTYPE);
+_izContext.logger.debug("objectRelationshipSchema", objectRelationshipSchema);
+// validate requiredOnCreateLinks let filteredRequiredOnCreatedLinks = []; await
+Promise.all( objectRelationshipSchema.map(async (requiredLink) => { const
+serviceTag = await Promise.all( requiredLink.storageResourceTags.map(async
+(storageTag) => { let storageResource =
+requiredLink.storageResources[storageTag]; if (storageResource.storageType ===
+consts.STORAGE_TYPES.graph) { return await
+getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag); } }) );
+if (serviceTag.includes(GRAPH_HANDLER_SERVICE_NAME.graphHandler)) {
+filteredRequiredOnCreatedLinks.push(requiredLink); } }) )
+_izContext.logger.debug("filteredRequiredOnCreatedLinks",
+filteredRequiredOnCreatedLinks); if (filteredRequiredOnCreatedLinks.length) { if
+(!requestParams.relationships || !requestParams.relationships.length) { // in
+case not send relationship to create with for (const requireLink of
+filteredRequiredOnCreatedLinks) { errorsFound.push(`missing required
+relationship of relType ${JSON.stringify(requireLink.relType)} when create`) } }
+for (const requireLink of filteredRequiredOnCreatedLinks) { const
+requiredOnCreateLinkTypeId = createLinkTypeId( _izContext, MAIN_OBJTYPE,
+requireLink.other.objType, requireLink.relType, requireLink.base.direction );
+Object.assign(requiredOnCreateLinks, { [requiredOnCreateLinkTypeId]: requireLink
+}) } if (requestParams.hasOwnProperty("relationships") &&
+requestParams.relationships.length) { for (const createRelationship of
+requestParams.relationships) { const onCreateLinkTypeId = createLinkTypeId(
+_izContext, MAIN_OBJTYPE, createRelationship.targetObjType,
+createRelationship.relType, createRelationship.relationshipDirection ); if
+(!requiredOnCreateLinks.hasOwnProperty(onCreateLinkTypeId)) {
+errorsFound.push(`relType:${JSON.stringify(createRelationship.relType)} not
+allow to create when use create action`) continue; } else {
+createLinkTypeIds.push(onCreateLinkTypeId); } } } } // validate missing relType
+when create that should create const remainRequiredOnCreateLinkTypeIds =
+Object.keys(requiredOnCreateLinks) .filter(requiredInCreateLinkTypeId =>
+!createLinkTypeIds.includes(requiredInCreateLinkTypeId)) if
+(remainRequiredOnCreateLinkTypeIds.length) { for (const
+remainRequiredOnCreateLinkTypeId of remainRequiredOnCreateLinkTypeIds) { const
+missingLink = { relType:
+requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].relType, base:
+requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].base.objType, other:
+requiredOnCreateLinks[remainRequiredOnCreateLinkTypeId].other.objType };
+errorsFound.push(`Missing Link:: ${JSON.stringify(missingLink)} when create`) }
+} _izContext.logger.debug("createLinkTypeIds", createLinkTypeIds);
+_izContext.logger.debug("requiredOnCreateLinks", requiredOnCreateLinks); // end
+validate let objInstanceFull = { identifiers: {}, fields: {} }; 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
+identifer:::::", identifier); if
+(objectSchemas.fieldNames[identifier.fieldName].hasOwnProperty("randomOnCreate"))
+{ if ((objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == true)) {
+Object.assign(requestParams.fieldNames, { [identifier.fieldName]: hash({
+fieldNames: identifier, // uniqueRequestId: _izContext.uniqueRequestId,
+callingFlowConfig: callingFlowConfig }) }); _izContext.logger.debug("Assign
+requestParams", requestParams) } else if
+((objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == false) ||
+(objectSchemas.fieldNames[identifier.fieldName].randomOnCreate == null)) { if
+((objectSchemas.fieldNames[identifier.fieldName].requiredOnCreate == true) &&
+(objectSchemas.fieldNames[identifier.fieldName].canUpdate == false)) { // check
+Fns have resive 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
+requriedOnCreate"); } } }; } else if
+(objectSchemas.fieldNames[identifier.fieldName].hasOwnProperty("hashOnCreate"))
+{ 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( requestParams.fieldNames, { [identifier.fieldName]: hash({
+[fieldName]: requestParams.fieldNames[fieldName] }) } ) } } else {
+errorsFound.push("[invalid] no data to hash for create") } } 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 objectSchemass"); };
+}; } _izContext.logger.debug("requestParams is:", requestParams); // check
+settingObjSchemas for (let [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("listOfRequriedOnCreate",
+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) if (errorsFound.length == 0) { for (let
+[storageTag, createDataDetail] of Object.entries(createDataDetails)) { if
+(createDataDetail.storageType == consts.STORAGE_TYPES.dynamoDB) {
+_izContext.logger.debug("::::::DynamoDB::::::", { storageTag, objInstanceFull
+}); 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 ), { ...identifiersForCreateData,
+...objInstanceFullForDynamoDb.fields } ); } 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: MAIN_OBJTYPE, graphServerTag: storageTag, identifiers:
+objInstanceFullForGraph.identifiers })), PREFIX.CREATE_OBJECT_ASYNC ));
+listOfObjectForCreates.push({ [storageTag]: { objInstanceFull: { identifiers:
+objInstanceFullForGraph.identifiers, fields: objInstanceFullForGraph.fields },
+allStorageTagComplete: false } }); _izContext.logger.debug("FIRST",
+listOfObjectForCreates) };
+_izContext.logger.debug("[1]listOfObjectForCreates:::", listOfObjectForCreates);
+}; }; function createObjInstanceFullFieldsByStorageTag(_izContext, storageTag,
+createDataDetail) {
+_izContext.logger.debug("createObjInstanceFullFieldsByStorageTag : ", {
+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] }) } } } } _izContext.logger.debug({ fields
+}) return fields } /// step save awiatingMultipleStep of storageType graph
+........................................................... await
+asyncFlowSharedLib.createAwaitingMultipleSteps( _izContext, allAwaitingStepsId,
+asyncFlowSharedLib.createPendingStepId((hash({ objType: MAIN_OBJTYPE,
+identifiers: objInstanceFull.identifiers })),
+PREFIX.CREATE_OBJECT_ASYNC_COMPLETE) );
+//............................................................................................................
+// process storageType : graph let messageObject = {}; for (let objectCreate of
+listOfObjectForCreates) { for (let [graphServiceName, objecForCreate] of
+Object.entries(objectCreate)) { _izContext.logger.debug("Loop each graph:", {
+[graphServiceName]: objecForCreate }); if (objecForCreate.allStorageTagComplete
+== false) { // needless check because in listOfObjectForCreates push case graph
+only! messageObject = { objType: MAIN_OBJTYPE, objInstanceFull:
+objecForCreate.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() }); messageObject
+= callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject( messageObject,
+callingFlowSharedLib.addParentCallingFlowConfig( callingFlowConfig, // resive
+parent callingFlowConfig. callingFlowSharedLib.createCallingFlowConfig( //
+callinfflow own service await lambdaSharedLib.lambdaFunctionName(_izContext,
+TOPIC_NAME_GENERATE_CODE.createNodeComplete), {} ) ) ); let
+messageToCreateObject = { Message: JSON.stringify(messageObject), TopicArn:
+await snsSharedLib.snsTopicArn(_izContext,
+TOPIC_NAME_GRAPH_HANDLER.inCreateNode, graphServiceName) };
+_izContext.logger.debug("RequestParams before send to sqs messageToCreateObject
+::::::: ", messageToCreateObject); await sns.publishAsync(_izContext,
+messageToCreateObject); }; }; // end loop of objectCreate. if
+(errorsFound.length > 0) { break; } }; // end loop listOfObjectForCreates if
+(errorsFound.length > 0) { _izContext.logger.debug("Case have errorFound:::",
+errorsFound); // remove awaitngMultiplestep. [[[[[[[open when not test
+lolcal.]]]]]]] await asyncFlowSharedLib.clearAllAwaitingSteps( _izContext,
+asyncFlowSharedLib.createPendingStepId((hash({ objType: MAIN_OBJTYPE,
+identifiers: objInstanceFull.identifiers })),
+PREFIX.CREATE_OBJECT_ASYNC_COMPLETE)); // pendingStepId // send message to
+OutCreateObjectComplete. //.. messageObject = { objType: MAIN_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.snsTopicArn(_izContext,
+TOPIC_NAME_GENERATE_CODE.outCreateNodeComplete) }; _izContext.logger.debug("Send
+message to OutCreateObjectComplete :::>", sendMessageOutCreateObjectComplete)
+await sns.publishAsync(_izContext, sendMessageOutCreateObjectComplete); return {
+objType: MAIN_OBJTYPE, fieldNames: requestParams.fieldNames, relationship:
+requestParams.relationships, status: "error", errorsFound: errorsFound } } else
+{ if (allAwaitingStepsId.length == 0 && listOfObjectForCreates.length == 0) {
+let messageObject = { objType: { objectType: OBJECT_TYPE, serviceTag:
+SERVICE_TAG }, 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.snsTopicArn(_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: MAIN_OBJTYPE, fieldNames:
+requestParams.fieldNames, relationship: requestParams.relationships, status:
+"complete", errorsFound: errorsFound } } } catch (err) { throw (err) } }

package/src/TemplateData/perActionEndpoint/mainFunction/delete/data.js

@@ -0,0 +1,91 @@
+/*
+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/>.
+*/
+
+const path = require('path');
+
+const {
+  ACTIONS,
+  HANDLER
+} = require('@izara_project/izara-core-library-service-schemas/src/Consts');
+// const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase, firstLetterUpperCase } = require("../#utils");
+// const { DEFAULT_HANDLER_PER_ACTION, SOURCE_PATH } = require("../#const");
+const {
+  firstLetterLowerCase: lowerCase,
+  firstLetterUpperCase: upperCase,
+  firstLetterUpperCase,
+  checkOverWriteGenerateMainFunction
+} = require('../../../../../MainLibs/src/Consts.js').utils;
+const { DEFAULT_HANDLER_PER_ACTION, SOURCE_PATH } =
+  require('../../../../../MainLibs/src/Consts.js').consts;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * receive objectSchema
+ * create data for hdrInv template
+ *
+ * @param {Object} objectSchema
+ * @return {{ templatePath, templateData, setting } }
+ */
+async function data(_izContext, objectSchema, srcPath) {
+  if (
+    objectSchema.overwriteGeneratedMainFunction?.length &&
+    objectSchema.overwriteGeneratedMainFunction.includes(ACTIONS.delete)
+  ) {
+    return [];
+  } else {
+    return [
+      await createParamForCreateSource(
+        _izContext,
+        objectSchema,
+        ACTIONS.delete,
+        srcPath
+      )
+    ];
+  }
+}
+
+async function createParamForCreateSource(
+  _izContext,
+  objectSchema,
+  action,
+  srcPath
+) {
+  // let objectType = objectSchema.objectType;
+  let objectType = objectSchema.objectType;
+  let groupBy = objectSchema?.shortNameObjectType
+    ? objectSchema.shortNameObjectType
+    : objectSchema.objectType;
+  let functionName = objectType + upperCase(action);
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName: functionName,
+      objectType: objectType,
+      roleName: groupBy,
+      action: action
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.lambdaPerAction),
+      saveFileName: `${upperCase(objectSchema.objectType)}${upperCase(action)}_Main`,
+      fileExtension: '.js',
+      isAppend: false
+    }
+  };
+}
+
+module.exports = data;

package/src/TemplateData/perActionEndpoint/mainFunction/delete/template.ejs

@@ -0,0 +1,99 @@
+/* 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/>. */
+const dynamodbSharedLib = require('@izara_project/izara-core-library-dynamodb');
+const snsSharedLib = require('@izara_project/izara-core-library-sns'); const
+asyncFlowSharedLib =
+require('@izara_project/izara-core-library-asynchronous-flow'); const
+callingFlowSharedLib =
+require('@izara_project/izara-core-library-calling-flow'); const lambdaSharedLib
+= require('@izara_project/izara-core-library-lambda'); const sns =
+require('@izara_project/izara-core-library-external-request/src/resources/Sns');
+const snsSharedLib = require('@izara_project/izara-shared/src/SnsSharedLib');
+const getObjectSchema =
+require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
+const serviceConfigLib =
+require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig')
+const uploadUseCase =
+require('@izara_project/izara-core-library-service-schemas/src/libs/UploadUseCase')
+const hash = require('@izara_project/izara-shared-core').objectHash; const
+NoRetryError =
+require('@izara_project/izara-core-library-core/src/NoRetryError'); const path =
+require('path') const schemasPath = path.join(__dirname, '../schemas'); const
+consts =
+require('@izara_project/izara-core-library-service-schemas/src/Consts'); const
+coreConsts = require("@izara_project/izara-core-library-core/src/Consts"); const
+{ generateDynamoDbIdentifiers, dynamoDbIdentifiersByStorageResource,
+collectGetData } =
+require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs/index.js');
+const { getGraphServiceTagWithCache, getServiceNameWithCache } =
+require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig');
+const { TOPIC_NAME_GENERATE_CODE, TOPIC_NAME_GRAPH_HANDLER } =
+require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/Consts')
+const { createDeleteDataDetail } =
+require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs/index.js')
+/** * * @param {*} _izContext * @param {Object} requestParams = {identifiers} *
+@param {*} callingFlowConfig */ module.exports.<%- functionName %>Main = async (
+_izContext, requestParams, callingFlowConfig ) => { try {
+_izContext.logger.debug("function:<%- functionName %>Main::" , { requestParams:
+requestParams, callingFlowConfig: callingFlowConfig }); let errorsFound = []
+const userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID); if
+(!userId){ errorsFound.push("not have userId"); } const OBJECT_TYPE = "<%-
+objectType %>"; const SERVICE_TAG = process.env.iz_serviceTag; //(<beforeQuery
+  >) //(</beforeQuery
+>) let messageAttributes; _izContext.logger.debug("messageAttributes",
+messageAttributes); let objectSchema = await
+getObjectSchema.getObjSchemaS3WithCache(_izContext, { objectType: OBJECT_TYPE,
+serviceTag: SERVICE_TAG }) _izContext.logger.debug("objectSchema", objectSchema)
+/* create deleteDataDetail that decade what storage that have to access or not
+becuase it only use identifier and dont care fieldName */ let deleteDataDetails
+= await createDeleteDataDetail(_izContext, objectSchema);
+_izContext.logger.debug("deleteDataDetails", deleteDataDetails); // validate
+objectSchema that canDelete or not if (objectSchema.canDelete === false ||
+objectSchema.canDelete == null) { errorsFound.push("this objectSchema can't
+delete") } if (errorsFound.length) { let deleteNodeCompleteMessage = { objType:
+{ objectType: OBJECT_TYPE, serviceTag: SERVICE_TAG }, identifiers:
+requestParams.identifiers, status: "error", errorsFound };
+deleteNodeCompleteMessage =
+callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig,
+deleteNodeCompleteMessage); let messageParams = { Message:
+JSON.stringify(deleteNodeCompleteMessage), MessageAttribute:
+sns.createStringMessageAttributes(_izContext, messageAttributes), TopicArn:
+await snsSharedLib.snsTopicArn(_izContext,
+TOPIC_NAME_GENERATE_CODE.deleteNodeComplete) }
+_izContext.logger.debug("messageParams OutDeleteNodeComplete::", messageParams);
+await sns.publishAsync(_izContext, messageParams); return
+deleteNodeCompleteMessage }; for await (const [storageTag, deleteDataDetail] of
+Object.entries(deleteDataDetails)) { if (deleteDataDetail.storageType ===
+consts.STORAGE_TYPES.dynamoDB) { _izContext.logger.debug("dynamoDb process") let
+identifiersForDeleteData = await dynamoDbIdentifiersByStorageResource(
+_izContext, objectSchema, deleteDataDetail, requestParams.identifiers )
+_izContext.logger.debug("identifiersForDeleteData", identifiersForDeleteData) //
+deleteItem in dynamo await dynamodbSharedLib.deleteItem(_izContext, await
+dynamodbSharedLib.tableName(_izContext, deleteDataDetail.tableName),
+identifiersForDeleteData ); } else if (deleteDataDetail.storageType ===
+consts.STORAGE_TYPES.graph) { _izContext.logger.debug("graph process") let
+deleteNodeParams = { objType: { objectType: OBJECT_TYPE, serviceTag: SERVICE_TAG
+}, identifiers: requestParams.identifiers } deleteNodeParams =
+callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(
+deleteNodeParams, callingFlowSharedLib.addParentCallingFlowConfig(
+callingFlowConfig, callingFlowSharedLib.createCallingFlowConfig( await
+lambdaSharedLib.lambdaFunctionName(_izContext,
+TOPIC_NAME_GENERATE_CODE.deleteNodeComplete), {} ) ) )
+_izContext.logger.debug("messageObject before send message: ",
+deleteNodeParams); let deleteNodeMessageBody = { Message:
+JSON.stringify(deleteNodeParams), MessageAttributes:
+sns.createStringMessageAttributes(_izContext, messageAttributes), TopicArn:
+await snsSharedLib.snsTopicArn(_izContext,
+TOPIC_NAME_GRAPH_HANDLER.inDeleteNode, storageTag) }
+_izContext.logger.debug("request message params before send to IndeleteNode::",
+deleteNodeMessageBody); let resSns = await sns.publishAsync(_izContext,
+deleteNodeMessageBody) _izContext.logger.debug('reSNS send to topic InDeleteNode
+finish', resSns) } } } catch (err) { throw (err) } } <% function
+uppercase(text){ return text.charAt(0).toUpperCase() + text.slice(1) } %>

package/src/TemplateData/perActionEndpoint/mainFunction/get/data.js

@@ -0,0 +1,92 @@
+/*
+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/>.
+*/
+
+const path = require('path');
+
+const {
+  ACTIONS,
+  HANDLER
+} = require('@izara_project/izara-core-library-service-schemas/src/Consts');
+
+// const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase, firstLetterUpperCase } = require("../#utils");
+// const { DEFAULT_HANDLER_PER_ACTION, SOURCE_PATH } = require("../#const");
+const {
+  firstLetterLowerCase: lowerCase,
+  firstLetterUpperCase: upperCase,
+  firstLetterUpperCase,
+  checkOverWriteGenerateMainFunction
+} = require('../../../../../MainLibs/src/Consts.js').utils;
+const { DEFAULT_HANDLER_PER_ACTION, SOURCE_PATH } =
+  require('../../../../../MainLibs/src/Consts.js').consts;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * receive objectSchema
+ * create data for hdrInv template
+ *
+ * @param {Object} objectSchema
+ * @return {{ templatePath, templateData, setting } }
+ */
+async function data(_izContext, objectSchema, srcPath) {
+  if (
+    objectSchema.overwriteGeneratedMainFunction?.length &&
+    objectSchema.overwriteGeneratedMainFunction.includes(ACTIONS.get)
+  ) {
+    return [];
+  } else {
+    return [
+      await createParamForCreateSource(
+        _izContext,
+        objectSchema,
+        ACTIONS.get,
+        srcPath
+      )
+    ];
+  }
+}
+
+async function createParamForCreateSource(
+  _izContext,
+  objectSchema,
+  action,
+  srcPath
+) {
+  // let objectType = objectSchema.objectType;
+  let objectType = objectSchema.objectType;
+  let groupBy = objectSchema?.shortNameObjectType
+    ? objectSchema.shortNameObjectType
+    : objectSchema.objectType;
+  let functionName = objectType + upperCase(action);
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName: functionName,
+      objectType: objectType,
+      roleName: groupBy,
+      action: action
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.lambdaPerAction),
+      saveFileName: `${upperCase(objectSchema.objectType)}${upperCase(action)}_Main`,
+      fileExtension: '.js',
+      isAppend: false
+    }
+  };
+}
+
+module.exports = data;

package/src/TemplateData/perActionEndpoint/mainFunction/get/request.json

@@ -0,0 +1,5 @@
+{
+  "getDataDetail": "object",
+  "objectType": "string",
+  "functionName": "string"
+}