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

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

@@ -0,0 +1,358 @@
+/* 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, createObjType } =
+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") const { createRelTypeConcat } =
+require('@izara_project/izara-core-library-service-schemas').utils
+//(<optionalRequire>) //(</optionalRequire>) /** * * @param {*} _izContext *
+@param {Object} requestParams = {fieldNames,relationships = []} * @param {*}
+callingFlowConfig */ module.exports.createMain = async ( _izContext,
+requestParams, callingFlowConfig ) => { try { _izContext.logger.debug("function
+CreateMain:", { 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") } //(<beforeQuery>) //(</beforeQuery>) const
+objType = createObjType(requestParams.objectType); let objectSchema = await
+getObjectSchema.getObjSchemaS3WithHierarchy( _izContext, 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)) { //(<beforeValidateRelationships
+  >) //(</beforeValidateRelationships
+>) 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, [objType, relationshipProperties.targetObjType],
+getObjectRelationship.links); _izContext.logger.debug("links", links) if
+(!links.length) { errorsFound.push(`not found link between ${JSON.stringify({
+mainObjType: objType })} and ${JSON.stringify({ toObjType:
+relationshipProperties.targetObjType })} `) } for (let link of links) { const {
+serviceTag: fromServiceTag, objectType: fromObjectType } = 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
+requiredOnCreateLink = new Set(); let nonRequiredOnCreateLink = new Set(); //
+validate relationships link let objectRelationshipSchema = await
+getObjectSchema.getObjectRelationshipWithCache(_izContext, objType);
+_izContext.logger.debug("objectRelationshipSchema", objectRelationshipSchema);
+for (const objectRelLinks of objectRelationshipSchema) { if
+(objectRelLinks.relType.serviceTag === "UserAccount") { continue } const
+relRequired = objectRelLinks.base if
+(relRequired.hasOwnProperty("requiredOnCreate") && relRequired.requiredOnCreate
+=== true) { requiredOnCreateLink.add(objectRelLinks); } else if
+(relRequired.requiredOnCreate === false) {
+nonRequiredOnCreateLink.add(objectRelLinks); } else {
+errorsFound.push(`requiredOnCreate should be true or false, not found
+${objectRelLinks}`); } } _izContext.logger.debug("requiredOnCreateLink=>",
+requiredOnCreateLink); _izContext.logger.debug("nonRequiredOnCreateLink=> ",
+nonRequiredOnCreateLink); function groupLinkByRequiredOnCreate(_izContext,
+links) { let groupLink = {}; for (let link of links) { let relTypeConcat =
+createRelTypeConcat(_izContext, link.relType); if
+(!groupLink.hasOwnProperty(relTypeConcat)) { groupLink[relTypeConcat] = { from:
+[], to: [] } } if (link.base.direction === "from") {
+groupLink[relTypeConcat].from.push(link) } else if (link.other.direction ===
+"to") { groupLink[relTypeConcat].to.push(link) } } return groupLink } //**** set
+requiredOncreateLinkGroup = {RelType, Direction} **** let
+requiredOnCreateLinkGroup = groupLinkByRequiredOnCreate(_izContext,
+requiredOnCreateLink); let nonRequiredOnCreateLinkGroup =
+groupLinkByRequiredOnCreate(_izContext, nonRequiredOnCreateLink)
+_izContext.logger.debug("requiredOnCreateLinkGroup:",
+requiredOnCreateLinkGroup);
+_izContext.logger.debug("nonRequiredOnCreateLinkGroup=",
+nonRequiredOnCreateLinkGroup); // collect requiredOnCreate linkTypeIds let
+createLinkTypeIds = []; // for (const requireLink of objectRelationshipSchema) {
+function createLinkTypeIdFromLinkGroup(_izContext, links) { let
+requiredOnCreateLinkSet = new Set(); for (const [relTypeConcat,
+objectRelationshipGroup] of Object.entries(links)) { for (const objectRelFrom of
+objectRelationshipGroup.from) { requiredOnCreateLinkSet.add(createLinkTypeId(
+_izContext, objectRelFrom.base.objType, objectRelFrom.other.objType,
+objectRelFrom.relType, objectRelFrom.base.direction )) } } return
+[...requiredOnCreateLinkSet] } let requiredOnCreateLinks =
+createLinkTypeIdFromLinkGroup(_izContext, requiredOnCreateLinkGroup); let
+nonRequiredOnCreateLinks = createLinkTypeIdFromLinkGroup(_izContext,
+nonRequiredOnCreateLinkGroup) _izContext.logger.debug("requiredOnCreateLinks::",
+requiredOnCreateLinks); _izContext.logger.debug("nonRequiredOnCreateLinks::",
+nonRequiredOnCreateLinks) for (const relationship of
+requestParams?.relationships) { const onCreateLinkTypeId = createLinkTypeId(
+_izContext, objType, relationship.targetObjType, relationship.relType,
+relationship.relationshipDirection ) createLinkTypeIds.push(onCreateLinkTypeId)
+}; _izContext.logger.debug("createLinkTypeIds::", createLinkTypeIds) return //
+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
+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 objectSchemas"); }; };
+} _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("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) if (errorsFound.length == 0) { 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
+}); 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) {
+//(<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 })), 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 awaitingMultipleStep of storageType graph
+........................................................... 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! //(<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() }); 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); //(<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 awaitngMultiplestep. [[[[[[[open when not test
+lolcal.]]]]]]] 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: { 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.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) } }
+const correlationIds =
+require("@izara_project/izara-core-library-correlation-ids"); const logger =
+require("@izara_project/izara-core-library-logger"); const integrationTestDetail
+= require("@izara_project/izara-core-library-integration-tests"); const
+resourceUse = require("@izara_project/izara-core-library-resource-use"); const {
+link } = require('fs'); const izaraAttributeTree =
+require('@izara_project/izara-attribute-tree'); let _izContext = {
+correlationIds: correlationIds, logger: logger, integrationTestDetail:
+integrationTestDetail, resourceUse: resourceUse }
+_izContext.correlationIds.set(coreConsts.BASE_USER_ID, "BasDev")
+_izContext.correlationIds.set(coreConsts.TARGET_ID, "BasDevTargetId")
+this.createMain(_izContext, { "fieldNames": { "address": "585/2" },
+"relationships": [ { "relType": { "serviceTag": "GCTpBas", "relationshipTag":
+"hasHouse" }, "relationshipProperties": { "createTimestamp": 1746758956635 },
+"relationshipDirection": "to", "targetObjType": { "serviceTag": "GCTpBas",
+"objectType": "person" }, "targetIdentifiers": { "personId":
+"05b29b450a6d11ff1f79a0ea6531d32423af3260" } }, { "relType": { "serviceTag":
+"GCTpBas", "relationshipTag": "hasHouse" }, "relationshipProperties": {
+"createTimestamp": 1746758956635 }, "relationshipDirection": "to",
+"targetObjType": { "serviceTag": "GCTpBas", "objectType": "person" },
+"targetIdentifiers": { "personId": "5d3add2de5fdbd9611864fb529c5091f511e5985" }
+} ], "objectType": "house" }, "callingFlowBasDev" )

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;