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

package/src/TemplateData/AttributeTreeSchema/AttributeTreeStandard/data.js

@@ -0,0 +1,103 @@
+/*
+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/>.
+*/
+
+'use strict';
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import { consts } from '@izara_project/izara-core-generate-service-code'
+
+const {
+  SOURCE_PATH,
+  SAVE_FILE_NAME,
+  ADD_ON_DATA_STRUCTURE_TYPE
+} = consts;
+
+const templatePath = path.join(__dirname, "./template.ejs");
+
+async function data(
+  _izContext,
+  settings,
+  srcPath
+) {
+  // console.log("settings::::::", settings);
+
+  const storageResources = settings.createDataDetail.storageResources; // storageResource from main objectType
+
+  // let compositeKeyDeliminator
+  // if (createDataDetail.hasOwnProperty("compositeKeyDeliminator")) {
+  //   compositeKeyDeliminator = createDataDetail.compositeKeyDeliminator;
+  // };
+  console.log(settings)
+  let attributeTreeObjSchemas = [];
+  let createSources = [];
+  // console.log("settings.objTypeExtend ==", settings.objTypeExtend);
+
+  attributeTreeObjSchemas.push(
+    {
+      objectType: settings.objType.objectType,
+      // fieldNames: {
+      //   [settings.objType.objectType + "Id"]: fieldNameSetting(FIELD_NAME_TPYE.randomOnCreateFieldName)
+      // },
+      // identifiers: [
+      //   {
+      //     type: "identifier",
+      //     fieldName: settings.objType.objectType + "Id"
+      //   }
+      // ],
+      extendObjType: settings.objTypeExtend
+    }
+  )
+  for (let attributeTreeObjSchema of attributeTreeObjSchemas) {
+    Object.assign(attributeTreeObjSchema, {
+      storageResources: storageResources, // add storageResources
+      // compositeKeyDeliminator: compositeKeyDeliminator
+    })
+    // for (let attributeTreeFieldName of Object.values(attributeTreeObjSchema.fieldNames)) {
+    //   Object.assign(attributeTreeFieldName, { storageResourceTags: storageResourceTag }) // add storageResourceTags for each fieldName
+    // }
+  };
+
+
+  for (const attributeTreeObjSchema of attributeTreeObjSchemas) {
+    createSources.push({
+      templatePath: templatePath,
+      templateData: {
+        // fieldNames: JSON.stringify(attributeTreeObjSchema.fieldNames, null, 2),
+        // identifiers: JSON.stringify(attributeTreeObjSchema.identifiers, null, 2),
+        objectType: attributeTreeObjSchema.objectType,
+        storageResources: JSON.stringify(attributeTreeObjSchema.storageResources, null, 2),
+        // compositeKeyDeliminator: attributeTreeObjSchema.compositeKeyDeliminator,
+        extendObjType: JSON.stringify(attributeTreeObjSchema.extendObjType, null, 2)
+      },
+      setting: {
+        savePath: path.join(srcPath, SOURCE_PATH.generatedAttributeTree, attributeTreeObjSchema.objectType, "/"),
+        hookPath: path.join(srcPath, "schemaHook", ADD_ON_DATA_STRUCTURE_TYPE.attributeTree, attributeTreeObjSchema.objectType, "/"),
+        saveFileName: SAVE_FILE_NAME.objectSchema,
+        fileExtension: ".js",
+        isAppend: false
+      }
+    })
+  };
+
+  return createSources;
+}
+
+export default data

package/src/TemplateData/AttributeTreeSchema/AttributeTreeStandard/template.ejs

@@ -0,0 +1,20 @@
+const izara = require("@izara_project/izara-middleware");
+let { pattern } = izara.validatorSchema.stringNotEmpty(); // should not be empty string
+
+export default [
+  {
+    objectType: "<%- objectType %>",
+    extendObjType: <%- extendObjType %>,
+    addOnDataStructure: [ // optional, add for additional setting to objectType
+      //(<addOnDataStructure<%- objectType %>>)
+      //(</addOnDataStructure<%- objectType %>>)
+    ],
+    storageResources: <%- storageResources %>,
+    fieldNames:{
+      //(<fieldNames<%- objectType %>>)
+      //(</fieldNames<%- objectType %>>)
+    },
+    //(<compositeKeyDeliminator<%- objectType %>>) // optional compositeKeyDeliminator
+    //(</compositeKeyDeliminator<%- objectType %>>)
+  }
+]

package/src/TemplateData/AttributeTreeSchema/generateTemplateData.js

@@ -0,0 +1,105 @@
+/*
+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 required modules
+// console.log("generate main PropertyValue Schema");
+import { join } from 'path';
+import fs from "fs"
+import { attributeTreeLib } from '@izara_project/izara-attribute-tree';
+import yaml from 'yaml'
+import attributeTreeManagerSchema from './AttributeTreeManager/data.js'
+import attributeTreeStandardSchema from './AttributeTreeStandard/data.js'
+import attributeTreeRelationshipSchema from './AttributeTreeRelationship/data.js'
+
+/**
+ * Generates code with templates for different actions
+ * @param {Object} _izContext - Context object
+ * @param {string} objSchemaPath - Path to the schema
+ * @returns {Array} Array of generated code parameters
+ */
+async function generateCodeWithTemplate(_izContext, settings) {
+  try {
+
+    let allCreateSource = [];
+
+    console.log("settings", settings)
+    const BASE_GENERATE_SCHEMA_PATH = "./app/src/"
+    // validate parent folder
+    const parentFolder = fs.readdirSync(settings.pathParent);
+    for (const suffixKey of Object.keys(settings.suffix)) {
+      let fileName = `${settings.setting.repositoryPrefix}-${settings.suffix[suffixKey]}`
+      if (!parentFolder.includes(fileName)) {
+        throw new Error('not have file to generateCode')
+      } else {
+        if (settings.suffix[suffixKey] === settings.suffix.manager) {
+          let generateSchema = {
+            objType: settings.setting.objType,
+            attributeTreeTag: settings.setting.attributeTag,
+            createDataDetail: settings.createDataDetail
+          }
+          let sourcePathManagerService = join(settings.pathParent, fileName, BASE_GENERATE_SCHEMA_PATH);
+
+          let generateObjectSchemaAttributeTreeManager = await attributeTreeManagerSchema(_izContext, generateSchema, sourcePathManagerService);
+          let generateObjectSchemaAttributeTreeRelationship = await attributeTreeRelationshipSchema(_izContext, settings, sourcePathManagerService);
+
+          allCreateSource.push(
+            ...generateObjectSchemaAttributeTreeManager,
+            generateObjectSchemaAttributeTreeRelationship
+          )
+        } else if (settings.suffix[suffixKey] === settings.suffix.standard) {
+          let generateSchema = {
+            objType: {
+              objectType: attributeTreeLib.createAttributeValueStandard(settings.setting.attributeTag),
+              serviceTag: findServiceTag(join(settings.pathParent, fileName, "/"))
+            },
+            objTypeExtend: {
+              objectType: attributeTreeLib.createAttributeValue(settings.setting.attributeTag),
+              serviceTag: settings.setting.objType.serviceTag
+            },
+            createDataDetail: settings.createDataDetail
+          }
+          let srcPathStandardService = join(settings.pathParent, fileName, BASE_GENERATE_SCHEMA_PATH)
+
+          let generateObjectSchemaAttributeTreeStandard = await attributeTreeStandardSchema(_izContext, generateSchema, srcPathStandardService);
+          allCreateSource.push(
+            ...generateObjectSchemaAttributeTreeStandard
+          )
+        }
+      }
+    }
+
+    return allCreateSource;
+  } catch (error) {
+    _izContext.logger.error(
+      'Error generating code with template propertyNode schema:',
+      error
+    );
+    return [];
+  }
+}
+
+function findServiceTag(srcPath) {
+
+  const configPath = path.join(srcPath, './config/serverless.config.yml');
+  const serverlessConfig = fs.readFileSync(configPath, 'utf8');
+  const config = yaml.parse(serverlessConfig);
+  console.log({ config })
+  const serviceTag = config.main_config.iz_serviceTag;
+  return serviceTag
+}
+
+export default generateCodeWithTemplate;

package/src/{reStructure → TemplateData}/GenerateSchema.js

@@ -17,15 +17,12 @@ 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 '../SourceManager/index.js';
+import { generateCodeLibs as validatePathWithRootServicePath, createSource, utils } from '@izara_project/izara-core-generate-service-code'
 const { deleteFileInDir } = utils;
 
+import generatePropertyNode from './PropertyValueSchema/generateTemplateData.js'
+import generateAttributeTree from './AttributeTreeSchema/generateTemplateData.js'
+
 async function generateSchema(
   _izContext,
   objSchemaPath,
@@ -49,52 +46,40 @@ async function generateSchema(
     // 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 (generateSchemaSettings.propertyNodeConfig && Object.keys(generateSchemaSettings.propertyNodeConfig).length > 0) {
+      allCreateSource.push(await generatePropertyNode(_izContext, objSchemaPath, generateSchemaSettings.propertyNodeConfig));
+    }
 
-    // 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(', ')} ]`
-      );
+    if (generateSchemaSettings.attributeTreeConfig && Object.keys(generateSchemaSettings.attributeTreeConfig).length > 0) {
+      allCreateSource.push(...await generateAttributeTree(_izContext, generateSchemaSettings.attributeTreeConfig));
     }
 
-    // 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
-      );
+    // console.log("allCreateSource:", JSON.stringify(allCreateSource, null, 2))
 
-      // 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);
-      }
-    }
+    // 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) {
@@ -112,7 +97,7 @@ async function generateSchema(
       } = item;
       setting.checkCreateSourcePass = true;
 
-      let [status, errors] = await createSource.createSource(
+      let [status, errors] = await createSource(
         readFileSync(templatePath, 'utf8'),
         templateData,
         setting
@@ -124,11 +109,12 @@ async function generateSchema(
 
       allEmptyPath.add(setting.savePath);
     }
-
+    console.log(allEmptyPath)
+    console.log(localServicePath)
     // validate path before empty folder
     for (let emptyPath of allEmptyPath) {
       // console.log("emptyPath: ", emptyPath);
-      validatePathWithRootServicePath(localServicePath, emptyPath);
+      // validatePathWithRootServicePath(localServicePath, emptyPath);
     }
 
     for (let emptyPath of allEmptyPath) {

package/src/TemplateData/PropertyValueSchema/PropertyValueObjectSchema/data.js

@@ -0,0 +1,160 @@
+/*
+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/>.
+*/
+
+// console.log("=== property value schema ===");
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import lodash from 'lodash';
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import { propertyNodeLib } from '@izara_project/izara-property-nodes';
+import { consts, utils, libs } from '@izara_project/izara-core-generate-service-code'
+
+const {
+  SOURCE_PATH,
+  FIELD_NAME_TYPE,
+  SAVE_FILE_NAME,
+  STORAGE_TYPES
+} = consts;
+
+const { fieldNameSetting } = libs;
+
+const { firstLetterUpperCase: upperCase } = utils;
+
+const templatePath = path.join(__dirname, './templateObjectPropertyValueSchema.ejs');
+
+
+async function data(_izContext, settings, srcPath) {
+  console.log('generateObjectSchema propertyNode')
+  let propertyValueObjectSchemas = [];
+  let createSources = [];
+
+  for (const settingPropertyNode of settings) {
+    let objectSchema = await getObjectSchema
+      .getLocalObjectSchemasWithHierarchy(
+        _izContext,
+        [settingPropertyNode.objectType],
+        path.join(srcPath, './schemas')
+      )
+      .then(res => res.records[0]);
+    _izContext.logger.debug('objectSchema objectSchema::', objectSchema);
+
+    if (!objectSchema) {
+      throw Error(
+        `Invalid objType:${objTypeString(objType)}, cannot generate attribute tree schema cause objectSchema is not exists`
+      );
+    }
+
+    // let objectType = settings.objType.objectType;
+    let propertyValueTag = settingPropertyNode.propertyNodeName;
+    // validate only addOnndataStructure is type propertyNode.
+
+    if (!objectSchema.hasOwnProperty('addOnDataStructure') ||
+      !Array.isArray(objectSchema.addOnDataStructure) ||
+      !objectSchema.addOnDataStructure.length
+    ) {
+      // console.log(`Not have data in addOnDataStructure in objectType:${objectSchema.objectType}`);
+      throw Error(
+        `Not have data in addOnDataStructure in objectType:${objectSchema.objectType}`
+      );
+    }
+
+    const storageResources = objectSchema.storageResources; // storageResource from main objectType
+    let cloneDeepStorageResources = lodash.cloneDeep(storageResources);
+    for (let [storageResourceTag, storageResourceSetting] of Object.entries(cloneDeepStorageResources)) {
+      if (storageResourceSetting.storageType === STORAGE_TYPES.dynamoDB) {
+        delete cloneDeepStorageResources[storageResourceTag];
+      }
+    }
+    const storageResourceTags = Object.keys(cloneDeepStorageResources); // storage ResourceTag from main objectType
+    const compositeKeyDeliminator = objectSchema.compositeKeyDeliminator;
+
+    propertyValueObjectSchemas.push(
+      {
+        // {subject}property
+        // objectType: propertyValueTag + PROPERTY_VALUE_TAG.property,
+        objectType: propertyNodeLib.createPropertyGraphNodeLabel(propertyValueTag),
+        fieldNames: {
+          // [propertyValueTag + PROPERTY_VALUE_TAG.property + 'Id']:
+          [propertyValueTag + upperCase(propertyNodeLib.consts.PROPERTY_GRAPH_IDENTIFIER_ID)]:
+            fieldNameSetting(FIELD_NAME_TYPE.randomOnCreateFieldName)
+        },
+        identifiers: [
+          {
+            type: 'identifier',
+            fieldName: propertyValueTag + upperCase(propertyNodeLib.consts.PROPERTY_GRAPH_IDENTIFIER_ID)
+          }
+        ]
+      },
+      {
+        // {subject}propertyLabel
+        // objectType: propertyValueTag + PROPERTY_VALUE_TAG.propertyLabel,
+        objectType: propertyNodeLib.createPropertyLabelGraphNodeLabel(propertyValueTag),
+        fieldNames: {
+          // [propertyValueTag + PROPERTY_VALUE_TAG.propertyLabel + 'Id']:
+          [propertyValueTag + upperCase(propertyNodeLib.consts.PROPERTY_LABEL_GRAPH_IDENTIFIER_ID)]:
+            fieldNameSetting(FIELD_NAME_TYPE.randomOnCreateFieldName)
+        },
+        identifiers: [
+          {
+            type: 'identifier',
+            fieldName:
+              propertyValueTag + upperCase(propertyNodeLib.consts.PROPERTY_LABEL_GRAPH_IDENTIFIER_ID)
+          }
+        ]
+      }
+    );
+    for (let propertyValueObjectSchema of propertyValueObjectSchemas) {
+      Object.assign(propertyValueObjectSchema, {
+        storageResources: cloneDeepStorageResources, // add storageResources
+        compositeKeyDeliminator: compositeKeyDeliminator
+      });
+      for (let attributeTreeFieldName of Object.values(
+        propertyValueObjectSchema.fieldNames
+      )) {
+        Object.assign(attributeTreeFieldName, {
+          storageResourceTags: storageResourceTags
+        }); // add storageResourceTags for each fieldName
+      }
+    }
+    for (const propertyValueObjectSchema of propertyValueObjectSchemas) {
+      createSources.push({
+        templatePath: templatePath,
+        templateData: {
+          fieldNames: JSON.stringify(propertyValueObjectSchema.fieldNames, null, 2),
+          identifiers: JSON.stringify(propertyValueObjectSchema.identifiers, null, 2),
+          objectType: propertyValueObjectSchema.objectType,
+          storageResources: JSON.stringify(propertyValueObjectSchema.storageResources, null, 2),
+          compositeKeyDeliminator: propertyValueObjectSchema.compositeKeyDeliminator
+        },
+        setting: {
+          savePath: path.join(srcPath, SOURCE_PATH.generatedPropertyValue, propertyValueObjectSchema.objectType + '/'),
+          hookPath: path.join(srcPath, 'schemaHook', 'propertyValue', propertyValueObjectSchema.objectType, '/'),
+          saveFileName: SAVE_FILE_NAME.objectSchema,
+          fileExtension: '.js',
+          isAppend: false
+        }
+      });
+    }
+  }
+  return createSources;
+} //End loop addOn
+
+export default data;