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

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

@@ -0,0 +1,415 @@
+import { consts } from '../../../../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 (Array.isArray(key)) {
+        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/reStructure/TemplateData/IntTest/upload/uploadIntTest.js

@@ -0,0 +1,60 @@
+/*
+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 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 uploadFolder(folderPath, s3Prefix) {
+  let objectToUploads = [];
+  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(fullPath, s3Key);
+    } else {
+
+      const fileStream = fs.createReadStream(fullPath);
+      const params = {
+        Bucket: "integrationtest-config-us-east-2",
+        Key: `test_config/${s3Key}`,
+        Body: fileStream,
+      };
+
+      objectToUploads.push(s3.putObjectS3(_izContext, params));
+
+      try {
+        await Promise.all(objectToUploads)
+        console.log("uploadComplete to", s3Key)
+        // console.log("Upload-Succuss:", s3Key, "ETag:", result.ETag);
+      } catch (err) {
+        // console.error("Upload-Failed:", s3Key, err);
+        console.log("Upload-Failed");
+      }
+    }
+  }
+}
+
+export default uploadFolder;

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

@@ -17,12 +17,16 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 'use strict';
 
-const path = require('path');
-const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = require("../../../../MainLibs/index.js").utils;
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { consts, utils } from '../../../../MainLibs/index.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");
-const { SOURCE_PATH, SOURCE_GENERATE_IAM_ROLE } = require("../../../../MainLibs/src/Consts.js");
-
 
 function data(_izContext, createSourceParams, srcPath) {
   // ! old code
@@ -169,4 +173,4 @@ function createRoleNameConfigFileJs(roleNameConfigs, srcPath) {
   return createRoleNameConfigJs
 }
 
-module.exports = data;
+export default data;

package/src/reStructure/TemplateData/externalService/functionNameConfig/templateIntTesting.ejs

@@ -17,7 +17,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 'use strict';
 
-module.exports.generatedIntTestRoleNameConfig = () => {
+export default function generatedIntTestRoleNameConfig  () {
 let roleNameConfigIntTest = [
     <% roleNameConfigs.forEach(roleNameConfig => { _%>
     "<%- firstLetterUpperCase(roleNameConfig) %>",

package/src/reStructure/TemplateData/externalService/generateTemplateData.js

@@ -18,17 +18,18 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 'use strict';
 
 // Import required modules
-const { join } = require('path');
-
+import { join } from 'path';
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
 const {
   getAllLocalObjectSchemasWithHierarchy,
   getAllLocalRelationshipSchema,
   getAllLocalFlowSchemas
-} = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
+} = getObjectSchema;
 
 // create External Service
-const createExternalLambdaRole = require('./lambdaRole/data');
-const createExternalSnsSubscriptions = require('./snsTopicSubscriptions/data');
+
+import createExternalLambdaRole from './lambdaRole/data.js';
+import createExternalSnsSubscriptions from './snsTopicSubscriptions/data.js';
 
 /**
  * Generates code with templates for different actions
@@ -41,7 +42,7 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
     const saveFilePath = join(objSchemaPath, '../');
     const createSourceParams = [];
     const allObjSchemas = await getAllLocalObjectSchemasWithHierarchy(_izContext, objSchemaPath);
-    const allObjectRelationships = getAllLocalRelationshipSchema(_izContext, objSchemaPath);
+    const allObjectRelationships = await getAllLocalRelationshipSchema(_izContext, objSchemaPath);
     const allLocalFlowSchemas = await getAllLocalFlowSchemas(_izContext, objSchemaPath);
     // create External service
     const createFunctionIamRole = await createExternalLambdaRole(_izContext, allObjSchemas, allObjectRelationships, allLocalFlowSchemas.records, saveFilePath);
@@ -56,4 +57,4 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
   }
 }
 
-module.exports = generateCodeWithTemplate;
+export default generateCodeWithTemplate;

package/src/reStructure/TemplateData/externalService/lambdaRole/data.js

@@ -16,17 +16,19 @@ 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);
 
-const path = require('path');
-const { ACTIONS, HANDLER, STORAGE_TYPES } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
-const {
-  getGraphServiceNameFromGraphServerTagWithCache,
-  getGraphServiceTagWithCache
-} = require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig')
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+const { getAllLocalRelationshipSchema } = getObjectSchema;
+
+import { consts as generateCodeLibsConsts } from '../../../../GenerateCodeLibs/index.js';
+const { EXTERNAL_SERVICE_NAME } = generateCodeLibsConsts;
 
-const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = require("../../../../MainLibs/src/Utils");
+import { consts as mainLibsConsts } from '../../../../MainLibs/index.js';
 const {
-  DEFAULT_HANDLER_PER_ACTION,
   createIamRole,
   RESOURCE_CLASSES,
   SOURCE_PATH,
@@ -35,18 +37,11 @@ const {
   SAVE_FILE_NAME,
   LAMBDA_RESOURCE,
   SNS_RESOURCE,
-  getGraphServiceNameFromObjectSchema,
-  shortNameHandler,
-  SHORT_FUNCTION_NAME,
-  defaultIamRolePerAction,
-  resourceNames,
   SOURCE_GENERATE_IAM_ROLE,
   getStorageResourceFromObjectSchemas,
-  FUNCTION_NAME
-} = require("../../../../MainLibs/src/Consts");
-const templatePath = path.join(__dirname, "./template.ejs");
-const { getAllLocalRelationshipSchema } = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema')
-const { EXTERNAL_SERVICE_NAME } = require("../../../../GenerateCodeLibs/src/Consts");
+} = mainLibsConsts;
+
+const templatePath = path.join(__dirname, 'template.ejs');
 
 const createExternalLambdaRole = async (_izContext, allObjSchemas, allRelSchemas, allLocalFlowSchemas, srcPath) => {
   // console.log("allRelationshipSchemas", allRelationshipSchemas);
@@ -332,4 +327,4 @@ async function externalRoleSnsPublish(_izContext, localFlowSchema) {
   };
 }
 
-module.exports = createExternalLambdaRole;
+export default createExternalLambdaRole;

package/src/reStructure/TemplateData/externalService/lambdaRole/template.ejs

@@ -17,15 +17,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 'use strict';
 
-const Logger = require('@izara_project/izara-core-library-logger')
-const dynamodbSharedLib = require('@izara_project/izara-core-library-dynamodb')
-const lambdaSharedLib = require('@izara_project/izara-core-library-lambda')
-const snsSharedLib = require('@izara_project/izara-core-library-sns')
-const initialSetupConfig = require('../../config/Config') // config external serviceName
-const basicNodeSchemaLib = require('@izara_project/izara-attribute-tree').basicNodeSchemaLib
+import Logger from '@izara_project/izara-core-library-logger';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
 const _izContext = {logger : Logger}
 
-module.exports.generatedLambdaRole = async () => {
+export default function generatedLambdaRole() {
   let externalLambdaRole = [ <%_ datas.forEach((data,dataIndex) => { %>
   {
     roleName: "<%- data.objectType %>",