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

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

@@ -0,0 +1,416 @@
+import { consts } from '../../../../../izara-market-library-service-schemas/src/MainLibs/index.js'
+const { HANDLER } = consts
+import yaml from "yaml";
+import fs from 'fs';
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+const { getDataFromPath } = getObjectSchema;
+
+function lowercaseFirst(str) {
+  if (!str) return "";
+  return str[0].toLowerCase() + str.slice(1);
+}
+
+// generate Resources
+function setGenerateSeedData(generatedSeedDataInput) {
+
+  // if (generatedSeedDataInput !== undefined) {
+
+  let generateSeedDatas = []
+
+  generateSeedDatas.push({
+    generateSeedDatas: generatedSeedDataInput
+  })
+
+  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(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 GCTpBas_Create
+  let functionName;
+  if (eventTag.includes("__case")) {
+    let mainPart = eventTag.split("__case")[0];
+    let mainPartShort = mainPart.slice(0, -6);
+    let lastUnderscoreIndex = mainPartShort.lastIndexOf("_");
+
+    if (lastUnderscoreIndex !== -1) {
+      functionName = mainPartShort.substring(lastUnderscoreIndex + 1);
+    } else {
+      functionName = mainPartShort;
+    }
+  }
+  // Logger.debug("handlerAfterSpite", handler);
+  return functionName;
+}
+
+// create ResourcesName & FunctionName
+
+// setEvent
+
+function setEvent(input, settings = {}) {
+  const transformedObject = {
+    //   forStageMatching: true
+  };
+  const forStageMatchs = settings?.forStageMatchs || [];
+  const testValueMatches = settings?.testValueMatches || [];
+  const isEqual = settings?.isEqual || [];
+
+  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 (isEqual.includes(key)) {
+        field.isEqual = true;
+      }
+
+      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
+}
+
+function setInvokeTest(
+  inputInvokeConfigs,
+  invokeEventTags = [],
+  invokeStages = [],
+  level = 1
+) {
+  for (const inputConfig of inputInvokeConfigs) {
+    const eventStageTag = inputConfig.eventStageTag;
+
+    const [serviceTag, functionName] = createResourceName(eventStageTag + "__case_");
+    const inputEventTag = `${eventStageTag}__case_${inputConfig.inputEventTag}`;
+
+    invokeEventTags.push({ eventStageTag });
+
+    invokeStages.push({
+      eventStageTag,
+      inputEventTag,
+      serviceTag,
+      resourceType: "Lambda",
+      resourceName: functionName,
+      outputEventTag: `Output_${inputEventTag}`
+    });
+
+    if (Array.isArray(inputConfig.invokeConfig) && inputConfig.invokeConfig.length > 0) {
+      setInvokeTest(inputConfig.invokeConfig, invokeEventTags, invokeStages, level + 1);
+    }
+  }
+
+  return {
+    invokeEventTags: structuredClone(invokeEventTags),
+    invokeStages: structuredClone(invokeStages)
+  };
+}
+
+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(testTag) {
+  let mainPart = testTag.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 if (mainPart.endsWith("S3")) {
+      handler = "S3"
+    } else {
+      throw new Error("not have handler")
+    }
+  }
+  return handler
+}
+
+function getHandlerFromTestTag(eventTag) {
+  let handler = "";
+  if (eventTag.includes("__case")) {
+    let mainPart = eventTag.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]
+}
+
+async function getIntTestConfig(_izContext, intTestPath) {
+  return await getDataFromPath(_izContext, "GenerateIntegrationTestConfig.js", intTestPath)
+}
+
+function buildInvokeStages(invokeList, result = []) {
+  for (const inv of invokeList) {
+    const inStage = {
+      type: "invoke",
+      eventStageTag: inv.eventStageTag,
+      inputEventTag: `${inv.eventStageTag}__case_${inv.inputEventTag}`,
+      inputConfig: inv.inputConfig,
+      outputConfig: inv.outputConfig,
+    };
+
+    result.push(inStage);
+
+    // recursive invoke
+    if (inv.invokeConfig && inv.invokeConfig.length > 0) {
+      buildInvokeStages(inv.invokeConfig, result);
+    }
+  }
+  return result;
+}
+
+export default {
+  lowercaseFirst,
+  setEvent,
+  createTestFunctionName,
+  createEventCaseByHandler,
+  setEventMessageAttributes,
+  getLocalConfig,
+  directoryPath,
+  setEventInvoke,
+  setDynamoIdentifierTests,
+  setEventDynamo,
+  getHandlerFromEventTag,
+  getHandlerFromTestTag,
+  createResourceName,
+  setInvokeTest,
+  setGenerateSeedData,
+  getIntTestConfig,
+}

package/src/TemplateData/IntTest/upload/uploadIntTest.js

@@ -0,0 +1,95 @@
+/*
+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 fs from 'fs';
+
+import { s3 } from '@izara_project/izara-core-library-s3';
+import Logger from '@izara_project/izara-core-library-logger';
+
+const _izContext = { Logger };
+
+async function bucketPathForUpload(folderPath, settings) {
+  console.log({ folderPath, settings });
+  let dataToUploads = [];
+  try {
+    const files = getAllFiles(folderPath);
+    // console.log({ files })
+    for (const filePath of files) {
+      const fileContent = fs.readFileSync(filePath);
+      const index = filePath.indexOf(settings.serviceTag);
+
+      let relativePath;
+      if (index !== -1) {
+        relativePath = filePath.substring(index);
+      } else {
+        relativePath = path.basename(filePath);
+      }
+
+      let s3Key = path
+        .join('test_config', settings.s3Prefix, relativePath)
+        .split(path.sep)
+        .join('/');
+
+      dataToUploads.push({ key: s3Key, fileContent });
+    }
+
+    return dataToUploads;
+  } catch (err) {
+    console.error('prepare data to upload fail', err);
+  }
+}
+
+function getAllFiles(dirPath, filePaths) {
+  const files = fs.readdirSync(dirPath);
+
+  filePaths = filePaths || [];
+
+  files.forEach(function (file) {
+    const fullPath = path.join(dirPath, file);
+
+    if (fs.statSync(fullPath).isDirectory()) {
+      filePaths = getAllFiles(fullPath, filePaths);
+    } else {
+      filePaths.push(fullPath);
+    }
+  });
+
+  return filePaths;
+}
+
+async function uploadTos3(folderPath, settings) {
+  let uploadLists = [];
+  let datas = await bucketPathForUpload(folderPath, settings);
+  // console.log({ keys })
+  await Promise.all(
+    datas.map(async data => {
+      uploadLists.push(
+        s3.putObjectS3(_izContext, {
+          Bucket: 'integrationtest-config-us-east-2',
+          Key: data.key,
+          Body: data.fileContent,
+          ContentType: 'application/json'
+        })
+      );
+    })
+  );
+
+  await Promise.all(uploadLists);
+}
+
+export default { uploadTos3, bucketPathForUpload };

package/src/TemplateData/externalService/functionNameConfig/data.js

@@ -0,0 +1,178 @@
+/*
+Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import consts from '../../../libs/Consts.js';
+import utils from '../../../libs/Utils.js';
+
+const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = utils;
+const { SOURCE_PATH, SOURCE_GENERATE_IAM_ROLE } = consts;
+
+const templateYamlPath = path.join(__dirname, './templateYaml.ejs');
+const templatePathIntTestPath = path.join(
+  __dirname,
+  './templateIntTesting.ejs'
+);
+
+function data(_izContext, createSourceParams, srcPath) {
+  // ! old code
+  // function createFunctionNameConfigFileYaml(functionNameConfigs, srcPath) {
+  //   let createFunctionNameConfigYaml = []
+  //   createFunctionNameConfigYaml.push(
+  //     {
+  //       templatePath: templateYamlPath,
+  //       templateData: {
+  //         functionNameConfigs: functionNameConfigs
+  //       },
+  //       setting: {
+  //         savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+  //         saveFileName: "FunctionNameConfig",
+  //         fileExtension: ".yml",
+  //         isAppend: true
+  //       }
+  //     }
+  //   )
+  //   return createFunctionNameConfigYaml
+  // }
+
+  // Extract role names from object types in createSourceParams
+  const roleNameConfigs = new Set();
+  const roleNameConcatConfigs = new Set();
+
+  // Add default IAM roles from configuration
+  // Object.entries(SOURCE_GENERATE_IAM_ROLE)
+  //   .filter(([_, enabled]) => enabled)
+  //   .forEach(([_, value]) => {
+  //     if (value === SOURCE_GENERATE_IAM_ROLE.NodeCompleteRole) return;
+  //     roleNameConfigs.add(`${upperCase(value)}Role`);
+  //     roleNameConcatConfigs.add(`${upperCase(value)}`);
+  //   });
+  for (const data of createSourceParams) {
+    let roleName = data.templateData?.roleName;
+    if (roleName) {
+      if (roleName === SOURCE_GENERATE_IAM_ROLE.NodeCompleteRole) {
+        return;
+      }
+      roleNameConfigs.add(`${upperCase(roleName)}Role`);
+      roleNameConcatConfigs.add(`${upperCase(roleName)}`);
+    }
+  }
+
+  // Extract role names from templateData in createSourceParams
+  createSourceParams.forEach(({ templateData }) => {
+    if (templateData) {
+      const sourceName = templateData.roleName || templateData.objectType;
+      if (sourceName) {
+        const upperCasedName = upperCase(sourceName);
+        roleNameConfigs.add(`${upperCasedName}Role`);
+        roleNameConcatConfigs.add(upperCasedName);
+      }
+    }
+  });
+
+  // Generate YAML and JS configurations
+  const roleConfigYaml = createRoleNameConfigFileYaml(roleNameConfigs, srcPath);
+  const roleConfigJs = createRoleNameConfigFileJs(
+    roleNameConcatConfigs,
+    srcPath
+  );
+
+  // Combine and return all configurations
+  return [...roleConfigYaml, ...roleConfigJs];
+}
+
+// ! old code
+// function createFunctionNameConfigFileYaml(functionNameConfigs, srcPath) {
+//   let createFunctionNameConfigYaml = []
+//   createFunctionNameConfigYaml.push(
+//     {
+//       templatePath: templateYamlPath,
+//       templateData: {
+//         functionNameConfigs: functionNameConfigs
+//       },
+//       setting: {
+//         savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+//         saveFileName: "FunctionNameConfig",
+//         fileExtension: ".yml",
+//         isAppend: true
+//       }
+//     }
+//   )
+//   return createFunctionNameConfigYaml
+// }
+
+// ! old code
+// function createFunctionNameConfigFileJs(functionNameConfigs, srcPath) {
+//   let createFunctionNameConfigJs = []
+//   createFunctionNameConfigJs.push(
+//     {
+//       templatePath: templatePathIntTestPath,
+//       templateData: {
+//         functionNameConfigs: functionNameConfigs
+//       },
+//       setting: {
+//         savePath: path.join(srcPath, SOURCE_PATH.externalService),
+//         saveFileName: "FunctionNameConfig",
+//         fileExtension: ".js",
+//         isAppend: true
+//       }
+//     }
+//   )
+
+//   return createFunctionNameConfigJs
+// }
+
+function createRoleNameConfigFileYaml(roleNameConfigs, srcPath) {
+  let createRoleNameConfigYaml = [];
+  createRoleNameConfigYaml.push({
+    templatePath: templateYamlPath,
+    templateData: {
+      roleNameConfigs: roleNameConfigs
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+      saveFileName: 'RoleNameConfig',
+      fileExtension: '.yml',
+      isAppend: true
+    }
+  });
+  return createRoleNameConfigYaml;
+}
+
+function createRoleNameConfigFileJs(roleNameConfigs, srcPath) {
+  let createRoleNameConfigJs = [];
+  createRoleNameConfigJs.push({
+    templatePath: templatePathIntTestPath,
+    templateData: {
+      roleNameConfigs: roleNameConfigs
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.externalService),
+      saveFileName: 'RoleNameConfig',
+      fileExtension: '.js',
+      isAppend: true
+    }
+  });
+
+  return createRoleNameConfigJs;
+}
+
+export default data;

package/src/TemplateData/externalService/functionNameConfig/template.ejs

@@ -0,0 +1,14 @@
+# for createIamRole
+
+<% functionNameConfigs.forEach(functionNameConfig => { _%>
+- ${self:custom.iz_prefixIamRole}<%- firstLetterUpperCase(functionNameConfig) %>${self:custom.iz_suffixIamRole}
+<% }) _%>
+
+# for createIntTest
+<% functionNameConfigs.forEach(functionNameConfig => { _%>
+  "<%- firstLetterUpperCase(functionNameConfig) %>",
+<% }) _%>
+
+<%_function firstLetterUpperCase(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} %>