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

package/src/TemplateData/EndpointPerService/yaml/data.js

@@ -0,0 +1,311 @@
+/*
+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 fs from 'fs';
+import yaml from 'yaml';
+import { objectHash as hash } from '@izara_project/izara-shared-core';
+
+import consts from '../../../libs/Consts.js';
+import utils from '../../../libs/Utils.js';
+import libs from '../../../libs/Libs.js';
+const {
+  ACTIONS,
+  HANDLER,
+  STORAGE_TYPES,
+  DEFAULT_HANDLER_PER_ACTION,
+  RESOURCE_CLASSES,
+  SOURCE_PATH,
+  SAVE_FILE_NAME,
+  DYNAMO_RESOURCE,
+  SNS_RESOURCE,
+  FUNCTION_NAME,
+  SOURCE_GENERATE_IAM_ROLE,
+  SQS_RESOURCE,
+} = consts;
+
+const {
+  createIamRole,
+  resourceNames,
+  defaultIamRolePerAction,
+  awaitingMultipleStepsRole,
+  shortNameHandler,
+  getStorageResourceFromObjectSchemas,
+  externalResourceYaml
+} = libs;
+
+const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = utils;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * receive objectSchema
+ * create data for hdrInv template
+ *
+ * @param {Object} objectSchema
+ * @return {{ templatePath, templateData, setting } }
+ */
+async function data(_izContext, allObjSchemas, srcPath) {
+  let createSourceParams = [];
+  // console.debug('templatePath:::', templatePath)
+  for (const action of Object.values(ACTIONS)) {
+    const defaultHandlers = DEFAULT_HANDLER_PER_ACTION[action];
+    for (const defaultHandler of defaultHandlers) {
+      const createSourceParam = await createParamForCreateSource(
+        _izContext,
+        allObjSchemas,
+        action,
+        defaultHandler,
+        srcPath
+      );
+      if (
+        createSourceParam &&
+        !createSourceParams.includes(createSourceParam)
+      ) {
+        createSourceParams.push(createSourceParam);
+      }
+    }
+  }
+  return createSourceParams;
+}
+
+async function createParamForCreateSource(
+  _izContext,
+  allObjSchemas,
+  action,
+  handler,
+  srcPath
+) {
+  let groupBy = SOURCE_GENERATE_IAM_ROLE.PerActionEndpoint;
+  let additionalResourcePermission = defaultIamRolePerAction();
+  let functionNameConfig =
+    upperCase(action) + upperCase(shortNameHandler(handler));
+
+  let storageResourceAllLocalObjectSchemas =
+    await getStorageResourceFromObjectSchemas(_izContext, allObjSchemas);
+
+  if (storageResourceAllLocalObjectSchemas.resourceDynamoTableName.length) {
+    additionalResourcePermission.push(
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.dynamoDbTable]: Object.values(DYNAMO_RESOURCE)
+        },
+        storageResourceAllLocalObjectSchemas.resourceDynamoTableName.map(
+          tableName =>
+            resourceNames(RESOURCE_CLASSES.dynamoDbTable, upperCase(tableName))
+        )
+      )
+    );
+  }
+
+  function httpEvent(lambdaAction) {
+    return {
+      create: 'put',
+      update: 'post',
+      get: 'post',
+      delete: 'delete'
+    }[lambdaAction];
+  }
+
+  function sqsEvent(handler) {
+    return {
+      [HANDLER.hdrSqs]: resourceNames(
+        RESOURCE_CLASSES.sqs,
+        upperCase(action) + upperCase(HANDLER.hdrSqs)
+      ),
+      [HANDLER.hdrDsq]: resourceNames(
+        RESOURCE_CLASSES.sqs,
+        upperCase(action) + upperCase(HANDLER.hdrDsq)
+      )
+    }[handler];
+  }
+
+  let event;
+  if (handler === HANDLER.hdrApi) {
+    event = httpEvent(action);
+  } else if (handler === HANDLER.hdrDsq || handler === HANDLER.hdrSqs) {
+    event = sqsEvent(handler);
+  }
+
+  additionalResourcePermission.push(awaitingMultipleStepsRole());
+
+  additionalResourcePermission.push(
+    createIamRole({ [RESOURCE_CLASSES.sns]: SNS_RESOURCE.publish }, [
+      resourceNames(
+        RESOURCE_CLASSES.sns,
+        upperCase(FUNCTION_NAME.createObjectComplete) + '_Out'
+      ),
+      resourceNames(
+        RESOURCE_CLASSES.sns,
+        upperCase(FUNCTION_NAME.updateNodeComplete) + '_Out'
+      ),
+      resourceNames(
+        RESOURCE_CLASSES.sns,
+        upperCase(FUNCTION_NAME.deleteNodeComplete) + '_Out'
+      ),
+      resourceNames(
+        RESOURCE_CLASSES.sns,
+        upperCase(FUNCTION_NAME.getNodeComplete) + '_Out'
+      )
+    ])
+  );
+
+  if (handler === HANDLER.hdrSqs) {
+    additionalResourcePermission.push(
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sqs]: [
+            SQS_RESOURCE.receiveMessage,
+            SQS_RESOURCE.sendMessage,
+            SQS_RESOURCE.deleteMessage,
+            SQS_RESOURCE.getQueueAttributes
+          ]
+        },
+        [
+          resourceNames(
+            RESOURCE_CLASSES.sqs,
+            upperCase(action) + upperCase(handler)
+          ),
+          resourceNames(
+            RESOURCE_CLASSES.sqs,
+            upperCase(action) + upperCase(handler) + 'DLQ'
+          )
+        ]
+      )
+    );
+  }
+
+  const configPath = path.join(srcPath, '../../config/serverless.config.yml');
+  const serverlessConfig = fs.readFileSync(configPath, 'utf8');
+  const config = yaml.parse(serverlessConfig);
+  const ownServiceTag = config.main_config.iz_serviceTag;
+  let parentTables = [];
+  let externalTopicComponents = [];
+  // create lambdaRole for parent dynamo table if able
+  for (const objectSchema of allObjSchemas.records) {
+    for (const storageResource of Object.values(
+      objectSchema.storageResources
+    )) {
+      if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+        if (objectSchema.hasOwnProperty('extendObjType')) {
+          if (
+            storageResource.serviceTag &&
+            storageResource.serviceTag !== ownServiceTag
+          ) {
+            parentTables.push({
+              tableName: upperCase(storageResource.tableName),
+              serviceTag: upperCase(storageResource.serviceTag)
+            });
+          }
+        }
+      }
+
+      if (storageResource.storageType === STORAGE_TYPES.externalTopic) {
+        let uniqueTag = hash({
+          accountId: storageResource.accountId,
+          region: storageResource.region,
+          serviceTag: storageResource.serviceTag,
+          stage: storageResource.stage
+        });
+
+        if (!externalTopicComponents.includes(uniqueTag)) {
+          externalTopicComponents.push({
+            [uniqueTag]: {
+              accountId: storageResource.accountId,
+              region: storageResource.region,
+              serviceTag: storageResource.serviceTag,
+              stage: storageResource.stage
+            }
+          });
+        }
+      }
+    }
+  }
+
+  if (parentTables.length > 0) {
+    additionalResourcePermission.push(
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.dynamoDbTable]: Object.values(DYNAMO_RESOURCE)
+        },
+        parentTables.map(parentTable =>
+          externalResourceYaml(
+            RESOURCE_CLASSES.dynamoDbAcrossService,
+            upperCase(parentTable.tableName),
+            parentTable.serviceTag
+          )
+        )
+      )
+    );
+  }
+
+  let resourceApis = [];
+  if (handler === HANDLER.hdrApi) {
+    for (const objectSchema of allObjSchemas.records) {
+      resourceApis.push({
+        event: lowerCase(objectSchema.objectType),
+        method: httpEvent(action)
+      });
+    }
+  }
+
+  if (externalTopicComponents.length > 0) {
+    if (action === ACTIONS.create) {
+      externalTopicComponents.map(component => {
+        for (const [_, compo] of Object.entries(component)) {
+          additionalResourcePermission.push(
+            createIamRole(
+              {
+                [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+              },
+              [
+                `arn:aws:sns:${compo.region}:${compo.accountId}:${compo.serviceTag}_${compo.stage}_Create_In`
+              ]
+            )
+          );
+        }
+      });
+    }
+  }
+
+  return {
+    templatePath: templatePath,
+    templateData: {
+      resourceLocation: SOURCE_PATH.resourceLocationHandlerEndpointPerService,
+      handlerType: handler,
+      additionalResourcePermission,
+      event: event,
+      roleName: groupBy,
+      action: action,
+      functionNameConfig,
+      resourceApis,
+      serviceTag: ownServiceTag
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+      saveFileName: SAVE_FILE_NAME.functionPerActionYaml,
+      fileExtension: '.yml',
+      isAppend: true
+    }
+  };
+}
+
+export default data;

package/src/TemplateData/EndpointPerService/yaml/template.ejs

@@ -0,0 +1,35 @@
+<%_ const join = require('path').join _%>
+<%- firstLetterUpperCase(functionNameConfig) %>:
+  handler: <%- join(resourceLocation, `${firstLetterUpperCase(action)}_${firstLetterUpperCase(handlerType)}.main`) %>
+  name: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(action) %><%- firstLetterUpperCase(handlerType) %>
+  role: <%- firstLetterUpperCase(roleName) _%>Role
+  #<#<%- firstLetterUpperCase(action) %><%- firstLetterUpperCase(handlerType) %>FunctionSetting#>
+  #<#/<%- firstLetterUpperCase(action) %><%- firstLetterUpperCase(handlerType) %>FunctionSetting#>
+  <%_ if (handlerType === "hdrDsq" || handlerType === "hdrSqs") { _%>
+  events:
+    - sqs:
+        arn: <%- event %>
+        batchSize: 10
+  <%_ } else if (handlerType === "hdrApi") { _%>
+  events:
+    <%_ resourceApis.forEach(resourceApi => { _%>
+    - httpApi:
+        path: /<%- serviceTag %>/<%- resourceApi.event %>/<%- action %>
+        method: <%- resourceApi.method %>
+        authorizer: authorizerServiceSchema
+        #<#<%- firstLetterUpperCase(resourceApi.event) _%><%- firstLetterUpperCase(handlerType) %>AppLevelAuthorizer#>
+        #<#/<%- firstLetterUpperCase(resourceApi.event) _%><%- firstLetterUpperCase(handlerType) %>AppLevelAuthorizer#>
+    - httpApi:
+        path: /<%- serviceTag %>/<%- resourceApi.event %>/<%- action %>/{targetUserId}
+        method: <%- resourceApi.method %>
+        authorizer: authorizerIdentifiers
+        #<#<%- firstLetterUpperCase(resourceApi.event) _%><%- firstLetterUpperCase(handlerType) %>UserLevelAuthorizer#>
+        #<#/<%- firstLetterUpperCase(resourceApi.event) _%><%- firstLetterUpperCase(handlerType) %>UserLevelAuthorizer#>
+          <%_ }) _%>
+  <%_ } _%>
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
+<%_ function firstLetterLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1)
+} _%>

package/src/TemplateData/IntTest/generateResources/generateResources.js

@@ -0,0 +1,113 @@
+/*
+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 { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+import util from '../../../libs/Utils.js'
+import intTestLibs from '../libs/libs.js';
+const { directoryPath } = intTestLibs;
+const { getLocalConfig } = util;
+const templatePath = path.join(__dirname, './templateResources.ejs');
+
+/**
+ * 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) {
+  try {
+    let allCreateSource = [];
+
+    let schemaPath = path.join(savePath, '../ schemas');
+    let slsYmlPath = path.join(
+      savePath,
+      '../../sls_yaml/generatedCode/source/'
+    );
+    let serviceTag = getLocalConfig('iz_serviceTag');
+    let functionPath = path.join(savePath, '../../sls_yaml/');
+    // console.log("serviceTag", serviceTag);
+
+    // let allObjectSchema = await getObjectSchemas.getAllLocalObjectSchemasWithHierarchy(_izContext, schemaPath)
+    let allObjectSchema = await getObjectSchema.getAllLocalObjectSchemas(
+      _izContext,
+      schemaPath
+    ); // get ObjectSchemas Local
+
+    let allObjectSchemas = allObjectSchema.records;
+
+    let tableNames = [];
+    for (let objectSchema of allObjectSchemas) {
+      // console.log("objectSchema", objectSchema)
+      for (let storageResource of Object.values(
+        objectSchema.storageResources
+      )) {
+        // console.log("storageResource_Data", storageResource)
+        if (storageResource.storageType === 'dynamoDB') {
+          // console.log("storageResource_Data_Before_Push_Dynamo", storageResource)
+          tableNames.push(storageResource.tableName);
+        }
+      }
+    }
+
+    const generateFunctionComponent = directoryPath(slsYmlPath);
+    const mainFunctionComponent = directoryPath(functionPath);
+    // console.log({ mainFunctionComponent, generateFunctionComponent })
+    let lambdaComponent = {
+      ...generateFunctionComponent,
+      ...mainFunctionComponent
+    };
+    let s3Component = {};
+    for (const lambdaFunctionName in lambdaComponent) {
+      if (lambdaFunctionName.endsWith('S3')) {
+        s3Component[lambdaFunctionName] = lambdaComponent[lambdaFunctionName];
+        delete lambdaComponent[lambdaFunctionName];
+      }
+    }
+    // console.log(s3Component);
+
+    allCreateSource.push({
+      templatePath: templatePath,
+      templateData: {
+        tableNames,
+        functionComponent: lambdaComponent,
+        s3Component
+      },
+      setting: {
+        generateHookFile: false,
+        savePath: path.join(savePath, `${serviceTag}/sharedResources/`),
+        saveFileName: 'resources',
+        fileExtension: '.json',
+        isAppend: false
+      }
+    });
+
+    return allCreateSource;
+  } catch (error) {
+    _izContext.logger.error(
+      'Error generating code with template propertyNode schema:',
+      error
+    );
+    return [];
+  }
+}
+
+export default generateCodeWithTemplate;

package/src/TemplateData/IntTest/generateResources/templateResources.ejs

@@ -0,0 +1,33 @@
+{
+  "Lambda": {
+    <% Object.entries(functionComponent).forEach(([funcName, filePath], index, array) => { %>
+      "<%= funcName %>": {
+        "localLocation": "/<%= filePath %>.js",
+        "localHandler": "main",
+        "functionName": "<%= funcName %>"
+      }<%= index < array.length - 1 ? "," : "" %>
+    <% }) %>
+  }<%= Object.keys(s3Component).length || Object.keys(tableNames).length ? "," : "" %>
+
+  <% if (Object.keys(s3Component).length) { %>
+  "S3": {
+    <% Object.entries(s3Component).forEach(([functionName, filePath], index, array) => { %>
+      "<%= functionName %>": {
+        "localLocation": "/<%= filePath %>",
+        "localHandler": "main",
+        "functionName": "<%= functionName %>"
+      }<%= index < array.length - 1 ? "," : "" %>
+    <% }) %>
+  }<%= Object.keys(tableNames).length ? "," : "" %>
+  <% } %>
+
+  <% if (Object.keys(tableNames).length) { %>
+  "Dynamodb": {
+    <% tableNames.forEach((tableName, index) => { %>
+      "<%= tableName %>": {
+        "tableName": "<%= tableName %>"
+      }<%= index < tableNames.length - 1 ? "," : "" %>
+    <% }) %>
+  }
+  <% } %>
+}

package/src/TemplateData/IntTest/generateTests/events/data.js

@@ -0,0 +1,137 @@
+/*
+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, { join } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const templatePath = path.join(__dirname, './templateEvents.ejs');
+import utils from '../../../../libs/Utils.js';
+const { getLocalConfig } = utils;
+
+import libs from '../../libs/libs.js';
+const {
+  setEvent,
+  createEventCaseByHandler,
+  setEventInvoke,
+  setEventDynamo,
+  getHandlerFromEventTag
+} = libs;
+
+async function data(_izContext, allIntTestConfig, srcPath) {
+  let createEventSources = [];
+  let serviceTag = getLocalConfig('iz_serviceTag');
+
+  // console.log({ allIntegrationTestConfig })
+
+  for (const intTest of allIntTestConfig) {
+    for (const [testTag, config] of Object.entries(intTest)) {
+      // console.log(testTag, config)
+      for (const eachStage of config.testStages) {
+        let inputEventTag = eachStage.eventTag;
+        let outputEventTag = `Output_${inputEventTag}`;
+
+        let inputConfig = {
+          forStageMatching: true,
+          ...setEvent(
+            eachStage.inputConfig.inputEvent,
+            eachStage.inputConfig.inputEventSettings
+          ),
+          ...createEventCaseByHandler(
+            getHandlerFromEventTag(inputEventTag),
+            eachStage.inputConfig.messageAttributes
+          )
+        };
+
+        let outputConfig = {
+          forStageMatching: true,
+          ...setEvent(
+            eachStage.outputConfig.outputEvent,
+            eachStage.outputConfig.outputEventSettings
+          )
+        };
+
+        let eventDynamos = [];
+        if (eachStage.dynamoDBConfig && eachStage.dynamoDBConfig.length > 0) {
+          // validate Dynamo
+          // console.log("have dynamoConfig", inputEventTag, eachStage.dynamoDBConfig)
+          for (const dynamoDBConfig of eachStage.dynamoDBConfig) {
+            let eventDynamo = {
+              keyValues: dynamoDBConfig.dynamoEvent.identifiers,
+              forStageMatching: true,
+              ...setEventDynamo(
+                dynamoDBConfig.dynamoEvent.fields,
+                dynamoDBConfig.dynamoEventSettings
+              )
+            };
+            eventDynamos.push({
+              eventTag:
+                inputEventTag + '__Dynamodb_' + dynamoDBConfig.eventDynamoTag,
+              event: eventDynamo
+            });
+          }
+        }
+
+        let eventInvokes = [];
+        if (eachStage.invokeConfig && eachStage.invokeConfig.length > 0) {
+          // Validate Invokes
+          for (const invokeConfig of eachStage.invokeConfig) {
+            let invokeEventComponents = setEventInvoke(invokeConfig);
+            eventInvokes.push(...invokeEventComponents);
+          }
+        }
+
+        if (getHandlerFromEventTag(testTag) === 'S3') {
+          if (
+            config.hasOwnProperty('s3Config') &&
+            Object.keys(config.s3Config).length > 0
+          ) {
+            Object.assign(inputConfig, {
+              uploadS3: true,
+              uploadS3Setting: config.s3Config
+            });
+          }
+        }
+        createEventSources.push({
+          templatePath: templatePath,
+          templateData: {
+            inputEventTag,
+            outputEventTag,
+            inputConfig,
+            outputConfig,
+            eventDynamos,
+            eventInvokes: eventInvokes || []
+          },
+          setting: {
+            generateHookFile: false,
+            savePath: path.join(
+              srcPath,
+              `./${serviceTag}/${testTag}/${inputEventTag}/`
+            ),
+            saveFileName: 'events',
+            fileExtension: '.json',
+            isAppend: false
+          }
+        });
+      }
+    }
+  }
+
+  return createEventSources;
+}
+
+export default data;

package/src/TemplateData/IntTest/generateTests/events/templateEvents.ejs

@@ -0,0 +1,11 @@
+{
+  "<%- inputEventTag %>": <%- JSON.stringify(inputConfig, null, 2) %>,
+  "<%- outputEventTag %>": <%- JSON.stringify(outputConfig, null, 2) %> <% eventDynamos.length ? "," : "" -%>
+  <% eventDynamos.forEach((eventDynamo,idx) => { %>
+      "<%- eventDynamo.eventTag %>": <%- JSON.stringify(eventDynamo.event,null,2) %> <% idx < eventDynamos.length - 1 ? ",": "" -%>
+  <% }) %> <% eventInvokes.length ? "," : "" %>
+  <% eventInvokes.forEach((invokeEventComponent,index) => { %>
+  "<%- invokeEventComponent.inputInvokeName %>": <%- JSON.stringify(invokeEventComponent.inputInvoke,null,2) %>,
+  "<%- invokeEventComponent.outputInvokeName %>": <%- JSON.stringify(invokeEventComponent.outputInvoke,null,2) %><%= index < eventInvokes.length - 1 ? ',': "" -%>
+  <% }) %>
+}