@izara_project/izara-market-library-service-schemas 1.0.65 → 1.0.67

package/src/reStructure/TemplateData/relationshipPerAction/update/action/handler/templateByHandler/sqsTemplate.ejs

@@ -0,0 +1,181 @@
+/*
+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 izara = require("@izara_project/izara-middleware");
+const middleware = izara.middlewareHandler;
+const callingFlowSharedLib = require('@izara_project/izara-core-library-calling-flow');
+const {
+  validateSchemaMiddleware
+} = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs');
+const Logger = require('@izara_project/izara-core-library-logger');
+const recordHandlerSharedLib = require('@izara_project/izara-core-library-record-handler');
+
+const <%- functionName %> = require('./<%- firstLetterUpperCase(functionName) %>_Main');
+
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+
+// validate event params in middleware before into function
+let validatorSchema = {
+  type: "object",
+  required: [
+  'firstObject',
+  'secondObject',
+  'oldReltypeAndDirection',
+  'newRelType',
+  ],
+  properties: {
+    firstObject: {
+      type: 'object',
+      required: ['objType', 'identifiers'],
+      properties: {
+        objType: {
+          type: 'object',
+          required: ['objectType', 'serviceTag'],
+          properties: {
+            serviceTag: izara.validatorSchema.stringNotEmpty(),
+            objectType: izara.validatorSchema.stringNotEmpty(),
+          }
+        },
+        identifiers: {
+          type: "object",
+          minProperties: 1
+        },
+      }
+    },
+    secondObject: {
+      type: 'object',
+      required: ['objType', 'identifiers'],
+      properties: {
+        objType: {
+          type: 'object',
+          required: ['objectType', 'serviceTag'],
+          properties: {
+            serviceTag: izara.validatorSchema.stringNotEmpty(),
+            objectType: izara.validatorSchema.stringNotEmpty(),
+          }
+        },
+        identifiers: {
+          type: "object",
+          minProperties: 1
+        },
+      }
+    },
+    oldReltypeAndDirection: {
+      type: 'object',
+      required: ['relType', 'relationshipDirection'],
+      properties: {
+        relType: {
+          type: 'object',
+          required: ['serviceTag', 'relationshipTag'],
+          properties: {
+            serviceTag: izara.validatorSchema.stringNotEmpty(),
+            relationshipTag: izara.validatorSchema.stringNotEmpty(),
+          }
+        },
+        relationshipProperties: {
+          type: 'object',
+        },
+        relationshipDirection: {
+          type: 'string',
+          enum: ['from', 'to']
+
+        },
+      }
+    },
+    newRelType: {
+      type: 'object',
+      required: ['serviceTag', 'relationshipTag'],
+      properties: {
+        serviceTag: izara.validatorSchema.stringNotEmpty(),
+        relationshipTag: izara.validatorSchema.stringNotEmpty(),
+      }
+    },
+    settings: {
+      type: 'object'
+    }
+  }
+};
+
+
+//(<globalVariable>
+  //</globalVariable>)
+
+  // validate event params in middleware before into main function
+  validatorSchema = callingFlowSharedLib.addOptionalCallingFlowToValidatorSchema(validatorSchema);
+  // if need to validate authorizer or additional params , add code to hook tag below
+
+  //(<afterValidateWith>)
+  //(</afterValidateWith>)
+
+  module.exports.main = middleware.wrap(async (event, context, callback) => {
+
+    try {
+
+      let recordPromises = []; // final return
+
+      // loop each record and send to mainFunction
+      await Promise.all(event.Records.map(async record => { // promise.all for map() function
+
+        let passOnProperties = []
+
+        // --- validate message (and MessageAttributes)
+        await recordHandlerSharedLib.validateRecord(
+          record, // one record will send to mainFunction
+          "<%-firstLetterUpperCase(queueName) %>",                       // queue name that need to retry or send to dlq
+          validatorSchema, // 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)
+        passOnProperties.push(callingFlowSharedLib.addCallingFlowToPassOnProperties(record.body.Message));
+        //(<afterPutParamIntoMainFunction>)
+        //(</afterPutParamIntoMainFunction>)
+
+        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
+          <%- functionName %>.<%- functionName %>,     // mainFunction that need to invoke.
+          "<%-firstLetterUpperCase(queueName) %>",                          // 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
+        })) //end record
+
+        Logger.debug('before Promise.all(recordPromises) in handler');
+        try {
+          await Promise.all(recordPromises); // await all promises
+          return event.Records // return all for local test
+        } 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, updateRelationshipHdrDsq:', err);
+        throw (err);
+      }
+    });
+  <%_ 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/relationshipPerAction/update/complete/functionYaml/data.js

@@ -101,7 +101,7 @@ function createParamForCreateSource(srcPath) {
       handlerType,
       additionalResourcePermission,
       resourceLocation: SOURCE_PATH.resourceLocationRelationshipPerAction,
-      functionNameConfig: upperCase(SHORT_FUNCTION_NAME.updateRelComplete),
+      functionNameConfig: upperCase(SHORT_FUNCTION_NAME(FUNCTION_NAME.updateRelComplete)),
       roleName: SOURCE_GENERATE_IAM_ROLE.RelationshipCompleteRole
     },
     setting: {

package/src/reStructure/TemplateData/resourceYaml/dynamodb/mainResourcePerObjectSchemaData.js

@@ -49,7 +49,7 @@ const { getLocalConfig } = require('../../../../MainLibs/src/Utils.js')
  */
 
 function dataForMainDynamoDbYamlFromObjectSchema(_izContext, objectSchema, srcPath) {
-  let dynamoDbYamlTempleteData = [];
+  let dynamoDbYamlTemplateData = [];
 
   let identifierDetail = {};
   for (let identifier of objectSchema.identifiers) { //check identifiers from objectSchema
@@ -119,10 +119,11 @@ function dataForMainDynamoDbYamlFromObjectSchema(_izContext, objectSchema, srcPa
     // if (storageResource.hasOwnProperty("serviceTag") && storageResource.serviceTag !== getLocalConfig(srcPath)) {
     //   continue; // if serviceTag of storageResource not own service will skip
     // }
+
     if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
       let templateData = {
-        tableName: storageResource.tableName,
-        resourceName: storageResource.tableName,
+        tableName: upperCase(storageResource.tableName),
+        resourceName: upperCase(storageResource.tableName),
         attributes: []
       };
       if (storageResource.hasOwnProperty("groupByPartitionKeyField")) {
@@ -145,11 +146,11 @@ function dataForMainDynamoDbYamlFromObjectSchema(_izContext, objectSchema, srcPa
         }
       }
       // templateData.resourceName = upperCase(objectSchema.objectType)
-      dynamoDbYamlTempleteData.push(templateData)
+      dynamoDbYamlTemplateData.push(templateData)
     }
   }
-
-  return dynamoDbYamlTempleteData
+  // console.log("dynamoDbYamlTemplateData", dynamoDbYamlTemplateData)
+  return dynamoDbYamlTemplateData
 }
 
 const createSourceDataDynamoDB = (_izContext, objectSchema, srcPath) => {
@@ -158,7 +159,7 @@ const createSourceDataDynamoDB = (_izContext, objectSchema, srcPath) => {
 
 
   const dynamoDbMainYamlDataList = dataForMainDynamoDbYamlFromObjectSchema(_izContext, objectSchema, srcPath)
-
+  // console.log("generateDynamoPerObjectSchema", objectSchema)
   for (let dynamoDbMainYamlData of dynamoDbMainYamlDataList) {
     resultsForCreateSource.push({
       templatePath: templatePath,

package/src/reStructure/TemplateData/resourceYaml/filterGenerateResource/data.js

@@ -30,53 +30,59 @@ const STORAGE_TYPES = {
   graph: "graph"
 }
 const { SOURCE_PATH, SAVE_FILE_NAME } = require('../../../../MainLibs/src/Consts')
-const { firstUpperCase: upperCase, getLocalConfig } = require('../../../../MainLibs/src/Utils')
+const { firstLetterUpperCase: upperCase, getLocalConfig } = require('../../../../MainLibs/src/Utils')
 const getObjectSchema = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
 const { NoRetryError } = require("@izara_project/izara-core-library-core");
 
 async function filterCreateResourceYaml(_izContext, createSourceParams, objSchemaPath) {
-  let tableNamesToFilter = new Set();
-  let ownServiceTag = getLocalConfig(path.join(objSchemaPath, "../../"), "iz_serviceTag")
-
-  const allLocalFlowSchema = await getObjectSchema.getAllLocalFlowSchemas(_izContext, objSchemaPath);
-  await Promise.all(allLocalFlowSchema.records.map(async (flowSchema) => {
-    if (flowSchema.statusType === "storedCache") {
-      tableNamesToFilter.add(...await getStoredCacheTableFromFlowSchema(_izContext, flowSchema, objSchemaPath))
-    } else if (flowSchema.statusType === "triggerCache" && flowSchema?.triggerType === "storedCache") {
-      tableNamesToFilter.add(...await getStoredCacheTableFromFlowSchema(_izContext, flowSchema, objSchemaPath))
-    }
-  }))
-
-  const allLocalObjSchema = await getObjectSchema.getAllLocalObjectSchemasWithHierarchy(_izContext, objSchemaPath);
-  await Promise.all(allLocalObjSchema.records.map(async (objSchema) => {
-    if (objSchema.hasOwnProperty("extendObjType")) {
-      for (const storageResource of Object.values(objSchema.storageResources)) {
-        if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
-          if (storageResource?.serviceTag !== ownServiceTag) {
-            tableNamesToFilter.add(storageResource.tableName)
+  try {
+    let tableNamesToFilter = new Set();
+    let ownServiceTag = getLocalConfig(path.join(objSchemaPath, "../../"), "iz_serviceTag")
+
+    const allLocalFlowSchema = await getObjectSchema.getAllLocalFlowSchemas(_izContext, objSchemaPath);
+    await Promise.all(allLocalFlowSchema.records.map(async (flowSchema) => {
+      if (flowSchema.statusType === "storedCache") {
+        tableNamesToFilter.add(...await getTableNameFromFlowSchema(_izContext, flowSchema, objSchemaPath))
+      } else if (flowSchema.statusType === "triggerCache") {
+        tableNamesToFilter.add(...await getTableNameFromFlowSchema(_izContext, flowSchema, objSchemaPath))
+      }
+    }))
+
+    const allLocalObjSchema = await getObjectSchema.getAllLocalObjectSchemasWithHierarchy(_izContext, objSchemaPath);
+    await Promise.all(allLocalObjSchema.records.map(async (objSchema) => {
+      if (objSchema.hasOwnProperty("extendObjType")) {
+        for (const storageResource of Object.values(objSchema.storageResources)) {
+          if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+            if (storageResource?.serviceTag !== ownServiceTag) {
+              tableNamesToFilter.has(storageResource.tableName)
+            }
           }
         }
       }
-    }
-  }))
+    }))
+
 
-  let filteredCreateSourceParams = createSourceParams.filter(
-    (result) => !tableNamesToFilter.has(result.templateData.tableName)
-  )
+    console.log("tableNamesToFilter", tableNamesToFilter)
+    let filteredCreateSourceParams = createSourceParams.filter(
+      (result) => !tableNamesToFilter.has(result.templateData.tableName)
+    )
 
-  // console.log("filteredCreateSourceParams", filteredCreateSourceParams)
-  return filteredCreateSourceParams
+    // console.log("filteredCreateSourceParams", filteredCreateSourceParams)
+    return filteredCreateSourceParams
+  } catch (err) {
+    console.log(err)
+  }
 }
 
 module.exports = filterCreateResourceYaml;
 
-async function getStoredCacheTableFromFlowSchema(_izContext, flowSchema, objSchemaPath) {
-  let tableNameStoredCache = new Set();
+async function getTableNameFromFlowSchema(_izContext, flowSchema, objSchemaPath) {
+  let tableNameStoredCache = [];
   const objectSchema = await getObjectSchema.getLocalObjectSchemas(_izContext, [flowSchema.objType.objectType], objSchemaPath).then(res => res.records[0])
   if (objectSchema) {
     for (const storageResource of Object.values(objectSchema.storageResources)) {
       if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
-        tableNameStoredCache.add(storageResource.tableName);
+        tableNameStoredCache.push(upperCase(storageResource.tableName));
       }
     }
   } else {

package/src/reStructure/TemplateData/resourceYaml/generateTemplateData.js

@@ -61,7 +61,6 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
         try {
 
           let createSourceDynamoDb = createSourceDataDynamoDB(_izContext, objectSchema, saveFilePath)
-
           const [dynamoResources, updatedTableYaml] = checkValidTableYaml(
             _izContext,
             createSourceDynamoDb,
@@ -78,7 +77,6 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
         }
       }
     }
-
     // Add default resources
     const defaultDynamoDbResources = createDefaultDynamoDb(_izContext, saveFilePath);
     const defaultSnsInSqsResources = createFindDataAndProcessLogicalDefaultSnsInSqs(_izContext, saveFilePath);
@@ -97,9 +95,11 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
         ...dynamoDbResourcePerRelationshipLink
       )
     }
+
+    // console.log("createSourceParams before filter", createSourceParams)
     const filteredCreateSourceParams = await filterCreateResourceYaml(_izContext, createSourceParams, objSchemaPath);
 
-    // console.log("filteredCreateSourceParams", filteredCreateSourceParams);
+    console.log("filteredCreateSourceParams", filteredCreateSourceParams);
 
     return filteredCreateSourceParams;
   } catch (error) {