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

package/src/TemplateData/findData/generateTemplateData.js

@@ -0,0 +1,69 @@
+/*
+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 } = getObjectSchema;
+
+// findData
+import createFindDataFunctionYaml from './findDataYaml/data.js';
+import createFindDataHandler from './handler/data.js';
+import createFindDataMainFunction from './mainFunction/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, settings) {
+  try {
+    const saveFilePath = join(objSchemaPath, '../');
+    const createSourceParams = [];
+    let allObjSchemas = await getAllLocalObjectSchemasWithHierarchy(
+      _izContext,
+      objSchemaPath
+    );
+
+    const findDataFunctionYaml = await createFindDataFunctionYaml(
+      _izContext,
+      allObjSchemas,
+      saveFilePath,
+      settings
+    );
+    const findDataHandlerSqs = createFindDataHandler(_izContext, saveFilePath);
+    const findDataMainFunction = await createFindDataMainFunction(
+      _izContext,
+      saveFilePath
+    );
+
+    // Combine all resources into a single array and add to createSourceParams
+    createSourceParams.push(
+      findDataHandlerSqs,
+      findDataMainFunction,
+      findDataFunctionYaml
+    );
+
+    return createSourceParams;
+  } catch (error) {
+    _izContext.logger.error('Error generating code with template:', error);
+    return [];
+  }
+}
+
+export default generateCodeWithTemplate;

package/src/TemplateData/findData/handler/data.js

@@ -0,0 +1,51 @@
+/*
+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 consts from '../../../libs/Consts.js';
+import utils from '../../../libs/Utils.js';
+
+const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = utils;
+const { SOURCE_PATH, FUNCTION_NAME, HANDLER } = consts;
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * receive srcPath
+ * create data for FindData Handler template
+ *
+ * @param {Object} srcPath
+ * @return {{ templatePath, templateData, setting } }
+ */
+function data(_izContext, srcPath) {
+  return {
+    templatePath: templatePath,
+    templateData: {},
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.findData),
+      saveFileName:
+        upperCase(FUNCTION_NAME.findData) + '_' + upperCase(HANDLER.hdrSqs),
+      fileExtension: '.js',
+      isAppend: false
+    }
+  };
+}
+
+export default data;

package/src/TemplateData/findData/handler/template.ejs

@@ -0,0 +1,136 @@
+/*
+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 { middlewareHandler as middleware, validatorSchema } from "@izara_project/izara-middleware";
+import { recordHandlerSharedLib } from "@izara_project/izara-core-library-record-handler";
+import Logger from '@izara_project/izara-core-library-logger';
+
+import findData from './FindData_Main.js';
+
+// validate event properties in body.Message of sqs event
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+
+// set schema for record.body.Message
+const perRecordsValidatorSchema = {
+  type: "object",
+  required: [
+    'fieldName',
+    'objType',
+    'identifiers',
+  ],
+  properties: {
+    fieldName: {
+      type: 'object',
+    },
+    objType: {
+      type: 'object',
+      required: ["serviceTag", "objectType"],
+      properties: {
+        serviceTag: {
+          type: "string",
+          enum: [process.env.iz_serviceTag]
+        },
+        objectType: validatorSchema.stringNotEmpty()
+      }
+    },
+    identifiers: {
+      type: 'object'
+    },
+    requestProperties: {
+      type: 'object',
+      default: {}
+    },
+    callingFlow: {
+      type: 'string',
+      default: ''
+    }
+
+  }
+};
+
+// set schema for record.body.MessageAttributes
+// const messageAttributeValidatorSchema = {
+//   type: "object",
+//   required: ['msgAtrrParam1', 'msgAtrrParam2'],
+//   properties: {
+//     msgAtrrParam1: {
+//       type: "string"
+//     },
+//     msgAtrrParam2: {
+//       type: "object"
+//     }
+//   }
+// };
+
+export const main = middleware.wrap(async (event, context) => {
+
+  try {
+
+    let recordPromises = [];
+
+    // loop each record and send to mainFunction
+    await Promise.all(event.Records.map(async record => { // promise.all for map() function
+
+      let passOnProperties = [];
+      record._izContext.logger.debug('record ReceiveMsgOutHdrSqs', record);
+
+      // validate message (and MessageAttributes)
+      await recordHandlerSharedLib.validateRecord(
+        record,                             // one record will send to mainFunction
+        "FindDataHdrSqs",                   // queue name that need to retry or send to dlq
+        perRecordsValidatorSchema,          // schema for record.Message
+        // messageAttributeValidatorSchema  // ----- for msgAttr default is null -> do not send this parameter if not want to validate msgAtt
+      );
+
+      // add argument (to invoke lambda) to passOnProperties[]
+      passOnProperties.push(record.body.Message.fieldName)
+      passOnProperties.push(record.body.Message.objType)
+      passOnProperties.push(record.body.Message.identifiers)
+      passOnProperties.push(record.body.Message.requestProperties)
+      passOnProperties.push(record.body.Message.callingFlow)
+      record._izContext.logger.debug('passOnProperties in handler', passOnProperties);
+
+      // call recordHandlerSharedLib.recordHandler with 3 parameters and return promise(resolve)
+      let recordPromise = recordHandlerSharedLib.recordHandler(
+        record,             // one record will send to mainFunction
+        findData,           // mainFunction that need to invoke.
+        "FindDataHdrSqs",   // queue name that need to retry or send to dlq
+        passOnProperties,   // all parameters that mainFunction needed.
+      );
+      record._izContext.logger.debug('after recordPromise in handler');
+      recordPromises.push(recordPromise); // push promise to recordPromises
+    }))
+
+    Logger.debug('before Promise.all(recordPromises) in handler');
+    try {
+      // --- main await all promises
+      await Promise.all(recordPromises); // await all promises
+
+      return event.Records // return all for local testing
+
+    } catch {
+      Logger.debug('Promise.all(recordPromises) in handler threw error (at least one record did no resolve)');
+    }
+    Logger.debug('after Promise.all(recordPromises) in handler');
+
+  } catch (err) {
+    Logger.error('Unhandled Error, FindDataHdrSqs: ', err);
+    throw (err);
+  }
+});

package/src/TemplateData/findData/mainFunction/data.js

@@ -0,0 +1,316 @@
+/*
+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 { NoRetryError } from '@izara_project/izara-core-library-core';
+import {
+  getObjectSchema,
+  utils
+} from '@izara_project/izara-core-library-service-schemas';
+
+import generateCodeConsts from '../../../libs/Consts.js';
+import generateCodeUtils from '../../../libs/Utils.js';
+
+const { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = generateCodeUtils;
+const {
+  SOURCE_PATH,
+  FUNCTION_NAME,
+  ADD_ON_DATA_STRUCTURE_TYPE,
+  STORAGE_TYPES
+} = generateCodeConsts;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+const getByDynamoTemplate = path.join(
+  __dirname,
+  '../GetByStorage/getByDynamo.ejs'
+);
+const getByGraphTemplate = path.join(
+  __dirname,
+  '../GetByStorage/getByGraph.ejs'
+);
+
+/**
+ * receive objectSchema
+ * create data for FindDataMain template
+ *
+ * @param {Object} objectSchema
+ * @return {{ templatePath, templateData, setting } }
+ */
+
+async function data(_izContext, srcPath) {
+  let schemaPath = path.join(srcPath, 'schemas');
+  let datas = [];
+
+  // 1. get objectTypes for check objType param
+  let getObjectTypes = await getObjectSchema.getAllLocalObjectSchemas(
+    _izContext,
+    schemaPath
+  );
+  // console.log(("getObjectTypes: ", getObjectTypes.fieldLookup)
+
+  for (const objectType of Object.keys(getObjectTypes.fieldLookup)) {
+    // console.log(("objectType: ", objectType)
+
+    // 2. get local object schema
+    let objectSchemaRecord =
+      await getObjectSchema.getLocalObjectSchemasWithHierarchy(
+        _izContext,
+        objectType,
+        schemaPath
+      );
+    // console.log("objectSchemaRecord: ", objectSchemaRecord)
+
+    let objectSchema = objectSchemaRecord.records[0];
+    // console.log(("objectSchema: ", objectSchema)
+
+    const identifiersNames = utils.getUsedFieldNamesOfIdentifiers(
+      _izContext,
+      objectSchema.identifiers
+    );
+    // _izContext.logger.debug("identifiersNames: ", identifiersNames);
+
+    let storageResources = objectSchema.storageResources;
+    let fieldNames = objectSchema.fieldNames; // object
+    let fieldNameDatas = [];
+
+    // loop for each main fieldNames
+    Object.entries(fieldNames).map(([field, schemas]) => {
+      // console.log(("field: ", field)
+      // console.log(("schemas: ", schemas)
+
+      let getInIdentifiers = false;
+
+      for (const identifierName of identifiersNames) {
+        if (field === identifierName) {
+          getInIdentifiers = true;
+        }
+      }
+
+      //* set field as key of object
+      //* use schemas for find storageType, graphServiceTag, tableName
+
+      // check type (use only string and number)
+      if (schemas.type === 'string' || schemas.type === 'number') {
+        let collectStorageDetail = {};
+        let storageResourceTags = schemas.storageResourceTags; // array
+
+        for (const storageResourceTag of storageResourceTags) {
+          // console.log(("storageResources: ", storageResources)
+
+          Object.entries(storageResources).map(
+            ([storageTag, storageDetail]) => {
+              if (storageResourceTag === storageTag) {
+                // console.log(("storageTag: ", storageTag)
+                // console.log(("storageDetail: ", storageDetail)
+
+                if (storageDetail.storageType === STORAGE_TYPES.graph) {
+                  if (
+                    collectStorageDetail.hasOwnProperty(STORAGE_TYPES.graph)
+                  ) {
+                    // console.log(("collectStorageDetail already have graph storageType")
+                  } else {
+                    Object.assign(collectStorageDetail, {
+                      [storageDetail.storageType]: {
+                        graphServerTag: storageDetail.graphServerTag,
+                        getInIdentifiers: getInIdentifiers
+                      }
+                    });
+                  }
+                } else if (
+                  storageDetail.storageType === STORAGE_TYPES.dynamoDB
+                ) {
+                  if (
+                    collectStorageDetail.hasOwnProperty(STORAGE_TYPES.dynamoDB)
+                  ) {
+                    // console.log(("collectStorageDetail already have dynamoDB storageType")
+                  } else {
+                    Object.assign(collectStorageDetail, {
+                      [storageDetail.storageType]: {
+                        tableName: storageDetail.tableName
+                      }
+                    });
+                  }
+                }
+              }
+            }
+          );
+        }
+
+        // console.log(("collectStorageDetail: ", collectStorageDetail)
+
+        //* Q: chooooooose get data from dynamoDB or graph if this fieldName have both of dynamoDB and graph storageTypes ???
+        //* A: choose dynamoDB
+        // collectStorageDetail: {
+        //   graph: { graphServerTag: 'GraphHandler' },
+        //   dynamoDB: { tableName: 'NotificationHello' }
+        // }
+        if (
+          collectStorageDetail.hasOwnProperty(STORAGE_TYPES.graph) &&
+          collectStorageDetail.hasOwnProperty(STORAGE_TYPES.dynamoDB)
+        ) {
+          delete collectStorageDetail[STORAGE_TYPES.graph];
+          // console.log(("collectStorageDetail after delete graph: ", collectStorageDetail)
+        }
+
+        fieldNameDatas.push({ [field]: collectStorageDetail });
+        // console.log(("fieldNameDatasMain: ", fieldNameDatas)
+      }
+    });
+
+    // fieldName in versionedData
+    if (objectSchema.hasOwnProperty('addOnDataStructure')) {
+      // array
+      // console.log("objectSchemas have addOnDataStructure: ", objectSchema.addOnDataStructure)
+      for (const versionedData of objectSchema.addOnDataStructure) {
+        // object // loop versionedData
+        // console.log("versionedData: ", versionedData)
+        if (versionedData.type === ADD_ON_DATA_STRUCTURE_TYPE.versionedData) {
+          let versionedStorageDetail = {};
+          let versioendStorageResourceTag = versionedData.storageResourceTag;
+          let versionedFieldNames = versionedData.fieldNames; // object
+
+          Object.entries(storageResources).map(
+            ([storageTag, storageDetail]) => {
+              if (versioendStorageResourceTag === storageTag) {
+                if (storageDetail.storageType === STORAGE_TYPES.graph) {
+                  versionedStorageDetail = {
+                    [storageDetail.storageType]: {
+                      graphServerTag: storageDetail.graphServerTag,
+                      versionedDataLabel: versionedData.versionedDataLabel
+                    }
+                  };
+                } else {
+                  throw new NoRetryError(
+                    `storageType of versionedData isn't graph`
+                  );
+                }
+              }
+            }
+          );
+          console.log('versionedStorageDetail: ', versionedStorageDetail);
+
+          Object.keys(versionedFieldNames).forEach(key => {
+            // console.log("key", key)
+            if (
+              versionedFieldNames[key].type === 'string' ||
+              versionedFieldNames[key].type === 'number'
+            ) {
+              fieldNameDatas.push({ [key]: versionedStorageDetail });
+            }
+          });
+
+          // for (const versionedFieldName of versionedFieldNames) { // object // loop versionedFieldNames
+
+          //   if (versionedFieldName.type === "string" || versionedFieldName.type === "number") {
+          //     fieldNameDatas.push({ [versionedFieldName.fieldName]: versionedStorageDetail })
+          //   }
+
+          // } // end loop versionedFieldNames
+        } // end loop versionedData
+        //fieldNameDatas.push(collectVersionedFieldNames)
+      }
+    }
+    // console.log(("fieldNameDatas: ", fieldNameDatas)
+
+    let fieldNameDatasPerObjectType = {
+      objectType: objectType,
+      fieldNames: fieldNameDatas
+    };
+    // console.log("fieldNameDatasPerObjectType: ", fieldNameDatasPerObjectType)
+
+    datas.push(fieldNameDatasPerObjectType);
+  } // end loop objectType
+
+  // console.log(("datas: ", datas)
+
+  // fieldNameDatas:  [
+  //   { notificationId: { graph: [Object], dynamoDB: [Object] } },
+  //   { notificationIdHello: { dynamoDB: {tableName: "NotificationHello"}} },
+  //   { notificationName: { graph: {graphServerTag: 'GraphHandler', versionedDataLabel: 'notificationSettings' }},
+  //   { notificationNameeeeeeeeeee: { graph: {graphServerTag: 'GraphHandler', versionedDataLabel: 'notificationSettingssssssssss'}}
+  // ]
+
+  // fieldNameDatasPerObjectType:  {
+  //   objectType: 'notification',
+  //   fieldNames: [
+  //     { notificationId: [Object] },
+  //     { notificationIdHello: [Object] },
+  //     { notificationName: [Object]},
+  //     { notificationNameeeeeeeeeee: [Object] }
+  //   ]
+  // }
+
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName: upperCase(FUNCTION_NAME.findData),
+      datas: datas,
+      getByDynamoTemplate: getByDynamoTemplate,
+      getByGraphTemplate: getByGraphTemplate,
+      storageDynamo: STORAGE_TYPES.dynamoDB,
+      storageTypeGraph: STORAGE_TYPES.graph
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.findData),
+      saveFileName: `FindData_Main`,
+      fileExtension: '.js',
+      isAppend: false
+    }
+  };
+
+  // datas:  [
+  //   {
+  //     objectType: 'consolidated',
+  //     fieldNames: [ {notificationGroupId: [Object], time: [Object]}]
+  //   },
+  //   {
+  //     objectType: 'notificationGroup',
+  //     fieldNames: [
+  //       {notificationGroupId: [Object]},
+  //       {notificationGroupName: [Object]},
+  //       {consolidatedType: [Object]},
+  //       {consolidatedFrequency: [Object]},
+  //       {consolidatedNextSendDue: [Object]}
+  //     ]
+  //   },
+  //   {
+  //     objectType: 'notification',
+  //     fieldNames: [
+  //       {notificationId: [Object]},
+  //       {notificationIdHello: [Object]},
+  //       {notificationName: [Object]},
+  //       {notificationNameeeeeeeeeee: [Object]}
+  //     ]
+  //   },
+  //   {
+  //     objectType: 'notificationTrigger',
+  //     fieldNames: [
+  //       {notificationTriggerId: [Object]},
+  //       {propertyName: [Object]},
+  //       {valueType: [Object]},
+  //       {valueString: [Object]},
+  //       {valueNumber: [Object]}
+  //     ]
+  //   }
+  // ]
+}
+
+export default data;