@izara_project/izara-core-generate-service-code 1.0.19 → 1.0.21

package/src/{TemplateData → generateResources}/IntTest/libs/libs.js

@@ -1,17 +1,17 @@
 import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
 const { getDataFromPath } = getObjectSchema;
-import yaml from "yaml";
+import yaml from 'yaml';
 import fs from 'fs';
-import consts from '../../../libs/Consts.js'
-const { HANDLER } = consts
+import consts from '#libs/Consts.js';
+const { HANDLER } = consts;
 
 function lowercaseFirst(str) {
-  if (!str) return "";
+  if (!str) return '';
   return str[0].toLowerCase() + str.slice(1);
 }
 
 function directoryPath(dirPath) {
-  let result = []
+  let result = [];
   const items = fs.readdirSync(dirPath);
   for (let item of items) {
     const fullPath = path.join(dirPath, item);
@@ -20,11 +20,14 @@ function directoryPath(dirPath) {
     if (stat.isDirectory()) {
       directoryPath(fullPath, result); // recursion
     } else if (stat.isFile()) {
-      if (!fullPath.includes("shared-resource.yml") && !fullPath.includes("core-function.yml")) {
+      if (
+        !fullPath.includes('shared-resource.yml') &&
+        !fullPath.includes('core-function.yml')
+      ) {
         if (fullPath.endsWith('.yml')) {
           result.push(fullPath);
         } else {
-          console.log("Skipped File:", fullPath);
+          console.log('Skipped File:', fullPath);
         }
       }
     }
@@ -32,28 +35,29 @@ function directoryPath(dirPath) {
 
   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 clearName = component.name.replace(
+          '${self:custom.iz_resourcePrefix}',
+          ''
+        );
         const clearMain = component.handler.replace(/\.main$/, '');
-        Object.assign(functionComponent, { [clearName]: clearMain })
+        Object.assign(functionComponent, { [clearName]: clearMain });
       }
     }
   }
-  return functionComponent
+  return functionComponent;
 }
 
-function createTestFunctionName(eventTag) { // set resourceName GCTpBas_Create
+function createTestFunctionName(eventTag) {
+  // set resourceName GCTpBas_Create
   let functionName;
-  if (eventTag.includes("__case")) {
-    let mainPart = eventTag.split("__case")[0];
+  if (eventTag.includes('__case')) {
+    let mainPart = eventTag.split('__case')[0];
     let mainPartShort = mainPart.slice(0, -6);
-    let lastUnderscoreIndex = mainPartShort.lastIndexOf("_");
+    let lastUnderscoreIndex = mainPartShort.lastIndexOf('_');
 
     if (lastUnderscoreIndex !== -1) {
       functionName = mainPartShort.substring(lastUnderscoreIndex + 1);
@@ -78,14 +82,14 @@ function setEvent(input, settings = {}) {
   const isEqual = settings?.isEqual || [];
 
   if (Array.isArray(input)) {
-    return { eventValue: input }
+    return { eventValue: input };
   }
 
   if (input === undefined) {
-    return { value: "undefined" };
+    return { value: 'undefined' };
   }
 
-  if (typeof input === "object") {
+  if (typeof input === 'object') {
     if (input === null) {
       return { value: input };
     }
@@ -111,10 +115,13 @@ function setEvent(input, settings = {}) {
         field.useIsEqual = true;
       }
 
-      if (typeof transformatValue === "object" && !Array.isArray(transformatValue)) {
+      if (
+        typeof transformatValue === 'object' &&
+        !Array.isArray(transformatValue)
+      ) {
         transformedObject[key] = {
           ...field,
-          ...transformatValue,
+          ...transformatValue
         };
       } else {
         transformedObject[key] = transformatValue;
@@ -124,9 +131,9 @@ function setEvent(input, settings = {}) {
   }
 
   if (
-    typeof input === "string" ||
-    typeof input === "number" ||
-    typeof input === "boolean"
+    typeof input === 'string' ||
+    typeof input === 'number' ||
+    typeof input === 'boolean'
   ) {
     return { value: input };
   }
@@ -141,10 +148,8 @@ function setEventDynamo(dynamoInput, settings = {}) {
   const testValueMatches = settings?.testValueMatches || [];
   const isEqual = settings?.isEqual || [];
 
-  if (typeof dynamoInput === "object") {
-
+  if (typeof dynamoInput === 'object') {
     for (const key in dynamoInput) {
-
       const transformatValue = setEventDynamo(input[key], settings);
       const field = {};
 
@@ -161,25 +166,26 @@ function setEventDynamo(dynamoInput, settings = {}) {
         field.isEqual = true;
       }
 
-
-      if (typeof transformatValue === "object" && !Array.isArray(transformatValue)) {
+      if (
+        typeof transformatValue === 'object' &&
+        !Array.isArray(transformatValue)
+      ) {
         transformedObject[key] = {
           ...field,
-          ...transformatValue,
+          ...transformatValue
         };
       } else {
         transformedObject[key] = transformatValue;
       }
     }
     return { properties: transformedObject };
-
   }
 
   return dynamoInput;
 }
 
-
-function setEventMessageAttributes(attributes = {}) { // set event MessageAttributes
+function setEventMessageAttributes(attributes = {}) {
+  // set event MessageAttributes
   const result = {};
   for (const key in attributes) {
     result[key] = {
@@ -189,72 +195,76 @@ function setEventMessageAttributes(attributes = {}) { // set event MessageAttrib
   return result;
 }
 
-function setEventInvoke(configs, invokeComponents = []) {   // set Event Invoke
+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.outputConfig.outputInvokeSettings)
+  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.outputConfig.outputInvokeSettings
+  );
 
   invokeComponents.push({
     inputInvokeName,
     outputInvokeName,
     inputInvoke,
     outputInvoke
-  })
-  let invokeConfigs = configs.invokeConfig
+  });
+  let invokeConfigs = configs.invokeConfig;
   if (invokeConfigs && invokeConfigs.length && invokeConfigs.length > 0) {
     for (let invokeConfig of configs.invokeConfig) {
-
-      setEventInvoke(invokeConfig, invokeComponents)
+      setEventInvoke(invokeConfig, invokeComponents);
     }
   }
-  return invokeComponents
+  return invokeComponents;
 }
 // setEvent
 
-
 // setTests
 
-function setDynamoIdentifierTests(dynamoDBConfigs, serviceTags, inputEventName) {
+function setDynamoIdentifierTests(
+  dynamoDBConfigs,
+  serviceTags,
+  inputEventName
+) {
   // console.log("dynamoDBConfigs", dynamoDBConfigs);
   // let stage = process.env.iz_stage
-  let dynamodbOutputEventIdentifiers = []
+  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) {
+      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}`
+        serviceTag = dynamoDBConfig.resourcePrefix;
 
+        resourceName = `${dynamoDBConfig.resourceName}`;
       } else if (dynamoDBConfig.resourceName) {
-
-        resourceName = `${dynamoDBConfig.resourceName}`
-        serviceTag = serviceTags
+        resourceName = `${dynamoDBConfig.resourceName}`;
+        serviceTag = serviceTags;
       }
 
-      eventTag = `${inputEventName + "__Dynamodb_"}${dynamoDBConfig.eventDynamoTag}`
-      dynamodbOutputEventIdentifiers.push(
-        {
-          serviceTag: serviceTag, // new Set
-          resourceName, // new set
-          eventTag // eventTag + stage + resourceName
-        }
-      )
+      eventTag = `${inputEventName + '__Dynamodb_'}${dynamoDBConfig.eventDynamoTag}`;
+      dynamodbOutputEventIdentifiers.push({
+        serviceTag: serviceTag, // new Set
+        resourceName, // new set
+        eventTag // eventTag + stage + resourceName
+      });
     }
-
   }
-  return dynamodbOutputEventIdentifiers
+  return dynamodbOutputEventIdentifiers;
 }
 
 function setInvokeTest(
@@ -266,7 +276,9 @@ function setInvokeTest(
   for (const inputConfig of inputInvokeConfigs) {
     const eventStageTag = inputConfig.eventStageTag;
 
-    const [serviceTag, functionName] = createResourceName(eventStageTag + "__case_");
+    const [serviceTag, functionName] = createResourceName(
+      eventStageTag + '__case_'
+    );
     const inputEventTag = `${eventStageTag}__case_${inputConfig.inputEventTag}`;
 
     invokeEventTags.push({ eventStageTag });
@@ -275,13 +287,21 @@ function setInvokeTest(
       eventStageTag,
       inputEventTag,
       serviceTag,
-      resourceType: "Lambda",
+      resourceType: 'Lambda',
       resourceName: functionName,
       outputEventTag: `Output_${inputEventTag}`
     });
 
-    if (Array.isArray(inputConfig.invokeConfig) && inputConfig.invokeConfig.length > 0) {
-      setInvokeTest(inputConfig.invokeConfig, invokeEventTags, invokeStages, level + 1);
+    if (
+      Array.isArray(inputConfig.invokeConfig) &&
+      inputConfig.invokeConfig.length > 0
+    ) {
+      setInvokeTest(
+        inputConfig.invokeConfig,
+        invokeEventTags,
+        invokeStages,
+        level + 1
+      );
     }
   }
 
@@ -291,23 +311,28 @@ function setInvokeTest(
   };
 }
 
-function setNoInvokeTest(invokeConfigs, serviceTag, functionName, eventStages = []) {  // function set Not invoke
-  let stageKeep = {}
-  let eventStageTags = invokeConfigs.eventStageTag
-  let inputEventTags = `${eventStageTags}"__case_"${invokeConfigs.inputEventTag}`
+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",
+      resourceType: 'Lambda',
       resourceName: functionName,
-      outputEventTag: `${"Output_" + inputEventTags}`
-    })
+      outputEventTag: `${'Output_' + inputEventTags}`
+    });
   }
-  eventStages.push(stageKeep)
+  eventStages.push(stageKeep);
 
   return eventStages;
 }
@@ -324,55 +349,58 @@ function createEventCaseByHandler(handler, messageAttributes = {}) {
         ? { messageAttributes: setEventMessageAttributes(messageAttributes) }
         : {})
     }
-  }
-  [handler]
+  }[handler];
 }
 
 function getHandlerFromEventTag(testTag) {
-  let mainPart = testTag.split("__case")[0];
+  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"
+  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")
+      throw new Error('not have handler');
     }
   }
-  return handler
+  return handler;
 }
 
 function getHandlerFromTestTag(eventTag) {
-  let handler = "";
-  if (eventTag.includes("__case")) {
-    let mainPart = eventTag.split("__case")[0];
+  let handler = '';
+  if (eventTag.includes('__case')) {
+    let mainPart = eventTag.split('__case')[0];
     handler = mainPart.slice(-6);
   }
-  handler = lowercaseFirst(handler) //
-  return handler
-
+  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]
+  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)
+  return await getDataFromPath(
+    _izContext,
+    'GenerateIntegrationTestConfig.js',
+    intTestPath
+  );
 }
 
 function buildInvokeStages(invokeList, result = []) {
   for (const inv of invokeList) {
     const inStage = {
-      type: "invoke",
+      type: 'invoke',
       eventStageTag: inv.eventStageTag,
       inputEventTag: `${inv.eventStageTag}__case_${inv.inputEventTag}`,
       inputConfig: inv.inputConfig,
-      outputConfig: inv.outputConfig,
+      outputConfig: inv.outputConfig
     };
 
     result.push(inStage);
@@ -399,5 +427,5 @@ export default {
   getHandlerFromTestTag,
   createResourceName,
   setInvokeTest,
-  getIntTestConfig,
-}
+  getIntTestConfig
+};

package/src/{GenerateResources.js → generateResources.js}

@@ -23,10 +23,11 @@ import { readFileSync } from 'fs';
 
 // SourceManager
 import createSource from './SourceManager/CreateSource.js';
-import utils from './libs/Utils.js'
+import utils from '#libs/Utils.js';
 const { deleteFileInDir } = utils;
 
-import generateResource from './TemplateData/IntTest/generateResources/generateResources.js';
+// import generateResource from './TemplateData/IntTest/generateResources/generateResources.js';
+import generateResource from './generateResources/IntTest/generateResources/generateResources.js';
 
 async function generateCodeWithTemplate(_izContext, savePath, settings) {
   try {

package/src/{GenerateTests.js → generateTests.js}

@@ -24,11 +24,12 @@ import { readFileSync } from 'fs';
 // SourceManager
 import createSource from './SourceManager/CreateSource.js';
 
-import generateTest from './TemplateData/IntTest/generateTests/generateTemplate.js';
+// import generateTest from './TemplateData/IntTest/generateTests/generateTemplate.js';
+import generateTest from './generateResources/IntTest/generateTests/generateTemplate.js';
 
 import lib from './libs/Utils.js';
 const { getLocalConfig } = lib;
-import uploadLib from './TemplateData/IntTest/upload/uploadIntTest.js';
+import uploadLib from './generateResources/IntTest/upload/uploadIntTest.js';
 async function generateCodeWithTemplate(_izContext, savePath, settings) {
   _izContext.logger.debug('START', { savePath, settings });
   try {