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

package/src/libs/Libs.js

@@ -0,0 +1,379 @@
+/*
+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 { serviceConfig } from '@izara_project/izara-core-library-service-schemas';
+import consts from './Consts.js';
+const {
+  STORAGE_TYPES,
+  RESOURCE_CLASSES,
+  DYNAMO_RESOURCE,
+  S3_RESOURCE,
+  FIELD_NAME_TYPE,
+} = consts;
+
+import utils from "./Utils.js";
+const { firstLetterUpperCase: upperCase, getLocalConfig } = utils;
+
+/**
+ *
+ * @param {string} resourceClass
+ * @param {string} resourceName
+ * @returns {string}
+ */
+function resourceNames(resourceClass, resourceName) {
+  return {
+    [RESOURCE_CLASSES.sqs]: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}" + resourceName,
+    [RESOURCE_CLASSES.s3]: "arn:aws:s3:::" + resourceName,
+    [RESOURCE_CLASSES.dynamoDbTable]: "arn:aws:dynamodb:${self:custom.iz_region}:${self:custom.iz_accountId}:table/${self:custom.iz_resourcePrefix}" + resourceName,
+    [RESOURCE_CLASSES.sns]: "arn:aws:sns:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_serviceTag}_${self:custom.iz_stage}_" + resourceName,
+    [RESOURCE_CLASSES.lambda]: "arn:aws:lambda:${self:custom.iz_region}:${self:custom.iz_accountId}:function:${self:custom.iz_resourcePrefix}" + resourceName,
+    [RESOURCE_CLASSES.webSocket]: "arn:aws:execute-api:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_webSocketHostId}/${self:custom.iz_stage}/POST/@connections/{connectionId}"
+  }[resourceClass];
+}
+
+/**
+ *
+ * @param {string} action
+ * @param {string} resource
+ * @param {string} effect - optional default Allow
+ * @returns {{ effect, action, resource}}
+ */
+function createIamRole(action, resource = [], effect = "Allow") {
+  if (Array.isArray(action)) {
+    const actionObj = {};
+    action.forEach(act => {
+      if (act.includes(":")) {
+        const [serviceAction, resourceAction] = act.split(":")
+        actionObj[serviceAction] = [upperCase(resourceAction)]
+      }
+    });
+    action = actionObj
+  } else {
+    for (const resourceAction in action) {
+      if (typeof (action[resourceAction]) === 'string') {
+        action[resourceAction] = [action[resourceAction]]
+      }
+
+      if (!Array.isArray(action[resourceAction])) {
+        throw new Error(`resourceAction:${resourceAction} should be string or array`);
+      }
+    }
+  }
+
+  return {
+    effect,
+    action,
+    resource
+  };
+}
+
+function externalResourceName(resourceClass, resourceName, serviceTag) {
+  return {
+    [RESOURCE_CLASSES.dynamoDbTable]: "arn:aws:dynamodb:${process.env.iz_region}:${process.env.iz_accountId}:table/${dynamoSharedLib.tableName(_izContext, " + `"${resourceName}" ,"${serviceTag}")}`,
+    // [RESOURCE_CLASSES.dynamoDbAcrossService]: "arn:aws:dynamodb:${process.env.iz_region}:${process.env.iz_accountId}:table/*/" + `${resourceName}`,
+    [RESOURCE_CLASSES.dynamoDbAcrossService]: "arn:aws:dynamodb:${process.env.iz_region}:${process.env.iz_accountId}:table/" + `"${serviceTag}"` + `"${resourceName}"`,
+    [RESOURCE_CLASSES.lambda]: "arn:aws:lambda:${process.env.iz_region}:${process.env.iz_accountId}:function:${lambdaSharedLib.lambdaFunctionName(_izContext, " + `"${resourceName}" ,"${serviceTag}")}`,
+    [RESOURCE_CLASSES.sns]: "arn:aws:sns:${process.env.iz_region}:${process.env.iz_accountId}:${snsSharedLib.snsTopicNameByFlowSchema(_izContext, " + `"${resourceName}", "${serviceTag}")}`
+
+  }[resourceClass]
+};
+
+function externalResourceYaml(resourceClass, resourceName, serviceTag) {
+  if (!serviceTag) {
+    serviceTag = "${self:custom.iz_resourcePrefix}"
+  } else {
+    serviceTag = serviceTag + "Test"
+  }
+  return {
+    [RESOURCE_CLASSES.dynamoDbTable]: "arn:aws:dynamodb:${self:custom.iz_region}:${self:custom.iz_accountId}:table/" + `${serviceTag}` + `${resourceName}`,
+    [RESOURCE_CLASSES.lambda]: "arn:aws:lambda:${self:custom.iz_region}:${self:custom.iz_accountId}:function:" + `${serviceTag}` + `${resourceName}`,
+    [RESOURCE_CLASSES.sns]: "arn:aws:sns:${self:custom.iz_region}:${self:custom.iz_accountId}:" + `${serviceTag}` + `${resourceName}`,
+    [RESOURCE_CLASSES.sqs]: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:" + `${serviceTag}` + `${resourceName}`
+
+  }[resourceClass]
+};
+
+const getGraphServiceNameFromAllRelSchema = async (_izContext, allRelSchemas, settings = { bucketName: getLocalConfig("iz_serviceSchemaBucketName") }) => {
+  const graphServiceNameSet = new Set();
+  await Promise.all(allRelSchemas.map(async relSchema => {
+    let relTag = Object.keys(relSchema)[0];
+    let relSchemaData = relSchema[relTag];
+
+    await Promise.all(Object.values(relSchemaData.storageResources).map(async storageResource => {
+      if (storageResource.storageType === STORAGE_TYPES.graph) {
+        const getGraphServiceName = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag, settings.bucketName);
+        graphServiceNameSet.add(getGraphServiceName)
+      }
+    }))
+  }))
+  const graphServiceName = [...graphServiceNameSet]
+  return graphServiceName
+};
+
+function defaultIamRolePerAction() {
+
+  let defaultIamRole = [];
+
+
+  defaultIamRole.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.s3]: [S3_RESOURCE.getObject, S3_RESOURCE.getObjectVersion],
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.s3, "${self:custom.iz_serviceSchemaBucketName}/perServiceSchemas/*"),
+        resourceNames(RESOURCE_CLASSES.s3, "${self:custom.iz_serviceSchemaBucketName}/serviceConfig/GraphServerTags.json"),
+      ]
+    )
+  );
+
+  defaultIamRole.push(
+    createIamRole(
+      { [RESOURCE_CLASSES.s3]: [S3_RESOURCE.listBucket] },
+      [
+        resourceNames(RESOURCE_CLASSES.s3, "${self:custom.iz_serviceSchemaBucketName}"),
+      ]
+    )
+  );
+
+  return defaultIamRole
+};
+
+async function getGraphServiceNameFromObjectSchema(_izContext, allObjSchemas, settings = { bucketName: getLocalConfig("iz_serviceSchemaBucketName") }) {
+  const graphServiceName = new Set();
+  for (const objectSchema of allObjSchemas) {
+    for (let storageResource of Object.values(objectSchema.storageResources)) {
+      if (storageResource.storageType === STORAGE_TYPES.graph) {
+        let getGraphServiceName = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag, settings.bucketName)
+        graphServiceName.add(getGraphServiceName)
+      }
+    }
+  }
+  let graphServiceNames = [...graphServiceName]
+  return graphServiceNames
+};
+
+function awaitingMultipleStepsRole() {
+  let awaitingMultipleStepsRole = createIamRole(
+    {
+      [RESOURCE_CLASSES.dynamoDbTable]:
+        [
+          DYNAMO_RESOURCE.updateItem,
+          DYNAMO_RESOURCE.putItem,
+          DYNAMO_RESOURCE.deleteItem,
+          DYNAMO_RESOURCE.query
+        ]
+    },
+    [
+      resourceNames(RESOURCE_CLASSES.dynamoDbTable, "AwaitingMultipleSteps"),
+      resourceNames(RESOURCE_CLASSES.dynamoDbTable, "AwaitingMultipleStepByPending"),
+      resourceNames(RESOURCE_CLASSES.dynamoDbTable, "AwaitingStep"),
+    ]
+  )
+  return awaitingMultipleStepsRole
+};
+
+function shortNameHandler(fullNameHandler) {
+  return fullNameHandler.slice(3)
+};
+
+function fieldNameSetting(fieldNameType) {
+  const stringValidation = "^[a-zA-Z0-9-_]+$"
+  return {
+    [FIELD_NAME_TYPE.identifiers]: {
+      type: "string",
+      requiredOnCreate: true,
+      optionalOnCreate: false,
+      canUpdate: false,
+      randomOnCreate: false,
+      validation: {
+        pattern: stringValidation
+      }
+    },
+    [FIELD_NAME_TYPE.nonIdentifiers]: {
+      type: "string",
+      requiredOnCreate: false,
+      optionalOnCreate: false,
+      canUpdate: true,
+      randomOnCreate: false,
+      validation: {
+        pattern: stringValidation
+      }
+    },
+    [FIELD_NAME_TYPE.requiredOnCreateFieldName]: {
+      type: "string",
+      requiredOnCreate: true,
+      optionalOnCreate: false,
+      canUpdate: false,
+      randomOnCreate: false,
+      validation: {
+        pattern: stringValidation
+      }
+    },
+    [FIELD_NAME_TYPE.randomOnCreateFieldName]: {
+      type: "string",
+      requiredOnCreate: false,
+      optionalOnCreate: false,
+      canUpdate: false,
+      randomOnCreate: true,
+      validation: {
+        pattern: stringValidation
+      }
+    },
+    [FIELD_NAME_TYPE.optionalOnCreate]: {
+      type: "string",
+      requiredOnCreate: false,
+      optionalOnCreate: true,
+      canUpdate: false,
+      randomOnCreate: false,
+      validation: {
+        pattern: stringValidation
+      }
+    }
+  }[fieldNameType]
+};
+
+function checkDynamoTypeRelationship(relationship) {
+  let storageType;
+  let relationshipTag;
+  let links;
+  for (const [relTag, relProperties] of Object.entries(relationship)) {
+    relationshipTag = relTag
+    for (const [storageResourceTag, storageResource] of Object.entries(relProperties.storageResources)) {
+      if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+        storageType = STORAGE_TYPES.dynamoDB;
+        for (const link of relProperties.links) {
+          if (link.storageResourceTags.includes(storageResourceTag)) {
+            links = relProperties.links
+          }
+        }
+      }
+    }
+  }
+  return [storageType, relationshipTag, links];
+}
+
+function createDynamoDbComponentByLinks(link, relationshipTag) {
+  let tableNameFrom = `${link.from.objType.serviceTag}_${link.from.objType.objectType}__${relationshipTag}__${link.to.objType.serviceTag}_${link.to.objType.objectType}`
+  let tableNameTo = `${link.to.objType.serviceTag}_${link.to.objType.objectType}__${relationshipTag}__${link.from.objType.serviceTag}_${link.from.objType.objectType}`
+
+  let identifiersConcatFrom = `${link.from.objType.serviceTag}_${link.from.objType.objectType}__identifiersConcat`
+  let identifiersConcatTo = `${link.to.objType.serviceTag}_${link.to.objType.objectType}__identifiersConcat`
+
+  let resourceNameFrom = `${upperCase(link.from.objType.objectType) + upperCase(link.to.objType.objectType)}${upperCase(relationshipTag)}`
+  let resourceNameTo = `${upperCase(link.to.objType.objectType) + upperCase(link.from.objType.objectType)}${upperCase(relationshipTag)}`
+  return {
+    tableNameFrom,
+    tableNameTo,
+    identifiersConcatFrom,
+    identifiersConcatTo,
+    resourceNameFrom,
+    resourceNameTo
+  }
+}
+
+async function getStorageResourceFromObjectSchemas(_izContext, allObjSchemas, settings = { bucketName: getLocalConfig("iz_serviceSchemaBucketName") }) {
+  if (Array.isArray(allObjSchemas)) {
+    allObjSchemas = [allObjSchemas]
+  }
+  let resourceGraphServiceTag = new Set();
+  let resourceDynamoTableName = new Set();
+  for (const objectSchema of allObjSchemas.records) {
+    for (const storageResource of Object.values(objectSchema.storageResources)) {
+      if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+        resourceDynamoTableName.add(storageResource.tableName);
+      } else if (storageResource.storageType === STORAGE_TYPES.graph) {
+        let graphServiceTag = await serviceConfig.getGraphServiceTagWithCache(_izContext, storageResource.graphServerTag, settings.bucketName);
+        resourceGraphServiceTag.add(graphServiceTag);
+      }
+    }
+  }
+
+  return { resourceGraphServiceTag: [...resourceGraphServiceTag], resourceDynamoTableName: [...resourceDynamoTableName] }
+}
+
+async function getExternalTopicComponentFromAllObjectSchemas(_izContext, allObjSchemas) {
+  const externalTopicComponentSet = new Set();
+  for (const objectSchema of allObjSchemas) {
+    for (let storageResource of Object.values(objectSchema.storageResources)) {
+
+      if (storageResource.storageType === STORAGE_TYPES.externalTopic) {
+        let uniqueTag = hash({
+          accountId: storageResource.accountId,
+          region: storageResource.region,
+          serviceTag: storageResource.serviceTag,
+          stage: storageResource.stage
+        })
+
+        if (!externalTopicComponentSet.has(uniqueTag)) {
+          externalTopicComponentSet.add(
+            {
+              [uniqueTag]: {
+                accountId: storageResource.accountId,
+                region: storageResource.region,
+                serviceTag: storageResource.serviceTag,
+                stage: storageResource.stage
+              }
+            }
+          )
+        }
+      }
+    }
+  }
+  let externalTopicComponents = [...externalTopicComponentSet]
+  return externalTopicComponents
+};
+
+function tableRoleForFlowSchema(objectSchema) {
+  let tableNames = [];
+  let resourcePermission = [];
+  for (const storageResource of Object.values(objectSchema.storageResources)) {
+    if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+      tableNames.push(storageResource.tableName)
+    }
+  }
+
+  resourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.dynamoDbTable]: Object.values(DYNAMO_RESOURCE)
+      },
+      tableNames.map(tableName =>
+        resourceNames(RESOURCE_CLASSES.dynamoDbTable, tableName)
+      )
+    )
+  )
+  return resourcePermission;
+};
+
+export default {
+  resourceNames,
+  createIamRole,
+  externalResourceName,
+  externalResourceYaml,
+  getGraphServiceNameFromAllRelSchema,
+  defaultIamRolePerAction,
+  getGraphServiceNameFromObjectSchema,
+  awaitingMultipleStepsRole,
+  shortNameHandler,
+  fieldNameSetting,
+  checkDynamoTypeRelationship,
+  createDynamoDbComponentByLinks,
+  getStorageResourceFromObjectSchemas,
+  getExternalTopicComponentFromAllObjectSchemas,
+  tableRoleForFlowSchema
+}

package/src/libs/Utils.js

@@ -0,0 +1,140 @@
+/*
+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 yaml from 'yaml';
+import fs from 'fs';
+import path from 'path';
+
+function firstLetterUpperCase(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+function firstLetterLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+function checkOverWriteGenerateMainFunction(objectSchema, action) {
+  let overWriteStatus;
+  if (
+    objectSchema.overwriteGenerateMainFunction?.length &&
+    objectSchema.overwriteGenerateMainFunction.includes(action)
+  ) {
+    overWriteStatus = true;
+  } else {
+    overWriteStatus = false;
+  }
+  return overWriteStatus;
+}
+
+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;
+}
+
+function checkValidTableYaml(
+  _izContext,
+  currentTableSetting,
+  existsTableSetting
+) {
+  // console.log("checkValidTableYaml", JSON.stringify(currentTableSetting, null, 2), JSON.stringify(existsTableSetting, null, 2))
+  /*
+    return table yml setting that already filter duplicate tableName that have same table setting
+    throw error when found duplicate table name but not have same table setting
+  */
+
+  let filteredDynamoDbYamlSetting = [];
+
+  for (let i = 0, length = currentTableSetting.length; i < length; i++) {
+    let dynamoDbYamlSetting = currentTableSetting[i];
+    // console.log("dynamoDbYamlSetting", dynamoDbYamlSetting)
+    if (
+      existsTableSetting.hasOwnProperty(
+        firstLetterUpperCase(dynamoDbYamlSetting.templateData.tableName)
+      )
+    ) {
+      // exists table
+      if (
+        hash(
+          existsTableSetting[
+          firstLetterUpperCase(dynamoDbYamlSetting.templateData.tableName)
+          ]
+        ) === hash(dynamoDbYamlSetting.templateData.attributes.sort())
+      ) {
+        continue;
+      } else {
+        throw Error(
+          `tableName:${firstLetterUpperCase(dynamoDbYamlSetting.templateData.tableName)} have duplicate setting but not have same setting`
+        );
+      }
+    } else {
+      filteredDynamoDbYamlSetting.push(dynamoDbYamlSetting);
+
+      // not exists table
+      Object.assign(existsTableSetting, {
+        [firstLetterUpperCase(dynamoDbYamlSetting.templateData.tableName)]:
+          dynamoDbYamlSetting.templateData.attributes.sort()
+      });
+    }
+  }
+  // console.log("filteredDynamoDbYamlSetting: ", JSON.stringify(filteredDynamoDbYamlSetting, null, 2),
+  //   "existsTableSetting:", JSON.stringify(existsTableSetting, null, 2))
+  return [filteredDynamoDbYamlSetting, existsTableSetting];
+}
+
+// empty dir
+async function deleteFileInDir(directory) {
+  try {
+    if (fs.existsSync(directory)) {
+      fs.rmSync(directory, { recursive: true });
+    }
+  } catch (err) {
+    console.log(err);
+  }
+}
+
+function deleteFile(filePath) {
+  if (fs.existsSync(filePath)) {
+    try {
+      // If the file exists, delete it
+      fs.unlinkSync(filePath);
+      console.log('File deleted successfully');
+    } catch (err) {
+      console.error(`Error deleting file: ${err.message}`);
+    }
+  } else {
+    console.log('File does not exist');
+  }
+}
+
+
+
+export default {
+  firstLetterUpperCase,
+  firstLetterLowerCase,
+  checkOverWriteGenerateMainFunction,
+  getLocalConfig,
+  checkValidTableYaml,
+  deleteFileInDir,
+  deleteFile
+};