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

package/src/TemplateData/flowSchema/register/wbs/functionYaml/data.js

@@ -0,0 +1,112 @@
+/*
+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';
+import libs from '../../../../../libs/Libs.js';
+
+const {
+  SOURCE_PATH,
+  RESOURCE_CLASSES,
+  DYNAMO_RESOURCE,
+  SAVE_FILE_NAME,
+  FUNCTION_NAME,
+  SOURCE_GENERATE_IAM_ROLE,
+  LAMBDA_RESOURCE
+} = consts;
+
+const { firstLetterUpperCase: upperCase } = utils;
+
+const {
+  shortNameHandler,
+  resourceNames,
+  defaultIamRolePerAction,
+  createIamRole
+} = libs;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * receive objectSchema
+ * create data for WebSocket handler template
+ *
+ * @param {Object} objectSchema
+ * @return {{templatePath, templateData,setting}}
+ */
+async function data(_izContext, allLocalFlowSchemas, srcPath) {
+  const handlerType = upperCase('hdrWbs');
+  const functionName = FUNCTION_NAME.flowSchemaRegister;
+  let functionNameConfig =
+    upperCase(functionName) + upperCase(shortNameHandler(handlerType));
+  let additionalResourcePermission = defaultIamRolePerAction();
+
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.lambda]: [LAMBDA_RESOURCE.invokeFunction]
+      },
+      [resourceNames(RESOURCE_CLASSES.lambda, 'GetHdrInv')]
+    ),
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.dynamoDbTable]: [
+          DYNAMO_RESOURCE.putItem,
+          DYNAMO_RESOURCE.getItem,
+          DYNAMO_RESOURCE.query,
+          DYNAMO_RESOURCE.deleteItem,
+          DYNAMO_RESOURCE.updateItem
+        ]
+      },
+      [resourceNames(RESOURCE_CLASSES.dynamoDbTable, 'WebSocketTask')]
+    ),
+    createIamRole(
+      {
+        'execute-api': ['ManageConnections']
+      },
+      [resourceNames(RESOURCE_CLASSES.webSocket)]
+    )
+  );
+
+  return [
+    {
+      templatePath: templatePath,
+      templateData: {
+        resourceLocation: path.join(
+          SOURCE_PATH.resourceLocationFlowSchemaRegister,
+          'source/'
+        ),
+        additionalResourcePermission,
+        functionName,
+        handlerType,
+        roleName: SOURCE_GENERATE_IAM_ROLE.RegisterRole,
+        functionNameConfig
+      },
+      setting: {
+        savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+        saveFileName: upperCase(SAVE_FILE_NAME.flowSchema),
+        fileExtension: '.yml',
+        isAppend: true
+      }
+    }
+  ];
+}
+
+export default data;

package/src/TemplateData/flowSchema/register/wbs/functionYaml/template.ejs

@@ -0,0 +1,19 @@
+<%_ 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: <%- functionName %>
+          # authorizer: ${self:custom.iz_authorizerAppLevel}
+          # identifierResource: 'route.request.header.Auth'
+  #<#<%- functionName %><%- handlerType %>FunctionSetting#>
+  #<#/<%- functionName %><%- handlerType %>FunctionSetting#>
+  role: <%- roleName %>Role
+
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
+<%_ function firstLetterLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1)
+} _%>

package/src/TemplateData/flowSchema/register/wbs/handler/data.js

@@ -0,0 +1,66 @@
+/*
+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 { SOURCE_PATH, FUNCTION_NAME } = consts;
+
+const { firstLetterUpperCase: upperCase } = utils;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * receive objectSchema
+ * create data for WebSocket handler template
+ *
+ * @param {Object} objectSchema
+ * @return {{templatePath, templateData,setting}}
+ */
+function data(_izContext, flowSchema, srcPath) {
+  return [createParamsForCreateSource(_izContext, flowSchema, srcPath)];
+}
+
+function createParamsForCreateSource(_izContext, srcPath) {
+  // let functionName = upperCase(FUNCTION_NAME.createObjectS3)
+  let functionName = FUNCTION_NAME.flowSchemaRegister;
+  let handlerType = 'HdrWbs';
+  let hook = false;
+  let hookFunctionName;
+  let isAsync = false;
+  return {
+    templatePath: templatePath,
+    templateData: {
+      hook: hook,
+      hookFunctionName: hookFunctionName,
+      isAsync,
+      functionName: functionName,
+      firstLetterUpperCase: upperCase,
+      routeName: FUNCTION_NAME.flowSchemaRegister
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.flowSchemaRegister, 'source/'),
+      saveFileName: `${upperCase(functionName)}_${handlerType}`,
+      fileExtension: '.js',
+      isAppend: false
+    }
+  };
+}
+export default data;

package/src/TemplateData/flowSchema/register/wbs/handler/template.ejs

@@ -0,0 +1,83 @@
+/*
+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/>.
+*/
+
+
+
+import { middlewareHandler as middleware } from "@izara_project/izara-middleware";
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+
+import registerMain from './register_Main.js';
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+// import coreConsts from "@izara_project/izara-core-library-core/src/Consts";
+import { postToConnection } from "../../../libs/source/GenerateCodeLibs.js";
+
+export const main = middleware.wrap(async (event, context) => {
+
+  event._izContext.logger.debug('Event:', event);
+
+  try {
+
+    if (event.requestContext) {
+      const route = event.requestContext.routeKey;
+      const connectionId = event.requestContext.connectionId;
+      let correlationId = event._izContext.correlationIds.get(consts.X_CORRELATION_ID)
+
+      switch (route) {
+        case '$default':
+          console.log('Received unknown route:', route);
+          break
+        case '<%- routeName%>':
+          console.log("event in route <%- routeName%>", event);
+          let eventParams = JSON.parse(event.body)
+
+          await dynamodbSharedLib.putItem(
+            event._izContext,
+            await dynamodbSharedLib.tableName(event._izContext, "WebSocketTask"),
+            {
+              taskKey: correlationId,
+              connectionId: connectionId,
+            }
+          )
+
+          let callingFlow = eventParams?.callingFlow ? eventParams.callingFlow : {};
+
+          await registerMain(
+            event._izContext,
+            eventParams,
+            callingFlowSharedLib.addCallingFlowToPassOnProperties(callingFlow)
+            //(<additionalParams>)
+            //(</additionalParams>)
+          )
+          break
+      }
+    } else {
+      const connId = event.connId;
+      // await postMessage({ message: event.message }, connId);
+      await postToConnection({ message: event.message }, connId);
+    }
+    return izara.response.webSocketSuccess()
+  } catch (err) {
+    const connId = event.requestContext.connectionId
+    event._izContext.logger.error('Error, WebSocket: ', err);
+    await postToConnection({ message: err.message }, connId);
+    return (izara.response.failure(err));
+  }
+});
+<%_ const join = require('path').join _%>
+<%_ function upperCase (text) {
+  return text.charAt(0).toUpperCase() + text.slice(1)
+  } _%>

package/src/TemplateData/flowSchema/register/wbs/mainFunction/data.js

@@ -0,0 +1,57 @@
+/*
+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 { SOURCE_PATH, FUNCTION_NAME } = consts;
+
+const { firstLetterUpperCase: upperCase } = utils;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * receive objectSchema
+ * create data for WebSocket Main template
+ *
+ * @param {Object} objectSchema
+ * @return {{templatePath, templateData,setting}}
+ */
+
+function data(_izContext, flowSchema, srcPath) {
+  return [createParamsForCreateSource(_izContext, flowSchema, srcPath)];
+}
+
+function createParamsForCreateSource(_izContext, srcPath) {
+  const functionName = upperCase(FUNCTION_NAME.flowSchemaRegister);
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionMain: FUNCTION_NAME.flowSchemaRegister + 'Main'
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.flowSchemaRegister, 'source/'),
+      saveFileName: `${functionName}_Main`,
+      fileExtension: '.js',
+      isAppend: false
+    }
+  };
+}
+export default data;

package/src/TemplateData/flowSchema/register/wbs/mainFunction/template.ejs

@@ -0,0 +1,165 @@
+/*
+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 { objectHash as hash } from '@izara_project/izara-shared-core';
+import { getObjectSchema, identifiersObject } from '@izara_project/izara-core-library-service-schemas';
+import lodash from 'lodash'
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+
+import { NoRetryError } from '@izara_project/izara-core-library-core';
+import { consts } from '@izara_project/izara-middleware';
+import { postToConnection } from '../../../libs/source/GenerateCodeLibs'
+
+/**
+ *
+ *
+ * description of function.
+ * @param {Object} _izContext
+ * @param {CorrelationIds} _izContext.correlationIds - property of _izContext
+ * @param {Logger} _izContext.logger - property of _izContext
+ * @param {Object} requestParams - request params
+ * @param {Object} requestParams.identifiers - identifiers for get data
+ * @param {Object} requestParams.additionalRequest - additionalRequest
+ *
+ *
+ * @returns {object} description of return value
+ */
+
+export default async function registerMain(
+  _izContext,
+  requestParams,
+  callingFlowConfig = {},
+  //(<additionalParams>)
+  //(</additionalParams>)
+) {
+  try {
+    let connectionId = _izContext.correlationIds.get(consts.CONNECTION_ID)
+    // receive flowTag and identifiers
+    let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, {
+      flowTag: requestParams.flowTag,
+      serviceTag: process.env.iz_serviceTag,
+    })
+
+    _izContext.logger.debug("flowSchema", flowSchema)
+    if (!flowSchema) {
+      throw new NoRetryError(`flowTag not found ${requestParams.flowTag}`)
+    }
+
+    const getResult = async (objType) => {
+      const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
+        _izContext,
+        {
+          objectType: objType.objectType,
+          serviceTag: objType.serviceTag,
+        })
+
+      _izContext.logger.debug("==> objectSchema", objectSchema)
+
+      const result = await externalRequest.lambda.invokeSync(_izContext,
+        await lambdaSharedLib.lambdaFunctionName(_izContext, "GetHdrInv"),
+        {
+          identifiers: await identifiersObject.identifiersFromIdentifiersConcat(_izContext, objType, requestParams.identifiersTask),
+          objectType: objType.objectType
+        }
+      )
+
+      if (!result) {
+        await postToConnection({ message: "not have record" }, connectionId)
+      } else {
+        for (const [fieldName, fieldNameSetting] of Object.entries(objectSchema.fieldNames)) {
+          if (fieldNameSetting.hasOwnProperty("statusField") && fieldNameSetting.statusField === true) {
+            if (result.fields[fieldName] !== "complete" && result.fields[fieldName] !== "error") {
+              // if status is not complete or error will save data into table
+              await dynamodbSharedLib.putItem(_izContext,
+                await dynamodbSharedLib.tableName(_izContext, "RegisterRecords"),
+                {
+                  identifiersTask: requestParams.identifiersTask,
+                  connectionId: connectionId
+                }
+              )
+            } else {
+              await postToConnection({ message: result }, connectionId)
+            }
+          }
+        }
+      }
+    }
+    // Initialize storedCacheData variable that will be used in multiple switch cases
+    switch (flowSchema.statusType) {
+      case "statusField":
+        await getResult(flowSchema.objType)
+        break;
+      case "storedCache":
+        await getResult(flowSchema.objType)
+        break;
+      case "triggerCache":
+        await getResult(flowSchema.objType)
+        break;
+      case "none":
+        let identifier = {};
+        if (requestParams.hasOwnProperty("identifiersField") && Array.isArray(requestParams.identifiersField)) {
+          for (const fieldNames of requestParams.identifiersField) {
+            Object.assign(identifier, {
+              [fieldNames]: requestParams[fieldNames]
+            })
+          }
+          identifier = identifier;
+        } else {
+          let pureRequestParams = lodash.cloneDeep(requestParams);
+          delete pureRequestParams.flowTag
+          identifier = pureRequestParams
+        }
+
+        // get task before putItem
+        let tasks = await dynamodbSharedLib.query(_izContext,
+          await dynamodbSharedLib.tableName(_izContext, "RegisterRecords"),
+          {
+            identifiersTask: hash(identifier)
+          }
+        )
+        if (tasks.Items && tasks.Items.length > 0) {
+          await Promise.all(tasks.Items.map(async (task) => {
+            await postToConnection({ message: task }, task.connectionId)
+          }))
+          await postToConnection({ message: tasks.Items[0] }, connectionId)
+          return tasks.Items[0]
+        } else {
+          await dynamodbSharedLib.putItem(_izContext,
+            await dynamodbSharedLib.tableName(_izContext, "RegisterRecords"),
+            {
+              identifiersTask: hash(identifier),
+              connectionId: connectionId
+            }
+          )
+        }
+
+
+        break;
+      default:
+        throw new NoRetryError(`statusType not found ${flowSchema.statusType}`)
+    }
+
+    // post result to connectionId
+  } catch (err) {
+    _izContext.logger.error('error WebSocketInvoke: ', err)
+    throw (err)
+  }
+}

package/src/TemplateData/flowSchema/statusFieldComponent/FunctionYaml/data.js

@@ -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/>.
+*/
+
+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 } from '@izara_project/izara-core-library-service-schemas';
+
+import consts from '../../../../libs/Consts.js';
+import utils from '../../../../libs/Utils.js';
+import libs from '../../../../libs/Libs.js';
+
+const {
+  SOURCE_PATH,
+  SAVE_FILE_NAME,
+  HANDLER,
+  RESOURCE_CLASSES,
+  SQS_RESOURCE,
+  DYNAMO_RESOURCE,
+  STORAGE_TYPES
+} = consts;
+
+const {
+  firstLetterLowerCase: lowerCase,
+  firstLetterUpperCase: upperCase,
+  getLocalConfig
+} = utils;
+
+const {
+  shortNameHandler,
+  awaitingMultipleStepsRole,
+  resourceNames,
+  defaultIamRolePerAction,
+  createIamRole,
+} = libs;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * receive objectSchema
+ *
+ * @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) {
+  let functionName = 'CompleteStatusField' + upperCase(flowSchema.flowTag);
+  let handlerType = upperCase(HANDLER.hdrSqs);
+  let additionalResourcePermission = defaultIamRolePerAction();
+  let queueName =
+    'CompleteStatusField' + upperCase(flowSchema.flowTag) + handlerType;
+  let serviceTag = getLocalConfig(path.join(srcPath, '../'), 'iz_serviceTag');
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sqs]: Object.values(SQS_RESOURCE)
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.sqs, queueName),
+        resourceNames(RESOURCE_CLASSES.sqs, queueName + 'DLQ')
+      ]
+    )
+  );
+
+  let tableNames = [];
+  let objectSchema = undefined;
+  if (flowSchema.objType.service === serviceTag) {
+    // console.log("find objSchema in Local")
+    objectSchema = await getObjectSchema
+      .getLocalObjectSchemasWithHierarchy(
+        _izContext,
+        [flowSchema.objType.objectType],
+        path.join(srcPath, './schemas')
+      )
+      .then(res => res.records[0]);
+  } else {
+    // console.log("find objSchema on S3")
+    objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
+      _izContext,
+      flowSchema.objType
+    );
+  }
+  if (!objectSchema) {
+    throw new NoRetryError('ObjectSchema not found');
+  }
+  for (const storageResource of Object.values(objectSchema.storageResources)) {
+    if (storageResource.storageType === STORAGE_TYPES.dynamoDB) {
+      if (!tableNames.includes(storageResource.tableName)) {
+        tableNames.push(storageResource.tableName);
+      }
+    }
+  }
+
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.dynamoDbTable]: Object.values(DYNAMO_RESOURCE)
+      },
+      tableNames.map(tableName =>
+        resourceNames(RESOURCE_CLASSES.dynamoDbTable, tableName)
+      )
+    )
+  );
+
+  additionalResourcePermission.push(awaitingMultipleStepsRole());
+  return {
+    templatePath: templatePath,
+    templateData: {
+      resourceLocation: path.join(
+        SOURCE_PATH.resourceLocationFlowSchema,
+        upperCase(flowSchema.flowTag),
+        'source/'
+      ),
+      functionName,
+      handlerType,
+      additionalResourcePermission,
+      functionNameConfig:
+        upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+      roleName: upperCase(flowSchema.flowTag),
+      queueName
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+      saveFileName: upperCase(SAVE_FILE_NAME.flowSchema),
+      fileExtension: '.yml',
+      isAppend: true
+    }
+  };
+}
+
+export default data;

package/src/TemplateData/flowSchema/statusFieldComponent/FunctionYaml/template.ejs

@@ -0,0 +1,22 @@
+<%_ const join = require('path').join; _%>
+<%- firstLetterUpperCase(functionNameConfig) %>:
+  handler: <%- join(resourceLocation, `${firstLetterUpperCase(functionName)}_${firstLetterUpperCase(handlerType)}.main`)%>
+  name: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(functionName) %><%- firstLetterUpperCase(handlerType) %>
+  role: <%- roleName %>Role
+  #<#<%- functionName %><%- handlerType %>FunctionSetting#>
+  #<#/<%- functionName %><%- handlerType %>FunctionSetting#>
+  events:
+    - sqs:
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>
+        batchSize: 10
+        filterPatterns: #**** need to update serverless framework upper v.2.69.1
+          - body: {"MessageAttributes":{"callingFlow":{"Value":["${self:custom.iz_resourcePrefix}<%- functionName %>"]}}} # functionName of callingFlow
+          - body: {"MessageAttributes":{"callingFlow":{"Value":[{"exists":false}]}}}
+
+
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
+<%_ function firstLetterLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1)
+} _%>