@izara_project/izara-market-library-service-schemas 1.0.23 → 1.0.24

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

@@ -0,0 +1,297 @@
+/*
+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 { SOURCE_PATH, FUNCTION_NAME, ADD_ON_DATA_STRUCTURE_TYPE } = require("../../../../MainLibs/src/Consts");
+// const { firstLetterUpperCase: upperCase } = require("../../../../MainLibs/index.js").utils;
+const {
+  firstLetterLowerCase: lowerCase,
+  firstLetterUpperCase: upperCase,
+} = require("../../../../MainLibs/index.js").utils;
+const {
+  createIamRole,
+  resourceNames,
+  RESOURCE_CLASSES,
+  DEFAULT_LAMBDA_ROLE_PER_ACTION,
+  SQS_RESOURCE,
+  SOURCE_PATH,
+  SAVE_FILE_NAME,
+  FUNCTION_NAME,
+  shortNameHandler,
+  HANDLER,
+  ADD_ON_DATA_STRUCTURE_TYPE
+} = require("../../../../MainLibs/src/Consts");
+
+const serviceSchemas = require('@izara_project/izara-core-library-service-schemas');
+const STORAGE_TYPES = serviceSchemas.consts.STORAGE_TYPES;
+const getObjectSchemas = serviceSchemas.getObjectSchema;
+const { getUsedFieldNamesOfIdentifiers } = serviceSchemas.utils;
+
+const templatePath = path.join(__dirname, "./template.ejs")
+const getByDynamoTemplate = path.join(__dirname, "../GetByStorage/getByDynamo.ejs")
+const getByGraphTemplate = path.join(__dirname, "../GetByStorage/getByGraph.ejs")
+
+const NoRetryError = require("@izara_project/izara-core-library-core/src/NoRetryError");
+
+/**
+ * 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 getObjectSchemas.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 getObjectSchemas.getLocalObjectSchemasWithHierarchy(
+      _izContext,
+      objectType,
+      schemaPath
+    );
+    // console.log("objectSchemaRecord: ", objectSchemaRecord)
+
+    let objectSchema = objectSchemaRecord.records[0];
+    // console.log(("objectSchema: ", objectSchema)
+
+    const identifiersNames = 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 === ADD_ON_DATA_STRUCTURE_TYPE.versionedData) {
+
+          let versionedStorageDetail = {};
+          let versioendStorageResourceTag = versionedData.storageResourceTag;
+          let versionedFieldNames = versionedData.fieldNames; // array
+
+          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)
+
+          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]}
+  //     ]
+  //   }
+  // ]
+}
+
+module.exports = data;

package/src/reStructure/TemplateData/findData/mainFunction/template.ejs

@@ -0,0 +1,151 @@
+/*
+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 izaraShared = require("@izara_project/izara-shared");
+const findDataSharedLib = izaraShared.findDataSharedLib;
+const graphSharedLib = izaraShared.graphSharedLib;
+const dynamodbSharedLib = izaraShared.dynamodbSharedLib;
+
+const serviceSchemas = require('@izara_project/izara-core-library-service-schemas');
+const serviceConfig = serviceSchemas.serviceConfig;
+const identifierObj = serviceSchemas.identifiersObject
+
+//(<additionalModule>)
+//(</additionalModule>)
+
+/**
+ * triggered from searchResult for each requiredData field per one identifiers
+ * @param {Object} _izContext
+ * @param {string} fieldName
+ * @param {Object} objType
+ * @param {Object} identifiers
+ * @param {Object} requestProperties
+ *
+ * @returns {object} description of return value
+ */
+
+exports.findData = async (
+  _izContext,
+  fieldName,
+  objType,
+  identifiers,
+  requestProperties,
+  callingFlow,
+  //(<additionalParams>)
+  //(</additionalParams>)
+) => {
+
+  try {
+
+    _izContext.logger.debug('----- findData event params -----', {
+      fieldName: fieldName,
+      objType: objType,
+      identifiers: identifiers,
+      requestProperties: requestProperties,
+      callingFlow: callingFlow
+    });
+
+    // removeAttributes on expired
+    let removeAttributes = [];
+    //(<removeAttributes>)
+    //(</removeAttributes>)
+
+    // Check/create FindDataMain status
+    let [findDataMainStatus, findDataId, findDataMain] = await findDataSharedLib.checkFindDataMainStatus(
+      _izContext,
+      fieldName,
+      objType,
+      identifiers,
+      requestProperties,
+      callingFlow,
+      removeAttributes
+    );
+    _izContext.logger.debug("result after checkFindDataMainStatus is", {
+      findDataMainStatus: findDataMainStatus,
+      findDataId: findDataId,
+      findDataMain: findDataMain
+    })
+
+    if (findDataMainStatus != "process") {
+      _izContext.logger.debug(`findDataMainStatus status isn't process :${findDataMainStatus}`)
+      return; // stop process
+    };
+
+    let errorsFound = [];
+
+    let standardErrorParams = [
+      _izContext,
+      fieldName,
+      objType,
+      identifiers,
+      requestProperties,
+      null,
+      "error"
+    ];
+
+  <% for (let idx = 0; idx < datas.length; idx++) { _%>
+    <% let objectType = datas[idx].objectType _%>
+    if (objType.objectType === <%- JSON.stringify(objectType) %>) {
+      _izContext.logger.debug("objectType: ", objType.objectType)
+
+      <% let fieldNames = datas[idx].fieldNames _%>
+      <% for (let idx = 0; idx < fieldNames.length; idx++) { _%>
+        <% let fieldName = Object.keys(fieldNames[idx])[0] _%>
+        <% let storageDetails = (Object.values(fieldNames[idx])[0]) _%>
+        if (fieldName == <%- JSON.stringify(fieldName) %>) {
+          _izContext.logger.debug("fieldName: ", fieldName)
+
+          <% Object.entries(storageDetails).map(([storage, details]) => { _%>
+            <% let versionedDataLabel = [] _%>
+            <% if (storage === storageTypeGraph && details.hasOwnProperty("versionedDataLabel")){ versionedDataLabel.push(details.versionedDataLabel) } _%>
+            <% if (storage === storageDynamo){ %><%- include(getByDynamoTemplate, {tableName: details.tableName, fieldName: fieldName, objectType: objectType}) %><% } _%>
+            <% if (storage === storageTypeGraph){ %><%- include(getByGraphTemplate, {graphServerTag: details.graphServerTag, versionedDataLabel: versionedDataLabel, fieldName: fieldName, objectType: objectType, getInIdentifiers: details.getInIdentifiers}) %><% } _%>
+          <% }) _%>
+        }<% if (idx + 1 == fieldNames.length) { %>
+        <%- createAdditionalFieldNamesTag(objectType) %>
+        <% } _%>
+          else <% } _%> {
+          errorsFound.push("unrecognised fieldName")
+          standardErrorParams.push(errorsFound)
+          await findDataSharedLib.completeFindDataMain(...standardErrorParams);
+          return;
+        }
+    } <% if (idx + 1 == datas.length) { %>
+      //(<addtionalObjectType>)
+      //(</addtionalObjectType>)
+      <% } _%>
+      else<% } %> {
+      errorsFound.push("unrecognised objectType")
+      standardErrorParams.push(errorsFound)
+      await findDataSharedLib.completeFindDataMain(...standardErrorParams);
+      return;
+    }
+
+    return "Function FindData Finish";
+
+  } catch (err) {
+    _izContext.logger.error('error FindDataMain: ', err)
+    throw (err)
+  }
+}
+
+<%_ function createAdditionalFieldNamesTag(objectType) {
+  return `//(<additional${objectType}FieldNames>)
+          //(</additional${objectType}FieldNames>)`
+} _%>

package/src/reStructure/TemplateData/flowSchema/components/schema/inProcess/functionYaml/data.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 { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = require("../../../../../../MainLibs/src/Utils");
+const { SOURCE_PATH, defaultIamRolePerAction, shortNameHandler, SAVE_FILE_NAME, createIamRole, RESOURCE_CLASSES, SNS_RESOURCE, resourceNames, DYNAMO_RESOURCE } = require('../../../../libs/Consts');
+const templatePath = path.join(__dirname, "./template.ejs")
+
+
+function data(_izContext, flowSchema, srcPath) {
+  return [createSourceParams(_izContext, srcPath)]
+}
+
+function createSourceParams(_izContext, flowSchema, srcPath) {
+  let functionName = "InProcessWebSocket";
+  let handlerType = "HdrWbs"
+  let additionalResourcePermission = defaultIamRolePerAction();
+  let functionNameConfig = upperCase(functionName) + upperCase(shortNameHandler(handlerType))
+
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.sns, `InProcess${flowSchema.flowTag}`)
+      ]
+    ),
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.dynamoDbTable]: [
+          DYNAMO_RESOURCE.putItem,
+          DYNAMO_RESOURCE.deleteItem
+        ]
+      },
+      resourceNames(RESOURCE_CLASSES.dynamoDbTable, "WebSocketTask")
+    )
+  )
+
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName,
+      handlerType,
+      functionNameConfig,
+      additionalResourcePermission,
+      resourceLocation: SOURCE_PATH.resourceLocationWebSocket,
+      route: flowSchema.flowTag
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+      saveFileName: upperCase(SAVE_FILE_NAME.flowSchema),
+      fileExtension: '.yml',
+      isAppend: true
+    }
+  }
+}
+
+
+module.exports = data;

package/src/reStructure/TemplateData/flowSchema/components/schema/inProcess/functionYaml/template.ejs

@@ -0,0 +1,37 @@
+<%_ const join = require('path').join; _%>
+<%- firstLetterUpperCase(functionNameConfig) %>:
+  handler: <%- join(resourceLocation, `${firstLetterUpperCase(functionName)}_${firstLetterUpperCase(handlerType)}.main`)%>
+  name: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(functionName) %><%- firstLetterUpperCase(handlerType) %>
+  events:
+    - websocket:
+        route: $connect
+    - websocket:
+        route: $disconnect
+    - websocket:
+        route: $default
+    - websocket:
+        route: <%- route %>
+        # authorizer: ${self:custom.iz_authorizerAppLevel}
+      # identifierResource: 'route.request.header.Auth'
+  iamRoleStatements:
+    <%_ additionalResourcePermission.forEach(resourcePermission => { _%>
+    - Effect: <%- resourcePermission.effect %>
+      Action:
+        <%_ Object.keys(resourcePermission.action).forEach(resourcePerAction => { _%>
+        <%_ resourcePermission.action[resourcePerAction].forEach(permission => { _%>
+        - <%- resourcePerAction %>:<%- permission %>
+        <%_}) _%>
+        <%_ }) _%>
+      Resource:
+        <%_ resourcePermission.resource.forEach(resource => { _%>
+        - <%- resource %>
+        <%_ }) _%>
+    <%_}) _%>
+    #<#<%- functionName %><%- handlerType %>IamRole#>
+    #<#/<%- functionName %><%- handlerType %>IamRole#>
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
+<%_ function firstLetterLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1)
+} _%>

package/src/reStructure/TemplateData/flowSchema/components/schema/inProcess/handler/data.js

@@ -0,0 +1,46 @@
+/*
+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 { firstLetterLowerCase: lowerCase, firstLetterUpperCase: upperCase } = require("../../../../../../MainLibs/src/Utils");
+const { SOURCE_PATH } = require('../../../../libs/Consts');
+const templatePath = path.join(__dirname, './template.ejs')
+
+function data(_izContext, srcPath) {
+  return [createSourceParams(_izContext, srcPath)]
+}
+
+function createSourceParams(_izContext, srcPath) {
+  let functionName = "InProcessWebSocket";
+  let handlerType = "HdrWbs";
+
+  return {
+    templatePath: templatePath,
+    templateData: {},
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.webSocket),
+      saveFileName: upperCase(functionName) + upperCase(handlerType),
+      fileExtension: ".js",
+      isAppend: true
+    }
+  }
+}
+
+
+module.exports = data;