@izara_project/izara-core-generate-service-code 1.0.51 → 1.0.53

package/src/codeGenerators/app/src/generatedCode/Flow/FlowSchemas/WebSocketGenerator.js

@@ -0,0 +1,124 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function upperCase(str) {
+    if (!str) return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+function shortNameHandler(handlerType) {
+    const map = {
+        'HdrSqs': 'Sqs',
+        'HdrApi': 'Api',
+        'HdrWbs': 'Wbs',
+        'HdrDsq': 'Dsq'
+    };
+    return map[handlerType] || handlerType;
+}
+
+export async function generateWebSocket(allLocalFlowSchemas, appPath, outputBaseDir) {
+    const hasOwnTopic = allLocalFlowSchemas.some(flow => flow.event && flow.event.includes('ownTopic'));
+    if (!hasOwnTopic) {
+        console.log('  [WebSocketGenerator] No flows use ownTopic. Skipping WebSocket generation.');
+        return;
+    }
+
+    console.log('  [WebSocketGenerator] Generated WebSocket files with ProcessWebSocketMain_Main convention.');
+    const templatesDir = path.join(__dirname, 'templates', 'webSocket');
+    const wsDir = path.join(outputBaseDir, 'app', 'src', 'generatedCode', 'SystemFlowSchemas', 'WebSocketMain', 'source');
+    await fs.mkdir(wsDir, { recursive: true });
+
+    const slsYamlDir = path.join(outputBaseDir, 'app', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(slsYamlDir, { recursive: true });
+
+    const resourceYamlDir = path.join(outputBaseDir, 'resource', 'sls_yaml', 'generatedCode', 'source');
+    await fs.mkdir(resourceYamlDir, { recursive: true });
+
+    // Helper to render and write
+    async function renderAndWrite(tplName, outPath, data) {
+        const tpl = await fs.readFile(path.join(templatesDir, tplName), 'utf-8');
+        const content = ejs.render(tpl, data);
+        await fs.writeFile(outPath, content, 'utf-8');
+    }
+
+    async function renderAndAppend(tplName, outPath, data) {
+        const tpl = await fs.readFile(path.join(templatesDir, tplName), 'utf-8');
+        const content = ejs.render(tpl, data);
+        await fs.appendFile(outPath, '\n' + content, 'utf-8');
+    }
+
+    // 1. DynamoDB Tables
+    const webSocketTaskTable = {
+        tableName: 'WebSocketTask',
+        resourceName: 'WebSocketTask',
+        ttl: true,
+        ttlAttributeName: 'expirationTime',
+        attributes: [
+            { keyType: 'partitionKey', AttributeName: 'taskKey', AttributeType: 'S' },
+            { keyType: 'sortKey', AttributeName: 'connectionId', AttributeType: 'S' }
+        ]
+    };
+    const userUploadRecordsTable = {
+        tableName: 'UserUploadRecords',
+        resourceName: 'UserUploadRecords',
+        attributes: [
+            { keyType: 'partitionKey', AttributeName: 'connectionId', AttributeType: 'S' }
+        ]
+    };
+
+    await renderAndAppend('WebSocketDynamoDb_Yaml.ejs', path.join(resourceYamlDir, 'generated-dynamoDB-table.yml'), webSocketTaskTable);
+    await renderAndAppend('WebSocketDynamoDb_Yaml.ejs', path.join(resourceYamlDir, 'generated-dynamoDB-table.yml'), userUploadRecordsTable);
+
+    // 2. WebSocketConnect
+    const wsConnectName = 'WebSocketConnect';
+    await renderAndWrite('WebSocketConnect_Main.ejs', path.join(wsDir, `${wsConnectName}.js`), {});
+    
+    await renderAndAppend('WebSocketConnect_Yaml.ejs', path.join(slsYamlDir, 'flow-schema.yml'), {
+        functionName: wsConnectName,
+        handlerFilePath: `src/generatedCode/SystemFlowSchemas/WebSocketMain/source/${wsConnectName}`,
+        roleName: 'WebSocketMain',
+        upperFunctionName: upperCase(wsConnectName)
+    });
+
+    // 3. ProcessWebSocketMain
+    const processFunctionName = 'ProcessWebSocketMain';
+    const processHandlerType = 'HdrSqs';
+    const queueName = processFunctionName + shortNameHandler(processHandlerType);
+    
+    const processData = {
+        functionName: processFunctionName,
+        handlerType: processHandlerType,
+        queueName: queueName,
+        handlerFilePath: `src/generatedCode/SystemFlowSchemas/WebSocketMain/source/${upperCase(processFunctionName)}_${upperCase(processHandlerType)}`,
+        roleName: 'WebSocketMain',
+        upperFunctionName: upperCase(processFunctionName),
+        upperHandlerType: upperCase(processHandlerType),
+        upperQueueName: upperCase(queueName),
+        functionNameConfig: upperCase(processFunctionName) + upperCase(shortNameHandler(processHandlerType))
+    };
+
+    await renderAndWrite('ProcessWebSocket_Main.ejs', path.join(wsDir, `${processFunctionName}_Main.js`), processData);
+    await renderAndWrite('ProcessWebSocket_HdrSqs.ejs', path.join(wsDir, `${processFunctionName}_${processHandlerType}.js`), processData);
+    await renderAndAppend('ProcessWebSocketFlow_Yaml.ejs', path.join(slsYamlDir, 'flow-schema.yml'), processData);
+    
+    // 4. SQS and SNS Subscriptions
+    await renderAndAppend('ProcessWebSocket_Yaml.ejs', path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'), processData);
+
+    for (const flowSchema of allLocalFlowSchemas) {
+        if (flowSchema.outputTopic) {
+            const topicOut = upperCase(flowSchema.flowTag);
+            await renderAndAppend('ProcessWebSocketSub_Yaml.ejs', path.join(resourceYamlDir, 'generated-sns-in-sqs.yml'), {
+                subscribeTo: topicOut,
+                queueName: queueName,
+                upperQueueName: upperCase(queueName)
+            });
+        }
+    }
+
+    console.log(`  [WebSocketGenerator] Generated WebSocket files with ProcessWebSocketMain_Main convention.`);
+}

package/src/{generators/fromFlowSchema/events/s3/upload/preSignUrl/createPreSignUrl/mainFunction/template.ejs → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3/CreatePreSignUrl_Main.ejs}

@@ -52,7 +52,7 @@ const { createFlowTypeConcat } = utils
  * @returns {object} returnResponse
  */
 
-export default async function createPresignUrl (
+export default async function createPreSignUrl (
   _izContext,
   returnMessage,
   errorsFound,
@@ -64,7 +64,7 @@ export default async function createPresignUrl (
 
   try {
 
-    _izContext.logger.debug('----- createPresignUrl event params -----', {
+    _izContext.logger.debug('----- createPreSignUrl event params -----', {
       returnMessage: returnMessage,
       errorsFound: errorsFound,
       passStatus: passStatus,
@@ -176,7 +176,7 @@ export default async function createPresignUrl (
     _izContext.logger.debug("maximumSize", maximumSize);
 
     // create PresignUrl
-    let createPresignUrlParam = {
+    let createPreSignUrlParam = {
       Bucket: process.env.iz_csvBucketName,
       Key: Key,
       Conditions: [
@@ -189,9 +189,9 @@ export default async function createPresignUrl (
       Fields: {},
       Expires: 86400
     };
-    _izContext.logger.debug('createPresignUrlParam', createPresignUrlParam);
+    _izContext.logger.debug('createPreSignUrlParam', createPreSignUrlParam);
 
-    const uploadUrl = await createPresignedPost(client, createPresignUrlParam);
+    const uploadUrl = await createPresignedPost(client, createPreSignUrlParam);
 
     //(<modifyUploadLinkField>)
     uploadUrl.fields['x-amz-meta-importBatchId'] = importBatchId;
@@ -212,7 +212,7 @@ export default async function createPresignUrl (
           },
           fields: {
             importBatchStatus: "waitingToUpload",
-            expiryTimestamp: (getResult.fields.startTime + (createPresignUrlParam.Expires * 1000))
+            expiryTimestamp: (getResult.fields.startTime + (createPreSignUrlParam.Expires * 1000))
           }
         },
         objectType: objType.objectType
@@ -256,7 +256,7 @@ export default async function createPresignUrl (
     //(</mainFunctionHookCode>)
 
   } catch (err) {
-    _izContext.logger.error('error createPresignUrl: ', err)
+    _izContext.logger.error('error createPreSignUrl: ', err)
     throw (err)
   }
 }

package/src/codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3/FlowHandler_HdrS3.ejs

@@ -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 { middlewareHandler as middleware, response } from "@izara_project/izara-middleware";
+import Logger from '@izara_project/izara-core-library-logger';
+import recordHandlerSharedLib from '@izara_project/izara-core-library-record-handler';
+
+import <%- functionName %> from './<%- mainFileName %>.js';
+
+// S3 event validator (record.body shape differs from SNS/SQS — uses event.Records[0].s3)
+middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchemaS3());
+
+/**
+ * GENERATED HANDLER: S3 Entry Point (Flow: <%- flowTag %>)
+ * Triggered by: S3 ObjectCreated event (s3:ObjectCreated:*)
+ * Wired to bucket: <%- s3Bucket %>
+ */
+export const main = middleware.wrap(async (event, context) => {
+  try {
+    Logger.debug("event is:", event);
+    Logger.debug("event.Records[0] is:", event.Records && event.Records[0]);
+
+    if (!event.Records || !event.Records[0] || !event.Records[0].s3) {
+      throw new Error("Invalid S3 event: missing Records[0].s3");
+    }
+
+    const s3Record = event.Records[0].s3;
+
+    // Pack the S3 trigger payload into requestParams so the main function
+    // can decide what to do (download file, publish to SNS, invoke Lambda, etc.)
+    const requestParams = {
+      bucket: s3Record.bucket,
+      object: s3Record.object,
+    };
+
+    const result = await <%- functionName %>(
+      event._izContext,
+      requestParams,
+      //(<additionalParams>)
+      //(</additionalParams>)
+    );
+
+    if (result instanceof Error) {
+      return response.failure(result);
+    }
+    return response.success(result);
+  } catch (err) {
+    event._izContext?.logger?.error('Error in S3 handler for flow <%- flowTag %>:', err);
+    return response.failure(err);
+  }
+});

package/src/{generators/fromFlowSchema/events/s3/flowSchemaMainFunction/main.js → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy/flowSchemaMainFunction/data.js}

@@ -99,9 +99,7 @@ async function createParamsForCreateSource(_izContext, flowSchema, appPath) {
       tableName,
       flowSchemaComplete,
       triggerType,
-      queueName: `${createFlowTypeConcat(_izContext, { serviceTag: getLocalConfig('iz_serviceTag'), flowTag: upperCase(flowSchema.flowTag) })}_Main`,
-      upperFunctionName: upperCase(functionName),
-      upperTableName: upperCase(tableName)
+      queueName: `${createFlowTypeConcat(_izContext, { serviceTag: (await import('yaml')).default.parse((await import('fs')).default.readFileSync(path.resolve(appPath, '../config/serverless.config.yml'), 'utf8'))?.main_config?.iz_serviceTag, flowTag: upperCase(flowSchema.flowTag) })}_Main`
     },
     setting: {
       savePath:

package/src/{generators/fromFlowSchema/events/s3 → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy}/index.js

@@ -1,36 +1,36 @@
 // Create S3 Component
-import createFunctionYamlCreateObjectWebSocket from './upload/createObject/functionYaml/yaml.js';
-import createHandlerCreateObjectWebSocket from './upload/createObject/handler/handler.js';
-import createMainFunctionCreateObjectWebSocket from './upload/createObject/mainFunction/main.js';
+import createFunctionYamlCreateObjectWebSocket from './upload/createObject/functionYaml/data.js';
+import createHandlerCreateObjectWebSocket from './upload/createObject/handler/data.js';
+import createMainFunctionCreateObjectWebSocket from './upload/createObject/mainFunction/data.js';
 
 // Create PreSigned URL Component
 // reservedLimit
-import createReservedLimitFunctionYaml from './upload/preSignUrl/reservedLimit/functionYaml/yaml.js';
-import createReservedLimitHandler from './upload/preSignUrl/reservedLimit/handler/handler.js';
-import createReservedLimitMainFunction from './upload/preSignUrl/reservedLimit/mainFunction/main.js';
-import createReservedLimitQueueName from './upload/preSignUrl/reservedLimit/sqs/sqs.js';
+import createReservedLimitFunctionYaml from './upload/preSignUrl/reservedLimit/functionYaml/data.js';
+import createReservedLimitHandler from './upload/preSignUrl/reservedLimit/handler/data.js';
+import createReservedLimitMainFunction from './upload/preSignUrl/reservedLimit/mainFunction/data.js';
+import createReservedLimitQueueName from './upload/preSignUrl/reservedLimit/sqs/data.js';
 // createPreSignUrl
-import createPreSignUrlFunctionYaml from './upload/preSignUrl/createPreSignUrl/functionYaml/yaml.js';
-import createPreSignUrlHandler from './upload/preSignUrl/createPreSignUrl/handler/handler.js';
-import createPreSignUrlMainFunction from './upload/preSignUrl/createPreSignUrl/mainFunction/main.js';
-import createPreSignUrlQueueName from './upload/preSignUrl/createPreSignUrl/queue/queue.js';
+import createPreSignUrlFunctionYaml from './upload/preSignUrl/createPreSignUrl/functionYaml/data.js';
+import createPreSignUrlHandler from './upload/preSignUrl/createPreSignUrl/handler/data.js';
+import createPreSignUrlMainFunction from './upload/preSignUrl/createPreSignUrl/mainFunction/data.js';
+import createPreSignUrlQueueName from './upload/preSignUrl/createPreSignUrl/queue/data.js';
 // Process After Upload S3
-import createProcessAfterUploadS3FunctionYmlS3 from './upload/processFile/functionYml/HdrS3/yaml.js';
-import createProcessAfterUploadS3HandlerS3 from './upload/processFile/handler/handlerS3/handlerS3.js';
-import createProcessAfterUploadS3MainFunction from './upload/processFile/mainFunction/main.js';
+import createProcessAfterUploadS3FunctionYmlS3 from './upload/processFile/functionYml/HdrS3/data.js';
+import createProcessAfterUploadS3HandlerS3 from './upload/processFile/handler/handlerS3/data.js';
+import createProcessAfterUploadS3MainFunction from './upload/processFile/mainFunction/data.js';
 // confirm After Upload S3
-import createConfirmAfterUploadS3FunctionYaml from './upload/confirmReserved/functionYaml/yaml.js';
-import createConfirmAfterUploadS3Handler from './upload/confirmReserved/handler/handler.js';
-import createConfirmAfterUploadS3MainFunction from './upload/confirmReserved/mainFunction/main.js';
-import createConfirmAfterUploadS3Queue from './upload/confirmReserved/queue/queue.js';
+import createConfirmAfterUploadS3FunctionYaml from './upload/confirmReserved/functionYaml/data.js';
+import createConfirmAfterUploadS3Handler from './upload/confirmReserved/handler/data.js';
+import createConfirmAfterUploadS3MainFunction from './upload/confirmReserved/mainFunction/data.js';
+import createConfirmAfterUploadS3Queue from './upload/confirmReserved/queue/data.js';
 // Relate Resources
-import createBucketS3 from './upload/relate/S3/s3.js';
+import createBucketS3 from './upload/relate/S3/data.js';
 // Other Resources
 import createReservedDataMainTable from './websocket/dynamoDb/ReservedTableData.js';
-import createSnsTopicForUploadS3 from './upload/relate/sns-out/snsOut.js';
+import createSnsTopicForUploadS3 from './upload/relate/sns-out/data.js';
 
 //
-import createFlowSchemaEndpointMainFunction from './flowSchemaMainFunction/main.js';
+import createFlowSchemaEndpointMainFunction from './flowSchemaMainFunction/data.js';
 
 async function createS3Component(_izContext, flowSchema, appPath) {
   const component = [
@@ -77,5 +77,4 @@ async function createS3Component(_izContext, flowSchema, appPath) {
   return component.flat();
 }
 
-export const eventKey = 's3';
 export default createS3Component;

package/src/{generators/fromFlowSchema/events/s3/upload/confirmReserved/functionYaml/yaml.js → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy/upload/confirmReserved/functionYaml/data.js}

@@ -101,32 +101,21 @@ function createSourceParams(_izContext, flowSchema, appPath) {
     )
   );
 
-  const resourceLocation = path.join(
-    SOURCE_PATH.resourceLocationWebSocket,
-    flowSchema.flowTag,
-    'source/'
-  );
-  const functionNameConfig = functionName + upperCase(handlerType);
-  const upperFunctionNameConfig = upperCase(functionNameConfig);
-  const upperFunctionName = upperCase(functionName);
-  const upperHandlerType = upperCase(handlerType);
-  const handlerPath = path.join(resourceLocation, `${functionName}_${upperHandlerType}.main`);
-  const upperRoleName = upperCase(SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role);
-
   return {
     templatePath: templatePath,
     templateData: {
       functionName,
       handlerType,
-      resourceLocation,
+      functionNameConfig: functionName + upperCase(handlerType),
+      resourceLocation: path.join(
+        SOURCE_PATH.resourceLocationWebSocket,
+        flowSchema.flowTag,
+        'source/'
+      ),
       additionalResourcePermission,
-      functionNameConfig,
-      roleName: SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role,
-      upperFunctionNameConfig,
-      handlerPath,
-      upperHandlerType,
-      upperFunctionName,
-      upperRoleName
+      functionNameConfig:
+        upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+      roleName: SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role
     },
     setting: {
       saveFileName: SAVE_FILE_NAME.flowSchemaYaml,

package/src/codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy/upload/confirmReserved/functionYaml/template.ejs

@@ -0,0 +1,17 @@
+<%_ const join = require('path').join; _%>
+<%- firstLetterUpperCase(functionNameConfig) %>:
+  handler: <%- join(resourceLocation, `${functionName}_${firstLetterUpperCase(handlerType)}.main`)%>
+  name: ${self:custom.iz_resourcePrefix}<%- 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}<%- functionName %><%- firstLetterUpperCase(handlerType) %>
+        batchSize: 10
+        filterPatterns: #**** need to update serverless framework upper v.2.69.1
+        - body: {"MessageAttributes":{"callingFlow":{"Value":["${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(functionName) %><%- firstLetterUpperCase(handlerType) %>"]}}} # functionName of callingFlow
+        - body: {"MessageAttributes":{"callingFlow":{"Value":[{"exists":false}]}}}
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>

package/src/{generators/fromFlowSchema/events/s3/upload/confirmReserved/handler/handler.js → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy/upload/confirmReserved/handler/data.js}

@@ -44,9 +44,7 @@ function createSourceParams(_izContext, flowSchema, appPath) {
     templatePath: templatePath,
     templateData: {
       functionName,
-      handlerType,
-      upperFunctionName: upperCase(functionName),
-      upperHandlerType: upperCase(handlerType)
+      handlerType
     },
     setting: {
       saveFileName: `${functionName}_${handlerType}`,

package/src/{generators/fromFlowSchema/events/s3 → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy}/upload/confirmReserved/handler/template.ejs

@@ -22,7 +22,7 @@ import { recordHandlerSharedLib } from "@izara_project/izara-core-library-record
 import Logger from '@izara_project/izara-core-library-logger';
 import callingFlowSharedLib from "@izara_project/izara-core-library-calling-flow";
 
-import confirmNewReserved from './ConfirmNewReserved_Main.js'
+import <%= functionName %> from './<%= functionName %>_Main.js'
 
 // validate event properties in body.Message of sqs event
 middleware.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
@@ -79,7 +79,7 @@ export const main = middleware.wrap(async (event, context) => {
       // validate message (and MessageAttributes)
       await recordHandlerSharedLib.validateRecord(
         record,                             // one record will send to mainFunction
-        "ConfirmNewReservedHdrSqs",         // queue name that need to retry or send to dlq
+        "<%= functionName %><%= handlerType %>",         // 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
       );
@@ -96,8 +96,8 @@ export const main = middleware.wrap(async (event, context) => {
       // call recordHandlerSharedLib.recordHandler with 3 parameters and return promise(resolve)
       let recordPromise = recordHandlerSharedLib.recordHandler(
         record,                                 // one record will send to mainFunction
-        confirmNewReserved,  // mainFunction that need to invoke.
-        "ConfirmNewReservedHdrSqs",             // queue name that need to retry or send to dlq
+        <%= functionName %>,  // mainFunction that need to invoke.
+        "<%= functionName %><%= handlerType %>",             // queue name that need to retry or send to dlq
         passOnProperties,                       // all parameters that mainFunction needed.
       );
       record._izContext.logger.debug('after recordPromise in handler');
@@ -117,7 +117,7 @@ export const main = middleware.wrap(async (event, context) => {
     Logger.debug('after Promise.all(recordPromises) in handler');
 
   } catch (err) {
-    Logger.error('Unhandled Error, ConfirmNewReservedHdrSqs: ', err);
+    Logger.error('Unhandled Error, <%= functionName %><%= handlerType %>: ', err);
     throw (err);
   }
 });

package/src/codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy/upload/confirmReserved/mainFunction/template.ejs

@@ -0,0 +1,129 @@
+/*
+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 dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import { sns } from '@izara_project/izara-core-library-external-request';
+import { consts as generateCodeConsts } from '@izara_project/izara-core-generate-service-code';
+import { getNestObject } from '../../../../libs/source/GenerateCodeLibs.js';
+
+//(<optionalRequired>)
+//(</optionalRequired>)
+/**
+ * description of function.
+ * @param {Object} _izContext
+ * @param {CorrelationIds} _izContext.correlationIds - property of _izContext
+ * @param {Logger} _izContext.logger - property of _izContext
+ * @param {Logger} _izContext.logger - property of _izContext
+ * @param {Object} returnMessage - limitValue or limitFound
+ * @param {Array} errorsFound - array
+ * @param {boolean} passStatus - true || false
+ * @param {Object} passBackProperties - identifier
+
+ *
+ * @returns {object} returnResponse
+ */
+
+export default async function <%= functionName %>(
+  _izContext,
+  returnMessage,
+  errorsFound,
+  passStatus,
+  //(<additionalProperties>)
+  //(</additionalProperties>)
+  passBackProperties = {}
+) {
+  try {
+    _izContext.logger.debug('----- <%= functionName %> event params', {
+      _izContext: _izContext,
+      returnMessage: returnMessage,
+      errorsFound: errorsFound,
+      passStatus: passStatus,
+      passBackProperties: passBackProperties
+    })
+
+    let servicePendingId = passBackProperties.passBackProperties.identifier.servicePendingId;
+    let reservedDataId = passBackProperties.passBackProperties.identifier.reservedDataId;
+    let userId = passBackProperties.passBackProperties.identifier.userId;
+    let realFileSize = passBackProperties.passBackProperties.identifier.realFileSize;
+
+    let uniqueIdentify = getNestObject(
+      _izContext,
+      returnMessage.limitFound,
+      ["runningTotal", "uniqueIdentify", "usedTimestampId"]
+    );
+
+    // confirmUsage
+    let confirmUsageMessage = {
+      userId: userId,
+      //(<optionalLimitTag>)
+      limitTag: consts.LIMIT_TAG.uploadData,
+      //(</optionalLimitTag>)
+      uniqueIdentify: uniqueIdentify,
+    }
+
+    let sendMessageToConfirmUsage = {
+      Message: JSON.stringify(confirmUsageMessage),
+      TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, 'ConfirmUsage_In', consts.EXTERNAL_SERVICE_NAME.accountLimits)
+    };
+    _izContext.logger.debug("sendMessageToConfirmUsage", sendMessageToConfirmUsage);
+    await sns.publishAsync(_izContext, sendMessageToConfirmUsage);
+
+    // update reservedDataValue as real size in ReservedDataMain table
+    await dynamodbSharedLib.updateItem(
+      _izContext,
+      await dynamodbSharedLib.tableName(_izContext, 'ReservedDataMain'),
+      {
+        servicePendingId: servicePendingId,
+        reservedDataId: reservedDataId
+      },
+      {
+        reservedValue: realFileSize
+      }
+    )
+
+    let sendMessageToUpdateStatus = {
+      //(<messageObjectHook>)
+      //(</messageObjectHook>)
+      objInstanceFull: {
+        identifiers: {
+          //(<identifiers>)
+          //(</identifiers>)
+        },
+        fields: {
+          //(<fields>)
+          //(</fields>)
+        }
+      }
+    }
+
+    let sendMessageToUpdateEndpoint = {
+      Message: JSON.stringify(sendMessageToUpdateStatus),
+      TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, "Update_In")
+    };
+    _izContext.logger.debug("sendMessageToUpdateEndpoint", sendMessageToUpdateEndpoint);
+    await sns.publishAsync(_izContext, sendMessageToUpdateEndpoint);
+
+    return { returnResponse: 'success' }
+
+  } catch (err) {
+    _izContext.logger.debug('error <%= functionName %>Main: ', err)
+    throw (err)
+  }
+}

package/src/{generators/fromFlowSchema/events/s3 → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy}/upload/confirmReserved/queue/template.ejs

@@ -34,9 +34,12 @@
             Action: "SQS:SendMessage"
       Queues:
         - Ref: <%- queueName %>HdrSqs
-  #<#<%- queueName %>QueueSetting#>
-  #<#/<%- queueName %>QueueSetting#>
+  #<#<%- firstLetterUpperCase(queueName) %>QueueSetting#>
+  #<#/<%- firstLetterUpperCase(queueName) %>QueueSetting#>
 
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
 <%_ function firstLetterLowerCase(str) {
   return str.charAt(0).toLowerCase() + str.slice(1)
 } _%>

package/src/{generators/fromFlowSchema/events/s3/upload/createObject/functionYaml/yaml.js → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy/upload/createObject/functionYaml/data.js}

@@ -89,37 +89,21 @@ function createSourceParams(_izContext, flowSchema, appPath) {
     )
   );
 
-  const resourceLocation = path.join(
-    SOURCE_PATH.resourceLocationWebSocket,
-    flowSchema.flowTag,
-    'source/'
-  );
-
-  const functionNameConfig = upperCase(functionName) + upperCase(shortNameHandler(handlerType));
-  const roleName = SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role;
-  const upperFunctionName = upperCase(functionName);
-  const upperHandlerType = upperCase(handlerType);
-  const upperFunctionNameConfig = upperCase(functionNameConfig);
-  const upperRoleName = upperCase(roleName);
-  const handlerPath = path.join(resourceLocation, `${functionName}_${upperHandlerType}.main`);
-  const handlerPathUpperFunctionName = path.join(resourceLocation, `${upperFunctionName}_${upperHandlerType}.main`);
-
   return {
     templatePath: templatePath,
     templateData: {
-      resourceLocation,
+      resourceLocation: path.join(
+        SOURCE_PATH.resourceLocationWebSocket,
+        flowSchema.flowTag,
+        'source/'
+      ),
       functionName,
       handlerType,
       additionalResourcePermission,
       route,
-      functionNameConfig,
-      roleName,
-      upperFunctionName,
-      upperHandlerType,
-      upperFunctionNameConfig,
-      upperRoleName,
-      handlerPath,
-      handlerPathUpperFunctionName
+      functionNameConfig:
+        upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+      roleName: SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role
     },
     setting: {
       savePath: path.join(appPath, SOURCE_PATH.appYaml),

package/src/{generators/fromFlowSchema/events/s3 → codeGenerators/app/src/generatedCode/Flow/FlowSchemas/templates/s3Legacy}/upload/createObject/functionYaml/template.ejs

@@ -1,6 +1,7 @@
-<%- functionNameConfig %>:
-  handler: <%- handlerPathUpperFunctionName %>
-  name: ${self:custom.iz_resourcePrefix}<%- upperFunctionName %><%- upperHandlerType %>
+<%_ 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#>
@@ -11,6 +12,9 @@
       route: <%- route %>
       # authorizer: ${self:custom.iz_authorizerAppLevel}
     # identifierResource: 'route.request.header.Auth'
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
 <%_ function firstLetterLowerCase(str) {
   return str.charAt(0).toLowerCase() + str.slice(1)
 } _%>