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

package/src/GenerateSchema.js

@@ -1,164 +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 { join } from 'path';
-import { readFileSync } from 'fs';
-
-import { validatePathWithRootServicePath } from './libs/GenerateCodeLibs.js';
-
-import { schemaConfig } from './SchemaConfig.js';
-
-// SourceManager
-import { utils, createSource } from '../../izara-market-library-service-schemas/src/SourceManager/index.js';
-const { deleteFileInDir } = utils;
-
-async function generateSchema(
-  _izContext,
-  objSchemaPath,
-  generateSchemaSettings
-) {
-  try {
-    // console.log('generateSchema', { objSchemaPath, generateSchemaSettings });
-    // ---------  Prepare path  -------------
-    // point to app/src
-    let saveFilePath = join(objSchemaPath, `../`);
-    // console.log("saveFilePath: ", saveFilePath);
-
-    // point to root folder of service
-    let localServicePath = join(saveFilePath, '../../');
-    // console.log("localServicePath: ", localServicePath);
-
-    //------ Start Create Source ------
-
-    // collect all result of template data for execute createSource
-    let allCreateSource = [];
-    // collect all path that need to empty before createSource
-    let allEmptyPath = new Set();
-
-    // Validate that all generateNames in generateSettings are present in the schemaConfig
-    const generateNameSet = new Set(Object.keys(schemaConfig.TemplateAndData));
-
-    // Find any missing generateNames that are not in the schemaConfig
-    let missingGenerateName = generateSchemaSettings.filter(
-      ({ generateName }) => !generateNameSet.has(generateName)
-    );
-
-    // If there are missing generateNames, throw an error with the list of missing names
-    if (missingGenerateName.length) {
-      throw Error(
-        `Invalid generateName:[ ${missingGenerateName.map(({ generateName }) => generateName).join(', ')} ]`
-      );
-    }
-
-    // start create generateSchema depend on
-    for (const generateSetting of generateSchemaSettings) {
-      console.log('Loading template:', generateSetting.generateName);
-      console.log('Setting data:', generateSetting);
-      // console.log('schemaPath:', schemaConfig.TemplateAndData[generateSetting.generateName]);
-      // console.log('schemaPath:', join(__dirname, schemaConfig.TemplateAndData[generateSetting.generateName]));
-
-      // get generateSchema template depend on generateName
-      let generateSchemaData = (
-        await import(
-          join(
-            __dirname,
-            schemaConfig.TemplateAndData[generateSetting.generateName]
-          )
-        )
-      ).default;
-      // sources[eventSourceTag] = await import(`../MiddlewareCore/EventSources/${eventSourceTag}.js`);
-      let createSourceResult = await generateSchemaData(
-        _izContext,
-        objSchemaPath,
-        generateSchemaSettings
-      );
-
-      // Filter out empty or invalid objects before adding to allCreateSource
-      if (Array.isArray(createSourceResult)) {
-        const validResults = createSourceResult.filter(
-          item => item && item.templatePath && item.templateData && item.setting
-        );
-        allCreateSource.push(...validResults);
-      }
-    }
-
-    // check each allCreateSource valid
-    for (let item of allCreateSource) {
-      // throw Error('Skipping invalid source item:', item);
-      if (!item || !item.templatePath || !item.templateData || !item.setting) {
-        console.log('throw Error Skipping invalid source item:', item);
-        throw Error('Skipping invalid source item:', item);
-      }
-
-      const {
-        templatePath,
-        templateData,
-        setting,
-        emptyPath: returnEmptyPath
-      } = item;
-      setting.checkCreateSourcePass = true;
-
-      let [status, errors] = await createSource.createSource(
-        readFileSync(templatePath, 'utf8'),
-        templateData,
-        setting
-      );
-
-      if (status === false) {
-        throw Error(errors);
-      }
-
-      allEmptyPath.add(setting.savePath);
-    }
-
-    // validate path before empty folder
-    for (let emptyPath of allEmptyPath) {
-      // console.log("emptyPath: ", emptyPath);
-      validatePathWithRootServicePath(localServicePath, emptyPath);
-    }
-
-    for (let emptyPath of allEmptyPath) {
-      await deleteFileInDir(emptyPath);
-    }
-
-    // generate all source
-    for (let item of allCreateSource) {
-      // throw error if item is invalid
-      if (!item || !item.templatePath || !item.templateData || !item.setting) {
-        console.log('Throwing invalid source item:', item);
-        throw Error('Throwing invalid source item:', item);
-      }
-
-      const { templatePath, templateData, setting } = item;
-      setting.checkCreateSourcePass = false;
-
-      await createSource(
-        readFileSync(templatePath, 'utf8'),
-        templateData,
-        setting
-      );
-    }
-
-    console.log('Generated all source files successfully');
-    return 'return values';
-  } catch (error) {
-    console.error('Error generating code:', error);
-    throw error;
-  }
-}
-
-export default generateSchema;

package/src/SchemaConfig.js

@@ -1,23 +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/>.
-*/
-
-export const schemaConfig = {
-  TemplateAndData: {
-    propertyValue: './TemplateData/propertyValueSchema/generateTemplateData.js'
-  },
-  Plugin: {}
-};

package/src/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/TemplateData/perActionEndpoint/generateTemplateData.js

@@ -1,112 +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/>.
-*/
-
-const { join } = require('path');
-const {
-  getAllLocalObjectSchemasWithHierarchy
-} = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
-
-// Import handlers and generators
-const modules = {
-  handlers: {
-    inv: require('./handler/inv/data'),
-    api: require('./handler/api/data'),
-    sqs: require('./handler/sqs/data'),
-    dsq: require('./handler/dsq/data')
-  },
-  mainFunctions: {
-    get: require('./mainFunction/get/data'),
-    update: require('./mainFunction/update/data'),
-    create: require('./mainFunction/create/data'),
-    delete: require('./mainFunction/delete/data')
-  },
-  yamlGenerators: {
-    inv: require('./yaml/inv/data'),
-    api: require('./yaml/api/data'),
-    sqs: require('./yaml/sqs/data'),
-    dsq: require('./yaml/dsq/data')
-  }
-};
-
-// Import code libs generator
-const createGenerateCodeLibs = require('./libs/data');
-
-/**
- * Generates code from templates based on object schemas
- * @param {Object} _izContext - Context object
- * @param {string} objSchemaPath - Path to object schema
- * @returns {Promise<Array>} - Array of parameter objects for code generation
- */
-async function generateCodeWithTemplate(_izContext, objSchemaPath) {
-  try {
-    const saveFilePath = join(objSchemaPath, `../`);
-    const allObjSchemas = await getAllLocalObjectSchemasWithHierarchy(
-      _izContext,
-      objSchemaPath
-    );
-
-    const createSourceParams = [];
-
-    for (const objectSchema of allObjSchemas.records) {
-      try {
-        // Generate handlers
-        const handlerParams = Object.entries(modules.handlers).flatMap(
-          ([type, handlerFn]) =>
-            handlerFn(_izContext, objectSchema, saveFilePath)
-        );
-
-        // Generate main functions
-        const functionParams = (
-          await Promise.all(
-            Object.entries(modules.mainFunctions).map(([action, functionFn]) =>
-              functionFn(_izContext, objectSchema, saveFilePath)
-            )
-          )
-        ).flat();
-
-        // Generate function YAML files
-        const yamlParams = Object.entries(modules.yamlGenerators).flatMap(
-          ([type, yamlFn]) => yamlFn(_izContext, objectSchema, saveFilePath)
-        );
-
-        // Generate code libs
-        const libsParam = createGenerateCodeLibs(_izContext, saveFilePath);
-
-        createSourceParams.push(
-          ...handlerParams,
-          ...functionParams,
-          ...yamlParams,
-          libsParam
-        );
-      } catch (error) {
-        _izContext.logger.error(
-          `Error processing schema ${objectSchema.name || 'unknown'}: ${error}`
-        );
-      }
-    }
-
-    return createSourceParams;
-  } catch (error) {
-    _izContext.logger.error(
-      'Error generating code with template perActionEndpoint:',
-      error
-    );
-    return [];
-  }
-}
-
-module.exports = generateCodeWithTemplate;