@izara_project/izara-market-library-service-schemas 1.0.85 → 1.0.86

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

@@ -1,358 +0,0 @@
-/* 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/reStructure/TemplateData/EndpointPerService/mainFunction/create/data.js

@@ -1,51 +0,0 @@
-/*
-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 { utils, consts } from '../../../../../MainLibs/index.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;