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

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

@@ -0,0 +1,10 @@
+# for createIamRole
+
+<% roleNameConfigs.forEach(roleNameConfig => { _%>
+- arn:aws:iam::${self:custom.iz_accountId}:role/${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(roleNameConfig) %>
+<% }) _%>
+
+
+<%_function firstLetterUpperCase(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} %>

package/src/TemplateData/externalService/generateTemplateData.js

@@ -0,0 +1,79 @@
+/*
+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 required modules
+import { join } from 'path';
+import { getObjectSchema } from '@izara_project/izara-core-library-service-schemas';
+const {
+  getAllLocalObjectSchemasWithHierarchy,
+  getAllLocalRelationshipSchema,
+  getAllLocalFlowSchemas
+} = getObjectSchema;
+
+// create External Service
+
+import createExternalLambdaRole from './lambdaRole/data.js';
+import createExternalSnsSubscriptions from './snsTopicSubscriptions/data.js';
+
+/**
+ * Generates code with templates for different actions
+ * @param {Object} _izContext - Context object
+ * @param {string} objSchemaPath - Path to the schema
+ * @returns {Array} Array of generated code parameters
+ */
+async function generateCodeWithTemplate(_izContext, objSchemaPath) {
+  try {
+    const saveFilePath = join(objSchemaPath, '../');
+    const createSourceParams = [];
+    const allObjSchemas = await getAllLocalObjectSchemasWithHierarchy(
+      _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
+    );
+    const createSnsSubscription = await createExternalSnsSubscriptions(
+      _izContext,
+      allObjSchemas.records,
+      allObjectRelationships,
+      allLocalFlowSchemas.records,
+      saveFilePath
+    );
+
+    createSourceParams.push(createFunctionIamRole, createSnsSubscription);
+
+    return createSourceParams;
+  } catch (error) {
+    _izContext.logger.error('Error generating code with template:', error);
+    return [];
+  }
+}
+
+export default generateCodeWithTemplate;

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

@@ -0,0 +1,448 @@
+/*
+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 consts from '../../../libs/Consts.js';
+import libs from '../../../libs/Libs.js';
+
+const {
+  RESOURCE_CLASSES,
+  SOURCE_PATH,
+  SAVE_FILE_NAME,
+  LAMBDA_RESOURCE,
+  SNS_RESOURCE,
+  SOURCE_GENERATE_IAM_ROLE,
+  EXTERNAL_SERVICE_NAME
+} = consts;
+
+const {
+  createIamRole,
+  externalResourceName,
+  getGraphServiceNameFromAllRelSchema,
+  getStorageResourceFromObjectSchemas
+} = libs;
+
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+const createExternalLambdaRole = async (
+  _izContext,
+  allObjSchemas,
+  allRelSchemas,
+  allLocalFlowSchemas,
+  srcPath
+) => {
+  // console.log("allRelationshipSchemas", allRelationshipSchemas);
+  const externalLambdaIamRoleArray = [];
+  // per action external lambda role
+  const externalLambdaIamRole = await externalLambdaIamRoleDataPerAction(
+    _izContext,
+    allObjSchemas
+  );
+  externalLambdaIamRole &&
+    externalLambdaIamRoleArray.push(externalLambdaIamRole);
+
+  const allRelationshipSchemas = await getObjectSchema.getAllLocalRelationshipSchema(_izContext, srcPath)
+
+  // validate relationship in ObjectRelationship
+  if (allRelationshipSchemas.length) {
+    // relationship external lambda role
+    const externalLambdaIamRoleRelationshipPerAction =
+      await externalLambdaIamRoleRelationships(_izContext, allRelSchemas);
+    externalLambdaIamRoleRelationshipPerAction &&
+      externalLambdaIamRoleArray.push(
+        externalLambdaIamRoleRelationshipPerAction
+      );
+  }
+
+  // ProcessLogical and FindData
+  const externalLambdaIamRoleProcessLogical =
+    await externalLambdaIamRoleDataProcessLogicalAndFindData(
+      _izContext,
+      allObjSchemas
+    );
+  externalLambdaIamRoleProcessLogical &&
+    externalLambdaIamRoleArray.push(externalLambdaIamRoleProcessLogical);
+
+  if (allLocalFlowSchemas) {
+    for (const localFlowSchema of allLocalFlowSchemas) {
+      for (const event of localFlowSchema.event) {
+        if (event.includes('s3')) {
+          const externalLambdaIamRoleGetPresignUrl =
+            await externalLambdaIamRoleUploadS3(_izContext);
+          externalLambdaIamRoleGetPresignUrl &&
+            externalLambdaIamRoleArray.push(externalLambdaIamRoleGetPresignUrl);
+        } else if (event.includes('extTopic')) {
+          // const externalSnsPublish = await externalRoleSnsPublish(_izContext, localFlowSchema);
+          // externalSnsPublish && externalLambdaIamRoleArray.push(externalSnsPublish);
+        }
+      }
+    }
+
+    // console.log("externalLambdaIamRoleArray", externalLambdaIamRoleArray)
+    // console.log("createSourceArrayIamRole", JSON.stringify(externalLambdaIamRoleArray))
+    // return externalLambdaIamRoleArray
+
+    return {
+      templatePath: templatePath,
+      templateData: { datas: externalLambdaIamRoleArray },
+      setting: {
+        savePath: path.join(srcPath, SOURCE_PATH.externalService),
+        saveFileName: SAVE_FILE_NAME.externalLambdaRole,
+        fileExtension: '.js',
+        isAppend: false
+      }
+    };
+  }
+};
+
+async function externalLambdaIamRoleDataPerAction(_izContext, allObjSchemas) {
+  let storageResourceAllLocalObjectSchemas =
+    await getStorageResourceFromObjectSchemas(_izContext, allObjSchemas);
+  const additionalResourcePermission = [];
+
+  if (!storageResourceAllLocalObjectSchemas.resourceGraphServiceTag.length) {
+    return;
+  } else {
+    additionalResourcePermission.push(
+      createIamRole(
+        { [RESOURCE_CLASSES.lambda]: [LAMBDA_RESOURCE.invokeFunction] },
+        storageResourceAllLocalObjectSchemas.resourceGraphServiceTag.map(
+          graphServerTag =>
+            externalResourceName(
+              RESOURCE_CLASSES.lambda,
+              'GetNodeV2HdrInv',
+              graphServerTag
+            )
+        )
+      ),
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        storageResourceAllLocalObjectSchemas.resourceGraphServiceTag.map(
+          graphServerTag =>
+            externalResourceName(
+              RESOURCE_CLASSES.sns,
+              'UpdateNode_In',
+              graphServerTag
+            )
+        )
+      ),
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        storageResourceAllLocalObjectSchemas.resourceGraphServiceTag.map(
+          graphServerTag =>
+            externalResourceName(
+              RESOURCE_CLASSES.sns,
+              'CreateNode_In',
+              graphServerTag
+            )
+        )
+      ),
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.lambda]: [LAMBDA_RESOURCE.invokeFunction]
+        },
+        storageResourceAllLocalObjectSchemas.resourceGraphServiceTag.map(
+          graphServerTag =>
+            externalResourceName(
+              RESOURCE_CLASSES.lambda,
+              'CreateNodeV2HdrInv',
+              graphServerTag
+            )
+        )
+      ),
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.lambda]: [LAMBDA_RESOURCE.invokeFunction]
+        },
+        storageResourceAllLocalObjectSchemas.resourceGraphServiceTag.map(
+          graphServerTag =>
+            externalResourceName(
+              RESOURCE_CLASSES.lambda,
+              'UpdateNodeHdrInv',
+              graphServerTag
+            )
+        )
+      )
+    );
+  }
+
+  return {
+    objectType: SOURCE_GENERATE_IAM_ROLE.PerActionEndpoint,
+    additionalResourcePermission
+  };
+}
+
+// update Relationship
+async function externalLambdaIamRoleRelationships(_izContext, allRelSchemas) {
+  const additionalResourcePermission = [];
+  const graphServiceNamesFromAllRelSchemas =
+    await getGraphServiceNameFromAllRelSchema(_izContext, allRelSchemas);
+  const objectType = SOURCE_GENERATE_IAM_ROLE.RelationshipRole;
+  if (!graphServiceNamesFromAllRelSchemas.length) {
+    return;
+  } else {
+    additionalResourcePermission.push(
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        graphServiceNamesFromAllRelSchemas.map(graphServiceName =>
+          externalResourceName(
+            RESOURCE_CLASSES.sns,
+            'UpdateRelationship_In',
+            graphServiceName
+          )
+        )
+      ),
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        graphServiceNamesFromAllRelSchemas.map(graphServiceName =>
+          externalResourceName(
+            RESOURCE_CLASSES.sns,
+            'CreateRelationship_In',
+            graphServiceName
+          )
+        )
+      ),
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        graphServiceNamesFromAllRelSchemas.map(graphServiceName =>
+          externalResourceName(
+            RESOURCE_CLASSES.sns,
+            'DeleteRelationship_In',
+            graphServiceName
+          )
+        )
+      ),
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.lambda]: [LAMBDA_RESOURCE.invokeFunction]
+        },
+        graphServiceNamesFromAllRelSchemas.map(graphServiceName =>
+          externalResourceName(
+            RESOURCE_CLASSES.lambda,
+            'GetRelationshipV2HdrInv',
+            graphServiceName
+          )
+        )
+      ),
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        graphServiceNamesFromAllRelSchemas.map(graphServiceName =>
+          externalResourceName(
+            RESOURCE_CLASSES.sns,
+            'ChangeRelationshipType_In',
+            graphServiceName
+          )
+        )
+      ),
+      createIamRole(
+        {
+          [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+        },
+        graphServiceNamesFromAllRelSchemas.map(graphServiceName =>
+          externalResourceName(
+            RESOURCE_CLASSES.sns,
+            'MoveRelationship_In',
+            graphServiceName
+          )
+        )
+      )
+    );
+  }
+
+  return {
+    additionalResourcePermission,
+    objectType
+  };
+}
+
+async function externalLambdaIamRoleDataProcessLogicalAndFindData(
+  _izContext,
+  allObjectSchemas
+) {
+  let additionalResourcePermission = [];
+  let graphServiceNames = await getStorageResourceFromObjectSchemas(
+    _izContext,
+    allObjectSchemas
+  );
+  let objectType = SOURCE_GENERATE_IAM_ROLE.ProcessFindDataRole;
+
+  // console.log("graphServiceNameFromProcessLogical::", graphServiceNames)
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.lambda]: [LAMBDA_RESOURCE.invokeFunction]
+      },
+      graphServiceNames.resourceGraphServiceTag.map(graphServiceName =>
+        externalResourceName(
+          RESOURCE_CLASSES.lambda,
+          'GetNodeV2HdrInv',
+          graphServiceName
+        )
+      )
+    )
+  );
+  return {
+    additionalResourcePermission,
+    objectType
+  };
+}
+
+function externalLambdaIamRoleUploadS3(_izContext) {
+  let additionalResourcePermission = [];
+  let objectType = SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role;
+  // reservedLimit
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+      },
+      [
+        externalResourceName(
+          RESOURCE_CLASSES.sns,
+          'ReservedDynamicUsage_In',
+          EXTERNAL_SERVICE_NAME.accountLimits
+        )
+      ]
+    ),
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.lambda]: [LAMBDA_RESOURCE.invokeFunction]
+      },
+      [
+        externalResourceName(
+          RESOURCE_CLASSES.lambda,
+          'StaticLimitProcessHdrInv',
+          EXTERNAL_SERVICE_NAME.accountLimits
+        )
+      ]
+    )
+  );
+  // createPresignUrl
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+      },
+      [
+        externalResourceName(
+          RESOURCE_CLASSES.sns,
+          'CancelUsage_In',
+          EXTERNAL_SERVICE_NAME.accountLimits
+        )
+      ]
+    )
+  );
+  // confirmReserved
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+      },
+      [
+        externalResourceName(
+          RESOURCE_CLASSES.sns,
+          'ReservedDynamicUsageComplet_Out',
+          EXTERNAL_SERVICE_NAME.accountLimits
+        ),
+        externalResourceName(
+          RESOURCE_CLASSES.sns,
+          'ConfirmUsage_In',
+          EXTERNAL_SERVICE_NAME.accountLimits
+        )
+      ]
+    )
+  );
+  // process after upload
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+      },
+      [
+        externalResourceName(
+          RESOURCE_CLASSES.sns,
+          'CancelUsage_In',
+          EXTERNAL_SERVICE_NAME.accountLimits
+        ),
+        externalResourceName(
+          RESOURCE_CLASSES.sns,
+          'ConfirmUsage_In',
+          EXTERNAL_SERVICE_NAME.accountLimits
+        ),
+        externalResourceName(
+          RESOURCE_CLASSES.sns,
+          'ReservedDynamicUsage_In',
+          EXTERNAL_SERVICE_NAME.accountLimits
+        )
+      ]
+    )
+  );
+  // console.log("additionalResourcePermission GetPresignUrl::", JSON.stringify(additionalResourcePermission))
+  return {
+    additionalResourcePermission,
+    objectType
+  };
+}
+
+async function externalRoleSnsPublish(_izContext, localFlowSchema) {
+  const additionalResourcePermission = [];
+  const flowStepInSplitKey = Object.keys(localFlowSchema.flowSteps)[0].split(
+    '_'
+  );
+  const serviceTag = flowStepInSplitKey[0];
+
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+      },
+      [
+        externalResourceName(
+          RESOURCE_CLASSES.sns,
+          `${flowStepInSplitKey[2]}_${flowStepInSplitKey[3]}`,
+          serviceTag
+        )
+      ]
+    )
+  );
+
+  return {
+    additionalResourcePermission,
+    objectType: SOURCE_GENERATE_IAM_ROLE.ExternalTopicRole
+  };
+}
+
+export default createExternalLambdaRole;

package/src/TemplateData/externalService/lambdaRole/request.json

@@ -0,0 +1,18 @@
+{
+  "functionName": "xx",
+  "additionalResourcePermission": [
+    {
+      "effect": "Allow",
+      "action": {
+        "dynamodb": [
+          "GetItem",
+          "PutItem"
+        ]
+      },
+      "resource": [
+        "aws:sqs",
+        "..."
+      ]
+    }
+  ]
+}

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

@@ -0,0 +1,57 @@
+/*
+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 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 }
+
+export function generatedLambdaRole() {
+  let externalLambdaRole = [ <%_ datas.forEach((data,dataIndex) => { %>
+  {
+    roleName: "<%- data.objectType %>",
+    statement: [
+    <%_ data.additionalResourcePermission.forEach((resourcePermission, resourceIdx) => { _%>
+      {
+        "Sid": "<%- data.objectType %>Test<%- resourceIdx %>",
+        "Effect": "<%- resourcePermission.effect %>",
+        "Action":
+          [
+          <%_ Object.keys(resourcePermission.action).forEach(resourcePerAction => { _%>
+            <%_ resourcePermission.action[resourcePerAction].forEach(permission => { _%>
+            "<%- resourcePerAction %>:<%- permission %>",
+          ],
+        "Resource":[
+          <%_ resourcePermission.resource.forEach(resource => { _%>
+            `<%- resource _%>`,
+            <%_ }) _%>
+            ]
+        <%_ }) _%>
+        <%_ }) _%>
+        },
+      <%_ }) _%>
+          //(<create<%- data.objectType%>Role>)
+          //(</create<%- data.objectType%>Role>)
+      ]
+    },
+    <%_ }) %>
+    //(<additionalRole>)
+    //(</additionalRole>)
+  ]
+   return externalLambdaRole
+}