@izara_project/izara-market-library-service-schemas 1.0.76 → 1.0.77

package/src/reStructure/TemplateData/IntTest/generateUpload/genetateTempleteUpload.js

@@ -0,0 +1,52 @@
+// /*
+// 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 required modules
+// // console.log("generate main PropertyValue Schema");
+// const { join } = require('path');
+
+
+
+
+// // const relationshipPropertyNodeSchema = require('./tests/data')
+// const upload = require('./upload/data')
+
+// /**
+//  * Generates code with templates for different actions
+//  * @param {Object} _izContext - Context object
+//  * @param {string} savePath - Path to the schema
+//  * @returns {Array} Array of generated code parameters
+//  */
+// async function generateCodeWithTemplate(_izContext, savePath, settings) {
+//   try {
+//     // console.log("settings generateCodeWithTemplate", settings)
+//     let allCreateSource = [];
+//     const generateUpload = await upload(_izContext, savePath, settings)
+//     // console.log("generateResource_Template", generateResource);
+//     allCreateSource.push(
+//       // generateResource,
+//     )
+//     return allCreateSource;
+//   } catch (error) {
+//     _izContext.logger.error('Error generating code with template propertyNode schema:', error);
+//     return [];
+//   }
+// }
+
+// module.exports = generateCodeWithTemplate;

package/src/reStructure/TemplateData/IntTest/generateUpload/upload/data.js

@@ -0,0 +1,40 @@
+/*
+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';
+
+const path = require('path');
+
+const { getLocalConfig } = require("../../libs/generateTestsLibs")
+const { uploadFolder } = require("./libs/generateTestUploadLibs")
+
+const Logger = require('@izara_project/izara-core-library-logger');
+const { NoRetryError } = require('@izara_project/izara-core-library-core');
+
+async function data(_izContext, srcPath, settings) {
+
+  let serviceTag = getLocalConfig(path.join(srcPath, "../../"), "iz_serviceTag")
+  let pathUpload = settings.saveBucketPath.s3
+  const folderPath = path.resolve(__dirname, `../../../../../../src/generateIntegrationTest/${serviceTag}`);
+  const s3Prefix = `test_config/${pathUpload}/${serviceTag}/`;
+  const bucketName = "integrationtest-config-us-east-2";
+  let uploadFolderToS3 = await uploadFolder(bucketName, folderPath, s3Prefix)
+  // console.log("uploadFolderToS3", uploadFolderToS3);
+
+}
+
+module.exports = data

package/src/reStructure/TemplateData/IntTest/generateUpload/upload/libs/generateTestUploadLibs.js

@@ -0,0 +1,39 @@
+const path = require('path');
+const fs = require("fs");
+const { putObjectS3 } = require("@izara_project/izara-core-library-s3");
+const Logger = require("@izara_project/izara-core-library-logger")
+const _izContext = { Logger }
+
+async function uploadFolder(bucketName, folderPath, s3Prefix) {
+  const entries = fs.readdirSync(folderPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(folderPath, entry.name);
+    const s3Key = path.join(s3Prefix, entry.name).replace(/\\/g, "/"); // path for user upload
+
+    if (entry.isDirectory()) {
+      await uploadFolder(bucketName, fullPath, s3Key);
+    } else {
+
+      const fileStream = fs.createReadStream(fullPath);
+      const params = {
+        Bucket: bucketName,
+        Key: s3Key,
+        Body: fileStream,
+      };
+
+      try {
+        const result = await putObjectS3(_izContext, params);
+        // console.log("Upload-Succuss:", s3Key, "ETag:", result.ETag);
+        console.log("Path-Upload ::", s3Key);
+
+        console.log("Upload-Succuss");
+      } catch (err) {
+        // console.error("Upload-Failed:", s3Key, err);
+        console.log("Upload-Failed");
+      }
+    }
+  }
+}
+module.exports = {
+  uploadFolder
+}

package/src/reStructure/TemplateData/IntTest/generateUpload.js

@@ -0,0 +1,145 @@
+// /*
+// 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';
+
+// const path = require("path");
+// const { join, resolve } = require("path");
+// const { readFileSync } = require("fs");
+// // const templateConfig = require("./TemplateConfig");
+// const {
+//   sourceMgr:
+//   {
+//     utils: {
+//       deleteFileInDir,
+//     },
+//     createSource: { createSource }
+//   }
+// } = require('@izara_project/izara-market-library-service-schemas')
+// // const { validatePathWithRootServicePath } = require('../libs/Libs')
+// const { exec } = require('child_process');
+
+// async function generateCodeWithTemplate(_izContext, savePath, settings) {
+//   _izContext.logger.debug("START", { savePath, settings })
+//   try {
+
+//     // let packagePath = path.join(__dirname, "../../")
+//     // console.log({ packagePath });
+//     // ---------  Prepare path  -------------
+//     // point to app/src
+//     // let saveFilePath = join(packagePath, `../`);
+
+//     // point to root folder of service
+//     // let localServicePath = join(saveFilePath, "../../");
+
+//     //------ Start Create Source ------
+
+//     // collect all result of template data for execute createSource
+//     let allCreateSource = []
+
+
+//     let generateTemplateData = require("./generateUpload/genetateTempleteUpload")
+//     let createSourceResult = await generateTemplateData(_izContext, savePath, settings);
+//     // console.log({ createSourceResult })
+//     // 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);
+//     }
+//     // console.log({ allCreateSource })
+//     // check each allCreateSource valid
+//     // _izContext.logger.debug("check savePath:", savePath);
+//     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 } = item;
+//       setting.checkCreateSourcePass = true;
+
+//       let [status, errors] = await createSource(
+//         readFileSync(templatePath, 'utf8'),
+//         templateData,
+//         setting,
+//       );
+
+//       if (status === false) {
+//         console.log('templatePath in generateCode', templatePath)
+//         throw Error(errors)
+//       }
+
+//       // validatePathWithRootServicePath(localServicePath, setting.savePath)
+//       await deleteFileInDir(setting.savePath);
+//     }
+
+//     // 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');
+
+//     // exec(`bash ${path.join(packagePath, "./frontEnd/NpmBash.bash")}`, (error, stdout, stderr) => {
+//     //   if (error) {
+//     //     console.error(`
+//     //       ${error.message}`);
+//     //     return;
+//     //   }
+//     //   if (stderr) {
+//     //     console.error(`${stderr}`);
+//     //     return;
+//     //   }
+//     //   console.log(`${stdout}`);
+//     // });
+//     // return 'return values';
+//   } catch (error) {
+//     console.error('Error generating code:', error);
+//     throw error;
+//   }
+// }
+
+// module.exports = {
+//   generateCodeWithTemplate
+// }
+
+
+// /*
+//   GenerateCode will iterate through templateConfig and generate each template dependOn each templateAndData\
+
+//   GenerateSchema now use for generate attribute tree only
+//   generateSchema can be modify use used depend on use case eg: some objectType have attribute tree inside addOn
+//     when generateSchema in own service need to generate ref objectRelationship only
+//     and attribute tree service can generate schema
+
+// */

package/src/reStructure/TemplateData/IntTest/libs/generateTestsLibs.js

@@ -0,0 +1,417 @@
+const { HANDLER } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+const yaml = require("yaml")
+const fs = require('fs');
+const Logger = require('@izara_project/izara-core-library-logger');
+const { log } = require('console');
+
+
+function lowercaseFirst(str) {
+  if (!str) return "";
+  return str[0].toLowerCase() + str.slice(1);
+}
+
+// generate Resources
+function setGenerateSeedData(generatedSeedDataInput) {
+
+  // if (generatedSeedDataInput !== undefined) {
+
+  Logger.debug("generatedSeedDataInput", generatedSeedDataInput)
+  let generateSeedDatas = []
+
+  generateSeedDatas.push({
+    generateSeedDatas: generatedSeedDataInput
+  })
+
+  Logger.debug("generateSeedDatas-Libs", generateSeedDatas)
+
+  return generateSeedDatas
+
+  // }
+
+}
+
+function directoryPath(dirPath) {
+  let result = []
+  const items = fs.readdirSync(dirPath);
+  for (let item of items) {
+    const fullPath = path.join(dirPath, item);
+    const stat = fs.statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      directoryPath(fullPath, result); // recursion
+    } else if (stat.isFile()) {
+      if (!fullPath.includes("shared-resource.yml") && !fullPath.includes("core-function.yml")) {
+        if (fullPath.endsWith('.yml')) {
+          result.push(fullPath);
+        } else {
+          console.log("Skipped File:", fullPath);
+        }
+      }
+    }
+  }
+
+  let functionComponent = {};
+  for (let ymlFilesPath of result) {
+
+    const fileContent = fs.readFileSync(ymlFilesPath, 'utf8');
+    const parsedYaml = yaml.parse(fileContent);
+    for (const component of Object.values(parsedYaml)) {
+
+      if (component.handler && component.name) {
+
+        const clearName = component.name.replace("${self:custom.iz_resourcePrefix}", "")
+        const clearMain = component.handler.replace(/\.main$/, '');
+        Object.assign(functionComponent, { [clearName]: clearMain })
+      }
+    }
+  }
+  return functionComponent
+}
+
+function getLocalConfig(srcPath, params) {
+  const configPath = path.join(process.cwd(), '../config/serverless.config.yml');
+  const serverlessConfig = fs.readFileSync(configPath, 'utf8')
+  const config = yaml.parse(serverlessConfig);
+  const returnConfig = config.main_config[params];
+  return returnConfig
+}
+
+// generate Resources
+
+// create ResourcesName & FunctionName
+
+function createTestFunctionName(eventTag) { // set resourceName
+  let handlerSpite = eventTag; // fix
+  let handler = "";
+  if (handlerSpite.includes("__case")) {
+    let mainPart = handlerSpite.split("__case")[0];
+    let mainPartShort = mainPart.slice(0, -6);
+    let lastUnderscoreIndex = mainPartShort.lastIndexOf("_");
+
+    if (lastUnderscoreIndex !== -1) {
+      handler = mainPartShort.substring(lastUnderscoreIndex + 1);
+    } else {
+      handler = mainPartShort;
+    }
+  }
+  // Logger.debug("handlerAfterSpite", handler);
+  return handler;
+}
+
+// create ResourcesName & FunctionName
+
+// setEvent
+
+function setEvent(input, settings = {}) {
+  const transformedObject = {};
+  const forStageMatchs = settings?.forStageMatchs || [];
+  const testValueMatches = settings?.testValueMatches || [];
+
+  if (Array.isArray(input)) {
+    return { eventValue: input };
+  }
+
+  if (input === undefined) {
+    return { value: "undefined" };
+  }
+
+  if (typeof input === "object") {
+    if (input === null) {
+      return { value: input };
+    }
+
+    if (Object.keys(input).length === 0) {
+      return { properties: { value: {} } };
+    }
+
+    for (const key in input) {
+      const transformatValue = setEvent(input[key], settings);
+      const field = {};
+
+      if (forStageMatchs.includes(key)) {
+        field.forStageMatching = true;
+      }
+      if (testValueMatches.includes(key)) {
+        field.testValueMatches = false;
+      }
+
+      if (typeof transformatValue === "object" && !Array.isArray(transformatValue)) {
+        transformedObject[key] = {
+          ...field,
+          ...transformatValue,
+        };
+      } else {
+        transformedObject[key] = transformatValue;
+      }
+    }
+    return { properties: transformedObject };
+  }
+
+  if (
+    typeof input === "string" ||
+    typeof input === "number" ||
+    typeof input === "boolean"
+  ) {
+    return { value: input };
+  }
+
+  return input;
+}
+
+function setEventDynamo(dynamoInput, settings = {}) {
+  const transformedObject = {};
+
+  if (typeof dynamoInput === "object") {
+
+    for (const key in dynamoInput) {
+      const transformatValue = setEventDynamo(dynamoInput[key], settings);
+      const field = {};
+
+      if (typeof transformatValue === "object") {
+        transformedObject[key] = {
+          ...field,
+          ...transformatValue,
+        };
+      }
+      else {
+        transformedObject[key] = transformatValue;
+      }
+    }
+    return { properties: transformedObject };
+  }
+
+  return dynamoInput;
+}
+
+
+function setEventMessageAttributes(attributes = {}) { // set event MessageAttributes
+  const result = {};
+  for (const key in attributes) {
+    result[key] = {
+      value: attributes[key]
+    };
+  }
+  return result;
+}
+
+function setEventInvoke(configs, invokeComponents = []) {   // set Event Invoke
+
+  let inputInvokeName = `${configs.eventStageTag + "__case_"}${configs.inputEventTag}`
+  let outputInvokeName = `${"Output_" + inputInvokeName}`
+  let inputInvoke = setEvent(configs.inputConfig.event, configs.inputConfig.inputInvokeSettings)
+  let outputInvoke = setEvent(configs.outputConfig.event, configs.inputConfig.outputInvokeSettings)
+
+  invokeComponents.push({
+    inputInvokeName,
+    outputInvokeName,
+    inputInvoke,
+    outputInvoke
+  })
+  let invokeConfigs = configs.invokeConfig
+  if (invokeConfigs && invokeConfigs.length && invokeConfigs.length > 0) {
+    for (let invokeConfig of configs.invokeConfig) {
+
+      setEventInvoke(invokeConfig, invokeComponents)
+    }
+  }
+  return invokeComponents
+}
+
+// setEvent
+
+
+// setTests
+
+function setDynamoIdentifierTests(dynamoDBConfigs, serviceTags, inputEventName) {
+  // console.log("dynamoDBConfigs", dynamoDBConfigs);
+  // let stage = process.env.iz_stage
+  let dynamodbOutputEventIdentifiers = []
+
+  if (dynamoDBConfigs && dynamoDBConfigs.length > 0) {
+
+    for (let dynamoDBConfig of dynamoDBConfigs) {
+
+      let eventTag = null
+      let resourceName = null
+      let serviceTag = null
+
+      if (dynamoDBConfig.resourcePrefix
+        && dynamoDBConfig.resourcePrefix !== ""
+        && dynamoDBConfig.resourcePrefix !== null) {
+        // setExten config
+        serviceTag = dynamoDBConfig.resourcePrefix
+
+        resourceName = `${dynamoDBConfig.resourceName}`
+
+      } else if (dynamoDBConfig.resourceName) {
+
+        resourceName = `${dynamoDBConfig.resourceName}`
+        serviceTag = serviceTags
+      }
+
+      eventTag = `${inputEventName + "__Dynamodb_"}${dynamoDBConfig.eventDynamoTag}`
+      dynamodbOutputEventIdentifiers.push(
+        {
+          serviceTag: serviceTag, // new Set
+          resourceName, // new set
+          eventTag // eventTag + stage + resourceName
+        }
+      )
+    }
+
+  }
+  return dynamodbOutputEventIdentifiers
+}
+
+async function setInvokeTest(   // invoke >> invoke >> invoke
+  inputInvokeConfigs,
+  stages = [],
+  eventStage = [],
+  stageKeep = [],
+
+) {
+
+  for (let loopInputInvokeConfig of inputInvokeConfigs) {
+
+    let objectKeep = {}
+    let eventStageTags = `${loopInputInvokeConfig.eventStageTag}`;
+
+    let [serviceTag, functionName] = createResourceName(eventStageTags + "__case_");
+    let inputEventTag = `${eventStageTags + "__case_"}${loopInputInvokeConfig.inputEventTag}`;
+
+    if (Array.isArray(loopInputInvokeConfig.invokeConfig) && loopInputInvokeConfig.invokeConfig.length > 0) {
+
+      let invokes = [];
+
+      Object.assign(objectKeep, {
+        eventStageTag: eventStageTags,
+        inputEventTag,
+        serviceTag,
+        resourceType: "Lambda",
+        resourceName: functionName,
+        outputEventTag: `${"Output_" + inputEventTag}`
+      }
+      )
+
+      stageKeep.push(objectKeep);
+      eventStage.push(eventStageTags);
+
+      for (const invoke of loopInputInvokeConfig.invokeConfig) {
+
+        invokes.push({
+          eventStageTags: invoke.eventStageTag
+        });
+
+        objectKeep.invokes = invokes;
+
+      }
+
+      await setInvokeTest(loopInputInvokeConfig.invokeConfig, stages, eventStage, stageKeep);
+      // continue
+      // }
+    }
+    if (loopInputInvokeConfig && !loopInputInvokeConfig.invokeConfig) {
+
+      let setInvokes = await setNoInvokeTest(loopInputInvokeConfig, serviceTag, functionName) // function Set !Invoke
+
+      stageKeep.push(...setInvokes)
+      //
+    }
+  }
+
+  return stageKeep
+}
+
+
+async function setNoInvokeTest(invokeConfigs, serviceTag, functionName, eventStages = []) {  // function set Not invoke
+
+  let stageKeep = {}
+  let eventStageTags = invokeConfigs.eventStageTag
+  let inputEventTags = `${eventStageTags + "__case_"}${invokeConfigs.inputEventTag}`
+
+  if (invokeConfigs) {
+
+    Object.assign(stageKeep, {
+      eventStageTag: eventStageTags,
+      inputEventTag: inputEventTags,
+      serviceTag,
+      resourceType: "Lambda",
+      resourceName: functionName,
+      outputEventTag: `${"Output_" + inputEventTags}`
+    })
+
+  }
+  eventStages.push(stageKeep)
+
+  return eventStages;
+}
+
+// setTests
+
+function createEventCaseByHandler(handler, messageAttributes = {}) {
+  return {
+    [HANDLER.hdrApi]: {},
+    [HANDLER.hdrDsq]: { DirectSqs: true },
+    [HANDLER.hdrInv]: {},
+    [HANDLER.hdrSqs]: {
+      snsSqsTrigger: true,
+      ...(messageAttributes && Object.keys(messageAttributes).length > 0
+        ? { messageAttributes: setEventMessageAttributes(messageAttributes) }
+        : {})
+    }
+  }
+  [handler]
+}
+
+function getHandlerFromEventTag(eventTag) {
+  let handlerSpite = eventTag // fix
+  let mainPart = handlerSpite.split("__case")[0];
+  let handler = lowercaseFirst(mainPart.slice(-6));
+  if (!handler || !Object.values(HANDLER).includes(handler)) { // Validate Handler
+    if (mainPart.endsWith("Complete")) {
+      handler = "Complete"
+    } else {
+      throw new NoRetryError("no handler");
+    }
+  }
+  return handler
+
+}
+
+function getHandlerFromTestTag(eventTag) {
+  let handlerSpite = eventTag // fix
+  let handler = "";
+  if (handlerSpite.includes("__case")) {
+    let mainPart = handlerSpite.split("__case")[0];
+    handler = mainPart.slice(-6);
+  }
+  handler = lowercaseFirst(handler) //
+  return handler
+
+}
+
+function createResourceName(eventTag) {
+  let mainPart = eventTag.split("__case")[0];
+  let functionName = mainPart.split("_")[1]
+  let serviceTag = mainPart.split("_")[0]
+  return [serviceTag, functionName]
+}
+
+
+module.exports = {
+  lowercaseFirst,
+  setEvent,
+  createTestFunctionName,
+  createEventCaseByHandler,
+  setEventMessageAttributes,
+  getLocalConfig,
+  directoryPath,
+  setEventInvoke,
+  setDynamoIdentifierTests,
+  setEventDynamo,
+  getHandlerFromEventTag,
+  getHandlerFromTestTag,
+  createResourceName,
+  setInvokeTest,
+  setGenerateSeedData
+}