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

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

@@ -0,0 +1,210 @@
+/*
+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';
+
+// Import required modules
+const { join } = require('path');
+
+const {
+  getAllLocalObjectSchemasWithHierarchy,
+  // getAllLocalRelationshipSchemas,
+  getAllLocalRelationshipSchema,
+  getAllLocalFlowSchemas
+} = require('@izara_project/izara-core-library-service-schemas/src/GetObjectSchema');
+
+// Core components
+const createWebSocketDynamoDb = require('./components/websocket/dynamoDb/WebSocketTaskData');
+const createReservedDataMainTable = require('./components/websocket/dynamoDb/ReservedTableData');
+const createBucketS3 = require('./components/upload/relate/S3/data');
+const createWebSocketGenerateCodeLibs = require('./components/upload/relate/libs/data');
+
+// CreateObject components
+const createFunctionYamlCreateObjectWebSocket = require('./components/upload/createObject/functionYaml/data');
+const createHandlerCreateObjectWebSocket = require('./components/upload/createObject/handler/data');
+const createMainFunctionCreateObjectWebSocket = require('./components/upload/createObject/mainFunction/data');
+
+// CreateObjectComplete components
+const createWebSocketCreateObjectCompleteFunctionYaml = require('./components/upload/createObjectComplete/functionYaml/data');
+const createWebSocketCreateObjectCompleteQueue = require('./components/upload/createObjectComplete/sns-sqs/data');
+const createWebSocketCreateObjectCompleteHandler = require('./components/upload/createObjectComplete/handler/data');
+const createWebSocketCreateObjectCompleteMainFunction = require('./components/upload/createObjectComplete/mainFunction/data');
+
+// PreSign URL components
+const createGetPreSignUrlFunctionYaml = require('./components/upload/preSignUrl/getSignUrls/functionYaml/data');
+const createGetPreSignUrlHandler = require('./components/upload/preSignUrl/getSignUrls/handler/data');
+const createGetPreSignUrlMainFunction = require('./components/upload/preSignUrl/getSignUrls/mainFunction/data');
+const createGetPreSignUrlQueueName = require('./components/upload/preSignUrl/getSignUrls/sqs/data');
+
+// Reserved limit components
+const createReservedLimitFunctionYaml = require('./components/upload/preSignUrl/reservedLimit/functionYaml/data');
+const createReservedLimitHandler = require('./components/upload/preSignUrl/reservedLimit/handler/data');
+const createReservedLimitMainFunction = require('./components/upload/preSignUrl/reservedLimit/mainFunction/data');
+const createReservedLimitQueueName = require('./components/upload/preSignUrl/reservedLimit/queue/data');
+
+// Process uploaded file components
+const createProcessAfterUploadS3FunctionYmlS3 = require('./components/upload/processFile/functionYml/HdrS3/data');
+const createProcessAfterUploadS3Queue = require('./components/upload/processFile/queue/data');
+const createProcessAfterUploadS3HandlerS3 = require('./components/upload/processFile/handler/handlerS3/data');
+const createProcessAfterUploadS3MainFunction = require('./components/upload/processFile/mainFunction/data');
+
+// Confirm reservation components
+const createConfirmAfterUploadS3FunctionYaml = require('./components/upload/confirmReserved/functionYaml/data');
+const createConfirmAfterUploadS3Handler = require('./components/upload/confirmReserved/handler/data');
+const createConfirmAfterUploadS3MainFunction = require('./components/upload/confirmReserved/mainFunction/data');
+const createConfirmAfterUploadS3Queue = require('./components/upload/confirmReserved/queue/data');
+
+/**
+ * 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, '../');
+    let createSourceParams = [];
+    const allLocalFlowSchemas = await getAllLocalFlowSchemas(_izContext, objSchemaPath);
+
+    // default webSocket setting
+    const webSocketTaskTable = createWebSocketDynamoDb(_izContext, saveFilePath);
+    // const webSocketConnectYaml = createWebSocketConnectYaml(_izContext, saveFilePath);
+    // const webSocketConnectHandler = createWebSocketConnectHandler(_izContext, saveFilePath);
+
+    const webSocketResource = [...webSocketTaskTable
+      // ...webSocketConnectYaml, ...webSocketConnectHandler,
+    ]
+    if (allLocalFlowSchemas.records.length) {
+      createSourceParams.push(
+        ...webSocketResource
+      )
+    }
+
+    for (const flowSchema of allLocalFlowSchemas.records) {
+      // console.log("flowSchema::", flowSchema)
+      const reservedDataTable = createReservedDataMainTable(_izContext, saveFilePath);
+      const bucketS3 = createBucketS3(_izContext, flowSchema, saveFilePath)
+
+
+      const functionYamlCreateObjectWebSocket = createFunctionYamlCreateObjectWebSocket(_izContext, flowSchema, saveFilePath);
+      const handlerCreateObjectWebSocket = createHandlerCreateObjectWebSocket(_izContext, flowSchema, saveFilePath);
+      const mainFunctionCreateObjectWebSocket = await createMainFunctionCreateObjectWebSocket(_izContext, flowSchema, saveFilePath);
+      const webSocketCreateObjectCompleteFunctionYaml = createWebSocketCreateObjectCompleteFunctionYaml(_izContext, saveFilePath);
+      const webSocketCreateObjectCompleteQueue = createWebSocketCreateObjectCompleteQueue(_izContext, saveFilePath);
+      const webSocketCreateObjectCompleteMainFunction = createWebSocketCreateObjectCompleteMainFunction(_izContext, saveFilePath)
+      const webSocketCreateObjectCompleteHandler = createWebSocketCreateObjectCompleteHandler(_izContext, saveFilePath);
+
+      // const webSocketCreateObjectStordCache = createWebSocketCreateObjectStoredCache(_izContext, saveFilePath);
+      const webSocketGenerateCodeLibs = createWebSocketGenerateCodeLibs(_izContext, saveFilePath)
+
+      const getPreSignUrlFunctionYaml = createGetPreSignUrlFunctionYaml(_izContext, saveFilePath);
+      const getPreSignUrlHandler = createGetPreSignUrlHandler(_izContext, saveFilePath);
+      const getPreSignUrlMainFunction = createGetPreSignUrlMainFunction(_izContext, saveFilePath);
+      const getPreSignUrlQueue = createGetPreSignUrlQueueName(_izContext, saveFilePath);
+
+      const reservedLimitCompleteFunctionYaml = createReservedLimitFunctionYaml(_izContext, saveFilePath);
+      const reservedLimitCompleteMainFunction = createReservedLimitMainFunction(_izContext, flowSchema, saveFilePath);
+      const reservedLimitCompleteHandler = createReservedLimitHandler(_izContext, saveFilePath);
+      const reservedLimitCompleteQueue = createReservedLimitQueueName(_izContext, saveFilePath);
+
+      const processAfterUploadFunctionYmlS3 = createProcessAfterUploadS3FunctionYmlS3(_izContext, flowSchema, saveFilePath);
+      // const processAfterUploadFunctionYamlHdrDsq = createProcessAfterUploadS3FunctionYmlDsq(_izContext, saveFilePath);
+      const processAfterUploadSqs = createProcessAfterUploadS3Queue(_izContext, saveFilePath);
+      const processAfterUploadHandlerS3 = createProcessAfterUploadS3HandlerS3(_izContext, saveFilePath);
+      // const processAfterUploadHandlerDsq = createProcessAfterUploadS3HandlerDsq(_izContext, saveFilePath);
+      const processAfterUploadMainFunction = createProcessAfterUploadS3MainFunction(_izContext, saveFilePath);
+
+      const confirmReservedAfterUploadFunctionYaml = createConfirmAfterUploadS3FunctionYaml(_izContext, saveFilePath);
+      const confirmReservedAfterUploadHandler = createConfirmAfterUploadS3Handler(_izContext, saveFilePath);
+      const confirmReservedAfterUploadMainFunction = createConfirmAfterUploadS3MainFunction(_izContext, saveFilePath);
+      const confirmReservedAfterUploadQueue = createConfirmAfterUploadS3Queue(_izContext, saveFilePath);
+
+      // Group related resources for better organization
+      const webSocketFunctions = [
+        ...functionYamlCreateObjectWebSocket,
+        ...handlerCreateObjectWebSocket,
+        ...mainFunctionCreateObjectWebSocket,
+        ...webSocketCreateObjectCompleteFunctionYaml,
+        ...webSocketCreateObjectCompleteQueue,
+        ...webSocketCreateObjectCompleteMainFunction,
+        ...webSocketCreateObjectCompleteHandler
+      ];
+
+      const getPreSignUrlResources = [
+        ...getPreSignUrlFunctionYaml,
+        ...getPreSignUrlHandler,
+        ...getPreSignUrlMainFunction,
+        ...getPreSignUrlQueue
+      ];
+
+      const reservedLimitResources = [
+        ...reservedLimitCompleteFunctionYaml,
+        ...reservedLimitCompleteHandler,
+        ...reservedLimitCompleteMainFunction,
+        ...reservedLimitCompleteQueue
+      ];
+
+      const processAfterUploadResources = [
+        ...processAfterUploadFunctionYmlS3,
+        ...processAfterUploadSqs,
+        ...processAfterUploadHandlerS3,
+        ...processAfterUploadMainFunction
+        // Commented resources kept for reference
+        // ...processAfterUploadHandlerDsq,
+        // ...processAfterUploadFunctionYamlHdrDsq
+      ];
+
+      const confirmAfterUploadResources = [
+        ...confirmReservedAfterUploadFunctionYaml,
+        ...confirmReservedAfterUploadHandler,
+        ...confirmReservedAfterUploadMainFunction,
+        ...confirmReservedAfterUploadQueue
+      ];
+
+      if (flowSchema.hasOwnProperty("uploadS3") && flowSchema.uploadS3 === true) {
+        // Group all resources related to S3 upload functionality
+        const webSocketUploadS3Resources = [
+          ...webSocketFunctions,
+          ...webSocketGenerateCodeLibs,
+          ...reservedDataTable
+        ];
+
+        // Add all resources to the parameters array
+        createSourceParams.push(
+          ...webSocketUploadS3Resources,
+          ...getPreSignUrlResources,
+          ...reservedLimitResources,
+          ...bucketS3,
+          ...processAfterUploadResources,
+          ...confirmAfterUploadResources
+        );
+      }
+
+      if (flowSchema.hasOwnProperty("initializeRequest") && flowSchema.hasOwnProperty("response")) {
+        const webSocketEndpointResource = []
+        createSourceParams.push(...webSocketEndpointResource)
+      }
+    }
+
+    return createSourceParams;
+  } catch (error) {
+    _izContext.logger.error('Error generating code with template perActionComplete:', error);
+    return [];
+  }
+}
+
+module.exports = generateCodeWithTemplate;

package/src/reStructure/TemplateData/flowSchema/legacy/hookCode-old/functionYaml/data.js

@@ -0,0 +1,101 @@
+/*
+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 } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+const { FLOW_SCHEMA_HOOK_STATE } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+const { firstLetterUpperCase: upperCase } = require('../../../../../../MainLibs/src/Utils')
+const { SOURCE_PATH, defaultIamRolePerAction, createIamRole, RESOURCE_CLASSES, SNS_RESOURCE, resourceNames, DYNAMO_RESOURCE, SAVE_FILE_NAME, FUNCTION_NAME, shortNameHandler, SQS_RESOURCE } = require("../../../../libs/Consts");
+const templatePath = path.join(__dirname, "template.ejs")
+/**
+ * receive objectSchema
+ * create data for WebScoket handler template
+ *
+ * @param {Object} objectSchema
+ * @return {{templatePath, templateData,setting}}
+ */
+
+function data(_izContext, flowSchema, srcPath) {
+  return [createSourceParams(_izContext, flowSchema, srcPath)]
+}
+
+function createSourceParams(_izContext, flowSchema, srcPath) {
+  let hook;
+  let hookFunctionName
+  let handlerType;
+  let queueName;
+  let filterPattern;
+  let additionalResourcePermission = defaultIamRolePerAction();
+  if (flowSchema?.hook) {
+    for (const [hookName, hookProperties] of Object.entries(flowSchema.hook)) {
+      for (const hookFunction of hookProperties.functionList) {
+        if (hookName === FLOW_SCHEMA_HOOK_STATE.beforeCreate) {
+          if (hookFunction.event.continueFlow === true && hookFunction.event.initialEvent === false) {
+            hook = true
+            hookFunctionName = upperCase(hookFunction.name)
+            handlerType = upperCase(hookFunction.event.handlerType);
+            filterPattern = hookFunction.event.filterPattern;
+            additionalResourcePermission.push(
+              createIamRole(
+                {
+                  [RESOURCE_CLASSES.sns]: [
+                    SNS_RESOURCE.publish
+                  ]
+                },
+                [
+                  resourceNames(RESOURCE_CLASSES.sns, "InImportBatchMainCreate")
+                ]
+              )
+            )
+            if (upperCase(handlerType) === upperCase(HANDLER.hdrDsq)) {
+              queueName = hookFunction.event.queueName;
+            } else if (upperCase(handlerType) === upperCase(HANDLER.hdrSqs)) {
+              if (hookFunction.event.topicName.includes("In")) {
+                queueName = upperCase(hookFunction.event.topicName.slice(2));
+              } else {
+                queueName = hookFunction.event.topicName;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    templatePath: templatePath,
+    templateData: {
+      hookFunctionName,
+      handlerType,
+      queueName,
+      additionalResourcePermission,
+      functionName: upperCase(hookFunctionName),
+      functionNameConfig: upperCase(hookFunctionName) + upperCase(shortNameHandler(handlerType)),
+      resourceLocation: SOURCE_PATH.resourceLocationGeneratedCodeHookFunction,
+      filterPattern
+    },
+    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/legacy/hookCode-old/functionYaml/template.ejs

@@ -0,0 +1,43 @@
+<%_ const join = require('path').join; _%>
+<%_ const { HANDLER } = require('@izara_project/izara-core-library-service-schemas/src/Consts'); _%>
+<%- firstLetterUpperCase(functionNameConfig) %>:
+  handler: <%- join(resourceLocation, `${functionName}_${firstLetterUpperCase(handlerType)}.main`)%>
+  name: ${self:custom.iz_resourcePrefix}<%- functionName %><%- firstLetterUpperCase(handlerType) %>
+  <%_ if (handlerType ===  firstLetterUpperCase(HANDLER.hdrDsq) || handlerType === firstLetterUpperCase(HANDLER.hdrSqs)) { _%>
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %><%- firstLetterUpperCase(handlerType) %>
+        batchSize: 10
+        <%_ if (filterPattern) { _%>
+        filterPatterns: #**** need to update serverless framwork upper v.2.69.1
+        - body: {"MessageAttributes":{"callingFlow":{"Value":["${self:custom.iz_resourcePrefix}<%- filterPattern %>"]}}} # functionName of callingFlow
+        - body: {"MessageAttributes":{"callingFlow":{"Value":[{"exists":false}]}}}
+  <%_ } _%>
+  <%_ } else if (handlerType === firstLetterUpperCase(HANDLER.hdrApi)) { _%>
+  events:
+    - http:
+        path: <%- objectType %>/<%- firstLetterUpperCase(action) %>
+        method: <%- event %>
+        cors: true
+        #<#<%- firstLetterUpperCase(functionName) %><%- firstLetterUpperCase(handlerType) %>Authorizer#>
+        #<#/<%- firstLetterUpperCase(functionName) %><%- firstLetterUpperCase(handlerType) %>Authorizer#>
+  <%_ } _%>
+  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)
+} _%>

package/src/reStructure/TemplateData/flowSchema/legacy/hookCode-old/handler/data.js

@@ -0,0 +1,93 @@
+/*
+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 } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+const { createHookFunction } = require('../../../../../../SourceManager/src/Utils')
+const { FLOW_SCHEMA_HOOK_STATE } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+const { firstLetterUpperCase: upperCase } = require('../../../../../../MainLibs/src/Utils')
+const { SOURCE_PATH, defaultIamRolePerAction, createIamRole, RESOURCE_CLASSES, SNS_RESOURCE, resourceNames, DYNAMO_RESOURCE, SAVE_FILE_NAME, FUNCTION_NAME, shortNameHandler, SQS_RESOURCE } = require("../../../../libs/Consts");
+const asyncTemplatePath = path.join(__dirname, "templateAsyncHandler.ejs")
+const syncTemplatePath = path.join(__dirname, "templateSyncHandler.ejs")
+/**
+ * receive objectSchema
+ * create data for WebScoket handler template
+ *
+ * @param {Object} objectSchema
+ * @return {{templatePath, templateData,setting}}
+ */
+
+function data(_izContext, flowSchema, srcPath) {
+  return [createSourceParams(_izContext, flowSchema, srcPath)]
+}
+
+function createSourceParams(_izContext, flowSchema, srcPath) {
+  let hook;
+  let hookFunctionName
+  let handlerType;
+  let queueName;
+  if (flowSchema?.hook) {
+    for (const [hookName, hookProperties] of Object.entries(flowSchema.hook)) {
+      for (const hookFunction of hookProperties.functionList) {
+        if (hookName === FLOW_SCHEMA_HOOK_STATE.beforeCreate) {
+          if (hookFunction.event.continueFlow === true && hookFunction.event.initialEvent === false) {
+            hook = true
+            hookFunctionName = upperCase(hookFunction.name)
+            handlerType = upperCase(hookFunction.event.handlerType);
+            if (upperCase(handlerType) === upperCase(HANDLER.hdrDsq)) {
+              queueName = hookFunction.event.queueName;
+            } else if (upperCase(handlerType) === upperCase(HANDLER.hdrSqs)) {
+              queueName = hookFunction.event.topicName;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (upperCase(handlerType) === upperCase(HANDLER.hdrSqs) || upperCase(handlerType) === upperCase(HANDLER.hdrDsq)) {
+    return {
+      templatePath: asyncTemplatePath,
+      templateData: {
+        hookFunctionName,
+        queueName
+      },
+      setting: {
+        savePath: path.join(srcPath, SOURCE_PATH.generatedCodeHookFunction),
+        saveFileName: `${upperCase(hookFunctionName)}_${upperCase(handlerType)}`,
+        fileExtension: ".js",
+        isAppend: false
+      }
+    }
+  } else if (upperCase(handlerType) === upperCase(HANDLER.hdrApi) || upperCase(handlerType) === upperCase(HANDLER.hdrInv)) {
+    return {
+      templatePath: syncTemplatePath,
+      templateData: {
+        hookFunctionName,
+      },
+      setting: {
+        savePath: path.join(srcPath, SOURCE_PATH.generatedCodeHookFunction),
+        saveFileName: `${upperCase(hookFunctionName)}_${upperCase(handlerType)}`,
+        fileExtension: ".js",
+        isAppend: false
+      }
+    }
+  }
+}
+
+module.exports = data;

package/src/reStructure/TemplateData/flowSchema/legacy/hookCode-old/handler/templateAsyncHandler.ejs

@@ -0,0 +1,110 @@
+/*
+Copyright (C) 2021 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 AWS = require('aws-sdk');
+// const sqs = new AWS.SQS(firstLetterUpperCase{ apiVersion: '2012-11-05' });
+
+const izara = require("@izara_project/izara-middleware");
+const middleware = izara.middlewareHandler;
+const recordHandlerSharedLib = require("@izara_project/izara-shared").recordHandlerSharedLib;
+const Logger = require('@izara_project/izara-core-library-logger');
+const izaraShared = require('@izara_project/izara-shared');
+const callingFlowSharedLib = izaraShared.callingFlowSharedLib;
+
+const <%- hookFunctionName %> = require('./<%- hookFunctionName %>_Main')
+
+// validate event properties in body.Message of sqs event
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
+
+// set schema for record.body.Message
+let perRecordsValidatorSchema = {
+  type: "object",
+  required: [
+    'returnMessage',
+    'errorsFound',
+    'passStatus'
+  ],
+  properties: {
+    returnMessage: {
+      type: "object"
+    },
+    errorsFound: {
+      type: "array"
+    },
+    passStatus: {
+      type: 'boolean'
+    }
+  }
+};
+
+perRecordsValidatorSchema = callingFlowSharedLib.addOptionalPassBackPropertiesToValidatorSchema(perRecordsValidatorSchema)
+
+module.exports.main = middleware.wrap(async (event, context, callback) => {
+
+  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
+        "<%- queueName %>", // 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)
+      passOnProperties.push(callingFlowSharedLib.addPassBackPropertiesToPassOnProperties(record.body.Message))
+      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
+        <%- hookFunctionName %>, // mainFunction that need to invoke.
+        "<%- 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
+    }))
+
+    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 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, <%- hookFunctionName %>: ', err);
+    throw (err);
+  }
+});

package/src/reStructure/TemplateData/flowSchema/legacy/hookCode-old/handler/templateSyncHandler.ejs

@@ -0,0 +1,49 @@
+/*
+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 CorrelationIds = require('@izara_project/izara-core-library-correlation-ids')
+// const Logger = require('@izara_project/izara-core-library-logger');
+// const IntegrationTestDetail = require('@izara_project/izara-core-library-integration-tests')
+
+const <%- hookFunctionName %> = require('./<%- hookFunctionName %>_Main');
+
+// validate event params in middlewware before into function.
+const validatorSchema = {};
+middleware.setValidatorSchema(validatorSchema);
+
+module.exports.main = middleware.wrap(async (event, context, callback) => {
+  event._izContext.logger.debug('Event:', event);
+  event._izContext.logger.debug('context:', context);
+
+  try {
+
+    // invoke LambdaFunction
+    return await <%- hookFunctionName %>(
+      event._izContext, // correlationId/logger/integrationTestDetail/uniqueRequestId
+      event
+    );
+
+  } catch (err) {
+    event._izContext.logger.error('Error, <%- hookFunctionName %>: ', err);
+    throw (err);
+  }
+});

package/src/reStructure/TemplateData/flowSchema/legacy/hookCode-old/hookLogic/data.js

@@ -0,0 +1,64 @@
+/*
+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 } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+const { createHookFunction } = require('../../../../../../SourceManager/src/Utils')
+const { FLOW_SCHEMA_HOOK_STATE } = require('@izara_project/izara-core-library-service-schemas/src/Consts')
+const { firstLetterUpperCase: upperCase } = require('../../../../../../MainLibs/src/Utils')
+const { SOURCE_PATH, defaultIamRolePerAction, createIamRole, RESOURCE_CLASSES, SNS_RESOURCE, resourceNames, DYNAMO_RESOURCE, SAVE_FILE_NAME, FUNCTION_NAME, shortNameHandler, SQS_RESOURCE } = require("../../../../libs/Consts");
+const asyncTemplatePath = path.join(__dirname, "templateAsyncHandler.ejs")
+const syncTemplatePath = path.join(__dirname, "templateSyncHandler.ejs")
+/**
+ * receive objectSchema
+ * create data for WebScoket handler template
+ *
+ * @param {Object} objectSchema
+ * @return {{templatePath, templateData,setting}}
+ */
+
+async function data(_izContext, flowSchema, srcPath) {
+  return [await createSourceParams(_izContext, flowSchema, srcPath)]
+}
+
+async function createSourceParams(_izContext, flowSchema, srcPath) {
+  if (flowSchema?.hook) {
+    await Promise.all(
+      Object.values(flowSchema.hook).map(hookProperties =>
+        Promise.all(
+          hookProperties.functionList.map(hookFunction =>
+            createHookFunction(
+              _izContext,
+              hookFunction.logicFunction,
+              {
+                fileExtension: ".js",
+                isAppend: false,
+                saveFileName: `${hookFunction.name}`,
+                destinationPath: path.join(srcPath, SOURCE_PATH.logicalFunctionHook),
+              }
+            )
+          )
+        )
+      )
+    );
+  }
+}
+
+
+
+module.exports = data