@izara_project/izara-market-library-service-schemas 1.0.1 → 1.0.3

package/src/TemplateManager/src/GenerateCode(Old).js

@@ -0,0 +1,135 @@
+/*
+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';
+
+const join = require('path').join;
+const { readFileSync } = require('fs');
+
+
+const {
+  getAllLocalObjectSchemasWithHierarchy,
+  getAllLocalRelationshipSchemas
+} = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
+
+
+
+const { createSource } = require("../../SourceManager/src/CreateSource");
+const { deleteFileInDir } = require("../../SourceManager/src/Utils");
+
+const perAction = require("./PerActionEndpoint/CreateSourceData");
+
+const mainResources = require("./MainResourcesYaml/CreateSourceData");
+
+
+/**
+ *
+ * get template and send to
+ *
+ * @param {object} objSchemaPath
+ * @returns
+ *
+ * add another param
+ *  {string[]} objectTypes
+ *  {string[]} templates
+ *  {string} saveFilePath
+ */
+async function generateCodeWithTemplate(_izContext, objSchemaPath) {
+
+  try {
+
+    // point to app/src
+    let saveFilePath = join(objSchemaPath, `../`);
+
+    // define path for store yml file
+    const GENERATECODE_SOURCE_PATH = {
+      appYaml: join(saveFilePath, `../sls_yaml/generatedCode/source/`),
+      resourceYaml: join(saveFilePath, `../../resource/sls_yaml/generatedCode/source/`),
+      lambdaPerObjectTypePath: join(saveFilePath, `/generatedCode/lambdaPerObjectType/source/`), // test
+      lamdaPerCombindActionPath: join(saveFilePath, `/generatedCode/lamdaPerCombindAction/source/`), // test
+    };
+
+
+    // from app/src/shcemas
+    let allObjSchemas = await getAllLocalObjectSchemasWithHierarchy(_izContext, objSchemaPath);
+
+    const allObjectRelationships = await getAllLocalRelationshipSchemas(_izContext, objSchemaPath);
+
+    /*
+      Should we generateCode with objectSchema that not in hierarchy or not?
+      Should use objectSchema with hierarchy because we use storageResource of parent to create lambda iam role in .yml file
+    */
+
+    let createSourceParams = [];
+
+    for (const relTag in allObjectRelationships) {
+      const relTagData = allObjectRelationships[relTag];
+
+      // create main resource per relationshipSchema
+      const createSourceMainResourcesRelSchema = mainResources.createSourceDataRelSchema(_izContext, { [relTag]: relTagData }, saveFilePath);
+      console.log("createSourceMainResourcesRelSchema: ", createSourceMainResourcesRelSchema);
+
+      createSourceParams = createSourceParams.concat(createSourceMainResourcesRelSchema);
+    }
+
+
+    //
+    for (let objectSchema of allObjSchemas.records) {
+
+      // create main resource per objectSchema
+      let createSourceMainResourcesObjectSchema = mainResources.createSourceDataObjectSchema(_izContext, objectSchema, saveFilePath);
+      // console.log("createSourceMainResourcesObjectSchema: ", createSourceMainResourcesObjectSchema);
+
+      // mainFunction, handlerFunction, resourceYaml per action
+      let createSourcePerAction = perAction.createSourceDataObjectSchema(_izContext, objectSchema, saveFilePath);
+      // console.log("createSourcePerAction: ", createSourcePerAction)
+
+
+
+      // console.log("createSourceParams begore concat: ", createSourceParams);
+
+      createSourceParams = createSourceParams.concat([...createSourcePerAction, ...createSourceMainResourcesObjectSchema]);
+
+      // console.log("createSourceParams after concat: ", createSourceParams);
+    }
+
+
+    // delete file .yml before start to prevent confilct of data
+    for (let folderPathToEmpty of Object.keys(GENERATECODE_SOURCE_PATH)) {
+      await deleteFileInDir(GENERATECODE_SOURCE_PATH[folderPathToEmpty]);
+    }
+
+
+    // start create source
+    for (let { templatePath, templateData, setting } of createSourceParams) {
+      await createSource(
+        readFileSync(templatePath, 'utf8'),
+        templateData,
+        setting,
+      );
+    }
+
+
+    return "return values";
+
+  } catch (err) {
+    console.log('error templateManager: ', err);
+    throw (err);
+  }
+};
+
+module.exports = { generateCodeWithTemplate };

package/src/TemplateManager/src/GenerateCode.js

@@ -0,0 +1,207 @@
+/*
+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';
+
+const join = require('path').join;
+const { readFileSync } = require('fs');
+
+
+const {
+  getAllLocalObjectSchemasWithHierarchy,
+  getAllLocalRelationshipSchemas
+} = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
+
+
+const {
+  getGraphServiceNameFromGraphServerTagWithCache
+} = require('@izara_project/izara-core-library-service-schemas/src/ServiceConfig');
+
+const { createSource } = require("../../SourceManager/src/CreateSource");
+const { deleteFileInDir } = require("../../SourceManager/src/Utils");
+// create handler function
+const perActionHdrInvData = require("./PerActionEndpoint/Handler/HdrInv/data");
+const perActionHdrApiData = require("./PerActionEndpoint/Handler/HdrApi/data");
+const perActionHdrSqsData = require("./PerActionEndpoint/Handler/HdrSqs/data");
+const perActionHdrDsqData = require("./PerActionEndpoint/Handler/HdrDsq/data");
+
+// create Main funcion
+const mainFunctionGetData = require('./PerActionEndpoint/MainFunction/Get/data');
+
+// create function.yaml
+const functionGetYamlDataHdrInv = require('./FunctionYaml/HdrInv/data');
+const functionGetYamlDataHdrApi = require('./FunctionYaml/HdrApi/data');
+const functionGetYamlDataHdrSqs = require('./FunctionYaml/HdrSqs/data');
+const functionGetYamlDataHdrDsq = require('./FunctionYaml/HdrDsq/data');
+
+
+// create Main resource
+const { createSourceDataDynamoDB } = require('./ResourceYaml/dynamodb/mainResourcePerObjectSchemaData');
+const { createDefaultSourceDataDynamoDB } = require('./ResourceYaml/dynamodb/processLogicalAndFindData')
+const { createSourceSnsAndSqs } = require('./ResourceYaml/sns-in-sqs/snsAndSqsPerActiondata');
+const createFindDataAndProcessLogicalDefaultSnsInSqs = require('./ResourceYaml/sns-in-sqs/defaultSnsInSqsForFindDataAndProcessLogical')
+
+// create External Service
+const createSnsSubscriptions = require('./externalService/SnsTopicSubscriotions/data');
+const createLambdaRole = require('./externalService/LambdaRole/data');
+
+
+
+//create resource
+// const mainResources = require("./MainResourcesYaml/CreateSourceData");
+
+
+/**
+ *
+ * get template and send to
+ *
+ * @param {object} objSchemaPath
+ * @returns
+ *
+ * add another param
+ *  {string[]} objectTypes
+ *  {string[]} templates
+ *  {string} saveFilePath
+ */
+async function generateCodeWithTemplate(_izContext, objSchemaPath) {
+
+  try {
+
+    // point to app/src
+    let saveFilePath = join(objSchemaPath, `../`);
+
+    // define path for store yml file
+    const GENERATECODE_SOURCE_PATH = {
+      appYaml: join(saveFilePath, `../sls_yaml/generatedCode/source/`),
+      resourceYaml: join(saveFilePath, `../../resource/sls_yaml/generatedCode/source/`),
+      lambdaPerObjectTypePath: join(saveFilePath, `/generatedCode/perAction/source/`), // test
+      lamdaPerCombindActionPath: join(saveFilePath, `/generatedCode/lamdaPerCombindAction/source/`), // test,
+      externalService: join(saveFilePath, '../initial_setup/generatedCode/source/')
+    };
+
+
+    // from app/src/shcemas
+    let allObjSchemas = await getAllLocalObjectSchemasWithHierarchy(_izContext, objSchemaPath);
+    // _izContext.logger.debug("allObjSchemas: ", allObjSchemas)
+
+    const allObjectRelationships = await getAllLocalRelationshipSchemas(_izContext, objSchemaPath);
+
+    // _izContext.logger.debug("allObjectRelationships: ", allObjectRelationships)
+    /*
+      Should we generateCode with objectSchema that not in hierarchy or not?
+      Should use objectSchema with hierarchy because we use storageResource of parent to create lambda iam role in .yml file
+    */
+
+    let createSourceParams = [];
+
+    for (const relTag in allObjectRelationships) {
+      // const relTagData = allObjectRelationships[relTag];
+
+      // create main resource per relationshipSchema
+      // const createSourceMainResourcesRelSchema = mainResources.createSourceDataRelSchema(_izContext, { [relTag]: relTagData }, saveFilePath);
+      // console.log("createSourceMainResourcesRelSchema: ", createSourceMainResourcesRelSchema);
+
+      // createSourceParams = createSourceParams.concat(createSourceMainResourcesRelSchema);
+    }
+
+    // create External service
+    const createFunctionIamRole = await createLambdaRole(_izContext, allObjSchemas.records, saveFilePath);
+    //
+    for (let objectSchema of allObjSchemas.records) {
+      console.log("objectSchema: ", objectSchema);
+
+      // create main resource per objectSchema
+      // const createSourceMainResourcesObjectSchema = mainResources.createSourceDataObjectSchema(_izContext, objectSchema, saveFilePath);
+      // console.log("createSourceMainResourcesObjectSchema: ", createSourceMainResourcesObjectSchema);
+
+      // mainFunction, handlerFunction, resourceYaml per action
+      // let createSourcePerAction = perAction.createSourceDataObjectSchema(_izContext, objectSchema, saveFilePath);
+      // console.log("createSourcePerAction: ", createSourcePerAction)
+
+      // generate handler
+      const createSourceHdrInv = perActionHdrInvData(_izContext, objectSchema, saveFilePath);
+      const createSourceHdrApi = perActionHdrApiData(_izContext, objectSchema, saveFilePath);
+      const createSourceHdrSqs = perActionHdrSqsData(_izContext, objectSchema, saveFilePath);
+      const createSourceHdrDsq = perActionHdrDsqData(_izContext, objectSchema, saveFilePath)
+
+      // wrap Handler Function
+      const createSourceHandler = [...createSourceHdrInv, ...createSourceHdrApi, ...createSourceHdrSqs, ...createSourceHdrDsq]
+
+      // generate main function
+      const createMainFunctionGet = await mainFunctionGetData(_izContext, objectSchema, saveFilePath)
+
+      // generate functionYaml File
+      const createFunctionGetYamlHdrInv = functionGetYamlDataHdrInv(_izContext, objectSchema, saveFilePath)
+      const createFunctionGetYamlHdrApi = functionGetYamlDataHdrApi(_izContext, objectSchema, saveFilePath)
+      const createFunctionGetYamlHdrSqs = functionGetYamlDataHdrSqs(_izContext, objectSchema, saveFilePath)
+      const createFunctionGetYamlHdrDsq = functionGetYamlDataHdrDsq(_izContext, objectSchema, saveFilePath)
+
+      // wrapMain Function
+      const createFunctionYaml = [...createFunctionGetYamlHdrApi, ...createFunctionGetYamlHdrDsq, ...createFunctionGetYamlHdrInv, ...createFunctionGetYamlHdrSqs]
+
+
+      // const createSnsSunbscription = createSnsSubscriptions.createSnsSubscription(_izContext, objectSchema, saveFilePath)
+
+      // generate Resource ..via dynamoDb sns-in-sqs sns-put
+      const createResourceDynamo = createSourceDataDynamoDB(_izContext, objectSchema, saveFilePath);
+      const createResourceSnsInSqs = createSourceSnsAndSqs(_izContext, objectSchema, saveFilePath);
+      const createResourceFindDataAndProcessLogical = createDefaultSourceDataDynamoDB(_izContext, saveFilePath);
+      const createResourceDefaultSnsInSqsFindDataAndProcessLogical = createFindDataAndProcessLogicalDefaultSnsInSqs(_izContext, saveFilePath);
+
+      // wrap main Resource
+      const createMainResource = [...createResourceDynamo, ...createResourceSnsInSqs, ...createResourceFindDataAndProcessLogical, ...createResourceDefaultSnsInSqsFindDataAndProcessLogical]
+
+      createSourceParams = createSourceParams.concat([
+        // ...createSourceMainResourcesObjectSchema,
+        ...createSourceHandler,                                                                                   // create handler function
+        ...createMainFunctionGet,                                                                                 // create main function
+        ...createFunctionYaml,                                                                                    // create function.yaml
+        ...createMainResource,                                                                                     // create resource yaml
+        createFunctionIamRole,
+      ]);
+
+      // console.log("createSourceParams after concat: ", createSourceParams);
+    }
+
+
+    // delete file .yml before start to prevent confilct of data
+    for (let folderPathToEmpty of Object.keys(GENERATECODE_SOURCE_PATH)) {
+      await deleteFileInDir(GENERATECODE_SOURCE_PATH[folderPathToEmpty]);
+    }
+
+    // console.log("createSourceParams: ", createSourceParams)
+    // start create source
+    for (let { templatePath, templateData, setting } of createSourceParams) {
+      // console.log("templatePath in GenerateCode", templatePath);
+      // console.log("setting.savePath in GenerateCode", setting.savePath);
+      await createSource(
+        readFileSync(templatePath, 'utf8'),
+        templateData,
+        setting,
+      );
+    }
+
+
+    return "return values";
+
+  } catch (err) {
+    console.log('error templateManager: ', err);
+    throw (err);
+  }
+};
+
+module.exports = { generateCodeWithTemplate };

package/src/TemplateManager/src/MainResourcesYaml/CreateSourceData.js

@@ -0,0 +1,76 @@
+/*
+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';
+
+const path = require('path');
+
+const schemaConsts = require('@izara_project/izara-core-library-service-schemas/src/Consts');
+
+
+
+// const lambdaYaml = require("./Template/Resource/Lambda/LambdaYamlTemplateData");
+
+const config = require('../libs/Consts')
+
+
+const dynamoDbMainYaml = require("./TemplateAndData/DynamoDbMain/Data/MainDynamoDbYamlData")
+
+/**
+ * @param {Object} _izContext
+ * @param {Object} objectSchema
+ */
+module.exports.createSourceDataObjectSchema = (_izContext, objectSchema, saveFilePath) => {
+
+  let resultsForCreateSource = [];
+
+
+  const dynamoDbMainYamlDataList = dynamoDbMainYaml.dynamoDbMainYamlFromObjectSchema.templateDataFunction(_izContext, objectSchema);
+  // console.log("dynamoDbMainYamlDataList: ", dynamoDbMainYamlDataList);
+
+  for (let dynamoDbMainYamlData of dynamoDbMainYamlDataList) {
+    // create iam role of handler here
+    resultsForCreateSource.push({
+      templatePath: dynamoDbMainYaml.dynamoDbMainYamlFromObjectSchema.templatePath,
+      templateData: dynamoDbMainYamlData,
+      setting: {
+        initialData: 'Resources:\n',
+        savePath: path.join(saveFilePath, config.SOURCE_PATH.resourceYaml),
+        saveFileName: 'generate-dynamodb-table',
+        fileExtension: '.yml',
+        isAppend: true
+      }
+    });
+  }
+
+  // console.log("resultsForCreateSource: ", resultsForCreateSource);
+
+  return resultsForCreateSource;
+}
+
+
+/**
+ *
+ * @param {Object} _izContext
+ * @param {Object} relSchema
+ * @param {String} saveFilePath
+ * @returns
+ */
+module.exports.createSourceDataRelSchema = (_izContext, relSchema, saveFilePath) => {
+
+  return []
+}

package/src/TemplateManager/src/MainResourcesYaml/TemplateAndData/DynamoDbMain/Data/MainDynamoDbYamlData.js

@@ -0,0 +1,155 @@
+/*
+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';
+
+const path = require("path")
+
+// const {
+//   HANDLER,
+// STORAGE_TYPES
+// } = require('@izara_project/izara-core-library-service-schemas/src/Consts');
+
+
+const STORAGE_TYPES = {
+  dynamoDB: "dynamoDB",
+  graph: "graph"
+}
+
+
+// ---------- End Per Lambda Handler IamRole Data ----------
+
+
+
+/**
+ * create data for dynamoDbYaml tempalte from objectSchema
+ * return array of dynamoDb data
+ * because one objectSchema can create multiple dynamoDb table
+ *
+ * @param {Object} _izContext
+ * @param {Object} objectSchema
+ * @returns {Object[]}              - data of multiple dynamoDb template
+ */
+function dataForMainDynamoDbYamlFromObjectSchema(_izContext, objectSchema) {
+  let dynamoDbYamlTemplateData = [];
+
+  // store detail for create dynamoDb table
+  let identifiersDetail = {};
+
+  // add identifiersDetail for dynamoDb storage
+  for (let identifier of objectSchema.identifiers) {
+    // console.log("in identifiers")
+    if (identifier.type === "partitionKey" || identifier.type === "sortKey") {
+      identifiersDetail[identifier.type] = {};
+
+      if (identifier.name) {
+        Object.assign(
+          identifiersDetail[identifier.type],
+          {
+            AttributeName: identifier.name,
+            AttributeType: "S"
+          }
+        );
+      } else {
+        let fieldNameType = objectSchema.fieldNames[identifier.fieldName].type;
+        let attributeType;
+
+        if (fieldNameType === "string") {
+          attributeType = "S"
+        } else if (fieldNameType === "number") {
+          attributeType = "N"
+        }
+
+        Object.assign(
+          identifiersDetail[identifier.type],
+          {
+            AttributeName: identifier.fieldName,
+            AttributeType: attributeType
+          }
+        );
+      }
+    }
+  }
+  // console.log("identifiersDetail: ", identifiersDetail)
+  if (!identifiersDetail.hasOwnProperty("partitionKey")) {
+    return [];
+  }
+
+
+  // start create dynamoDb template data
+  for (let storageResource of Object.values(objectSchema.storageResources)) {
+    if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+      let templateData = {
+        tableName: storageResource.tableName,
+        attributes: []
+      };
+
+
+      if (storageResource.hasOwnProperty("groupByPartitionKeyField")) {
+        templateData.attributes.push(
+          {
+            keyType: "partitionKey",
+            AttributeName: storageResource.groupByPartitionKeyField,
+            AttributeType: "S"
+          }
+        );
+      } else {
+        for (let identifierType in identifiersDetail) {
+          templateData.attributes.push(
+            {
+              keyType: identifierType,
+              AttributeName: identifiersDetail[identifierType].AttributeName,
+              AttributeType: identifiersDetail[identifierType].AttributeType
+            }
+          );
+        }
+      }
+      dynamoDbYamlTemplateData.push(templateData);
+      // console.log("templateData: ", templateData)
+    }
+  }
+
+  return dynamoDbYamlTemplateData
+}
+
+
+// return array of table data
+// because one relSchema can create multiple dynamoDb table
+function dataForMainDynamoDbYamlFromRelSchema(_izContext, relSchema) {
+  let relTag = Object.keys(relSchema)[0];
+  let relData = relSchema[relTag];
+
+  for (let parents of relData.parents) {
+    let parentObjectType = parent.objType.objectType;
+
+
+  }
+
+  return
+}
+
+
+module.exports = {
+  dynamoDbMainYamlFromObjectSchema: {
+    templatePath: path.join(__dirname, '../Template/DynamoDb.ejs'),
+    templateDataFunction: dataForMainDynamoDbYamlFromObjectSchema
+  },
+  dynamoDbMainYamlFromRelSchema: {
+    templatePath: path.join(__dirname, '../Template/DynamoDb.ejs'),
+    templateDataFunction: dataForMainDynamoDbYamlFromRelSchema
+  },
+}

package/src/TemplateManager/src/MainResourcesYaml/TemplateAndData/DynamoDbMain/Template/DynamoDb.ejs

@@ -0,0 +1,31 @@
+  <%- tableName %>Table:
+    Type: "AWS::DynamoDB::Table"
+    Properties:
+      TableName: ${self:custom.iz_resourcePrefix}<%- tableName %>
+      AttributeDefinitions:
+        <%_ attributes.forEach((attribute) => { -%>
+        - AttributeName: <%- attribute["AttributeName"] %>
+          AttributeType: <%- attribute["AttributeType"] %>
+        <%_ }) _%>
+      KeySchema:
+        <%_ attributes.forEach((attribute) => { -%>
+        <%_ if(attribute.keyType === 'partitionKey') { -%>
+        - AttributeName: <%- attribute["AttributeName"] %>
+          KeyType: HASH
+        <%_ } -%>
+        <%_ if(attribute.keyType === 'sortKey') {  -%>
+        - AttributeName: <%- attribute["AttributeName"] %>
+          KeyType: RANGE
+        <%_ } -%>
+        <%_ }) _%>
+      ProvisionedThroughput:
+        ReadCapacityUnits: 1
+        WriteCapacityUnits: 1
+      #<#<%- firstLetterUpperCase(tableName) %>DynamoDbSetting#>
+      #<#/<%- firstLetterUpperCase(tableName) %>DynamoDbSetting#>
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
+<%_ function firstLetterLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1)
+} _%>

package/src/TemplateManager/src/MainResourcesYaml/TemplateAndData/DynamoDbMain/Template/DynamoDb.exampleData.js

@@ -0,0 +1,12 @@
+// example template data for dynamoDb
+const templateData = {
+  tableName: "xx",
+  attributes: [
+    {
+      keyType: "xx", // partitionKey || sortKey
+      AttributeName: "", // any
+      AttributeType: "" // S, N, B
+    },
+    //...
+  ]
+}