@izara_project/izara-market-library-service-schemas 1.0.54 → 1.0.56

package/src/reStructure/TemplateData/flowSchema/components/upload/processFile/mainFunction/template.ejs

@@ -32,11 +32,11 @@ const { S3Client, GetObjectCommand, DeleteObjectCommand, PutObjectCommand, CopyO
 const s3 = new S3Client({ region: 'us-east-2' });
 
 const hash = require('@izara_project/izara-shared-core').objectHash;
-const Readable = require('stream');
-const { isValidCsv, getNestObject } = require('../../../../libs/source/GenerateCodeLibs');
 const consts = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/Consts')
 const coreConsts = require('@izara_project/izara-core-library-core/src/Consts');
 
+//(<optionalRequired>)
+//(</optionalRequired>)
 
 /**
  * description of function.
@@ -58,331 +58,23 @@ module.exports.processAfterUpload = async (
   _izContext,
   bucket,
   field,
-  importBy = '',
-  importBatchId = '',
-  realImageSize = 0,
+  //(<additionalProperties>)
+  //(</additionalProperties>)
   passBackProperties = {}
 ) => {
 
   try {
 
-    _izContext.logger.debug('----- processImageFile event params ----- ', {
+    _izContext.logger.debug('----- process AfterUpload event params ----- ', {
       bucket: bucket,
       field: field,
-      importBy: importBy,
-      importBatchId: importBatchId,
-      realImageSize: realImageSize,
+      //(<loggerAdditionalParams>)
+      //(</loggerAdditionalParams>)
       passBackProperties: passBackProperties
     })
 
-    let errorsFound = [];
-
-    const objectS3Param = {
-      Bucket: bucket.name,
-      Key: field.key
-    }
-    _izContext.logger.debug("params before getObjectParam::", objectS3Param)
-
-    const fileObjectS3 = await s3.send(new GetObjectCommand(objectS3Param));
-    _izContext.logger.debug("get fileObjectS3", fileObjectS3);
-
-    importBatchId = fileObjectS3.Metadata.importbatchid
-
-    let getImportBatchMain = await lambda.invokeSync(_izContext,
-      await lambdaSharedLib.lambdaFunctionName(_izContext, "ImportBatchMainGetHdrInv"),
-      {
-        identifiers: {
-          importBatchId: importBatchId
-        }
-      }
-    )
-
-    _izContext.logger.debug("getImportBatchMain", getImportBatchMain)
-    _izContext.correlationIds.set(coreConsts.BASE_USER_ID, getImportBatchMain.fields.userId);
-    _izContext.correlationIds.set(coreConsts.TARGET_ID, getImportBatchMain.fields.submittedByUserId);
-
-    let userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID);
-    let targetId = _izContext.correlationIds.get(coreConsts.TARGET_ID);
-
-    if (Date.now() > getImportBatchMain.fields.expiryTimestamp) {
-      errorsFound.push("url expired can't upload")
-      let sendMessageUpdateUrlExpired = {
-        objInstanceFull: {
-          identifiers: {
-            importBatchId: importBatchId
-          },
-          fields: {
-            importBatchStatus: "urlExpired",
-            errorsFound: "url expired can't upload",
-            processingError: true
-          }
-        }
-      }
-
-      let sendMessageToInImportBatchUpdate = {
-        Message: JSON.stringify(sendMessageUpdateUrlExpired),
-        TopicArn: await snsSharedLib.snsTopicArn(_izContext, "InImportBatchMainUpdate")
-      };
-
-      _izContext.logger.debug("message param before send to updateImportBatchMain", sendMessageToInImportBatchUpdate);
-      await sns.publishAsync(_izContext, sendMessageToInImportBatchUpdate);
-
-      let deleteFileObjectS3 = await s3.send(new DeleteObjectCommand(objectS3Param));
-      _izContext.logger.debug("Delete object response: ", deleteFileObjectS3)
-
-      return
-    }
-
-    if (fileObjectS3) {
-      if (!importBatchId) {
-        errorsFound.push("cant't get importBatchId from S3 uploaded file");
-      }
-    } else {
-      errorsFound.push("cant't get fileObjectS3 from S3 uploaded file");
-    };
-
-    let fileS3Body = fileObjectS3.Body;
-    _izContext.logger.debug("fileS3Body", fileS3Body);
-
-    let fileS3Buffer = null;
-
-    if (fileS3Body instanceof Readable) {
-      fileS3Buffer = Buffer.concat(await fileS3Body.toArray());
-      _izContext.logger.debug("fileS3Buffer", fileS3Buffer)
-    } else {
-      errorsFound.push('unknown object stream type');
-    }
-
-    // check file type
-    // can be strict in function.yml that only trigger if it specific type of file
-    const srcKey = field.key;
-    const importFieldType = srcKey.match(/\.([^.]*)$/);
-    _izContext.logger.debug("importFieldType", importFieldType);
-    if (!importFieldType) {
-      throw new NoRetryError("error fileType")
-    };
-
-    const importKeyType = utils.firstLetterLowerCase(importFieldType[1]);
-    _izContext.logger.debug("importKeyType", importKeyType);
-
-    if (importKeyType === "csv") {
-      // check valid CSV file
-      let [validCsv, errorCheckCsv] = await isValidCsv(_izContext, fileObjectS3)
-      _izContext.logger.debug("validCsv check::", { validCsv, errorsFound })
-      if (errorCheckCsv.length) {
-        errorsFound.push(errorCheckCsv[0])
-      }
-
-      // check file size
-      let reservedFileSize = getImportBatchMain.fields.fileSize;
-      _izContext.logger.debug("initialFileSize::", reservedFileSize)
-      let s3FileSize = fileObjectS3.ContentLength / 1048576 // convert back to byte unit
-      _izContext.logger.debug("s3FileSize in MiB::", s3FileSize)
-
-      if (s3FileSize < 0.5) { // round up to 1
-        s3FileSize = 1
-      }
-
-      let reservedData = await dynamodbSharedLib.getItem(_izContext,
-        await dynamodbSharedLib.tableName(_izContext, "ReservedDataMain"),
-        {
-          servicePendingId: importBatchId,
-          reservedDataId: `${consts.ACCOUNTLIMIT_TAG.reservedDynamic}_${getImportBatchMain.fields.userId}_${consts.LIMIT_TAG.uploadData}`
-        }
-      )
-      _izContext.logger.debug("reservedData::", reservedData);
-
-      let sizeDiff;
-
-      if (s3FileSize > reservedFileSize) {
-        sizeDiff = s3FileSize - reservedFileSize;
-
-
-        if (sizeDiff < 1) {
-
-          // send message to confirmUsage
-          let confirmUsageMessage = {
-            userId: userId,
-            limitTag: consts.LIMIT_TAG.uploadData,
-            uniqueIdentify: reservedData.uniqueIdentify,
-          }
-
-          let sendMessageToConfirmUsage = {
-            Message: JSON.stringify(confirmUsageMessage),
-            TopicArn: await snsSharedLib.snsTopicArn(_izContext, 'InConfirmUsage', consts.EXTERNAL_SERVICE_NAME.accountLimits)
-          };
-          _izContext.logger.debug("sendMessageToConfirmUsage", sendMessageToConfirmUsage);
-          await sns.publishAsync(_izContext, sendMessageToConfirmUsage);
-
-          let sendMessageToUpdateImportBatchStatus = {
-            objInstanceFull: {
-              identifiers: {
-                importBatchId: servicePendingId
-              },
-              fields: {
-                importBatchStatus: 'uploadComplete'
-              }
-            }
-          }
-
-          let sendMessageToUpdateImportBatch = {
-            Message: JSON.stringify(sendMessageToUpdateImportBatchStatus),
-            TopicArn: await snsSharedLib.snsTopicArn(_izContext, `InImportBatchMainUpdate`)
-          };
-          _izContext.logger.debug("sendMessageToUpdateImportBatch", sendMessageToUpdateImportBatch);
-          await sns.publishAsync(_izContext, sendMessageToUpdateImportBatch);
-
-        }
-      } else if (s3FileSize < reservedFileSize) {
-        sizeDiff = reservedFileSize - s3FileSize;
-
-        if (sizeDiff < 1) {
-          let confirmUsageMessage = {
-            userId: userId,
-            limitTag: consts.LIMIT_TAG.uploadData,
-            uniqueIdentify: reservedData.uniqueIdentify,
-          }
-
-          let sendMessageToConfirmUsage = {
-            Message: JSON.stringify(confirmUsageMessage),
-            TopicArn: await snsSharedLib.snsTopicArn(_izContext, 'InConfirmUsage', consts.EXTERNAL_SERVICE_NAME.accountLimits)
-          };
-          _izContext.logger.debug("sendMessageToConfirmUsage", sendMessageToConfirmUsage);
-          await sns.publishAsync(_izContext, sendMessageToConfirmUsage);
-
-          let sendMessageToUpdateImportBatchStatus = {
-            objInstanceFull: {
-              identifiers: {
-                importBatchId: servicePendingId
-              },
-              fields: {
-                importBatchStatus: 'uploadComplete'
-              }
-            }
-          }
-
-          let sendMessageToUpdateImportBatch = {
-            Message: JSON.stringify(sendMessageToUpdateImportBatchStatus),
-            TopicArn: await snsSharedLib.snsTopicArn(_izContext, `InImportBatchMainUpdate`)
-          };
-          _izContext.logger.debug("sendMessageToUpdateImportBatch", sendMessageToUpdateImportBatch);
-          await sns.publishAsync(_izContext, sendMessageToUpdateImportBatch);
-
-        } else {
-          let realFileSize = Math.round(s3FileSize);
-          // cancel reserved -> new reserved -> confirm
-          // cancel
-          let sendMessageToCancelReserved = {
-            Message: JSON.stringify({
-              userId: userId,
-              limitTag: consts.LIMIT_TAG.uploadData,
-              uniqueIdentify: reservedData.uniqueIdentify
-            }),
-            TopicArn: await snsSharedLib.snsTopicArn(_izContext, 'InCancelUsage', consts.EXTERNAL_SERVICE_NAME.accountLimits)
-          };
-          _izContext.logger.debug("sendMessageToCancelReserved", sendMessageToCancelReserved);
-          await sns.publishAsync(_izContext, sendMessageToCancelReserved);
-
-          // new reserved
-          let originTimestamp = Date.now();
-          let messageObjReserved = {
-            userId: userId,
-            limitTag: consts.LIMIT_TAG.uploadData,
-            value: realFileSize,
-            rbacType: consts.RBAC_TYPE.appLevel,
-            usedTimestamp: originTimestamp,
-            targetUserId: targetId
-          }
-
-          let callingFlowProperties = {
-            identifier: {
-              servicePendingId: importBatchId,
-              reservedDataId: `${consts.ACCOUNTLIMIT_TAG.reservedDynamic}_${getImportBatchMain.fields.userId}_${consts.LIMIT_TAG.uploadData}`,
-              userId: getImportBatchMain.fields.userId,
-              realSize: realFileSize
-            }
-          }
-
-          messageObjReserved = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
-            messageObjReserved,
-            callingFlowSharedLib.createCallingFlowConfig(
-              await lambdaSharedLib.lambdaFunctionName(_izContext, "ConfirmNewReservedHdrSqs"),
-              callingFlowProperties
-            )
-          )
-          _izContext.logger.debug('after add callingFlow: ', messageObjReserved)
-
-          let sendMessageToReservedDynamic = {
-            Message: JSON.stringify(messageObjReserved),
-            TopicArn: await snsSharedLib.snsTopicArn(_izContext, 'InReservedDynamicUsage', consts.EXTERNAL_SERVICE_NAME.accountLimits)
-          };
-
-          _izContext.logger.debug("sendMessageToReservedDynamic", sendMessageToReservedDynamic);
-          await sns.publishAsync(_izContext, sendMessageToReservedDynamic);
-        };
-      } else if (s3FileSize === reservedFileSize) {
-        let confirmUsageMessage = {
-          userId: getImportBatchMain.fields.userId,
-          limitTag: consts.LIMIT_TAG.uploadData,
-          uniqueIdentify: reservedData.uniqueIdentify,
-        }
-
-        let sendMessageToConfirmUsage = {
-          Message: JSON.stringify(confirmUsageMessage),
-          TopicArn: await snsSharedLib.snsTopicArn(_izContext, 'InConfirmUsage', consts.EXTERNAL_SERVICE_NAME.accountLimits)
-        };
-        _izContext.logger.debug("sendMessageToConfirmUsage", sendMessageToConfirmUsage);
-        await sns.publishAsync(_izContext, sendMessageToConfirmUsage);
-
-        let sendMessageToUpdateImportBatchStatus = {
-          objInstanceFull: {
-            identifiers: {
-              importBatchId: servicePendingId
-            },
-            fields: {
-              importBatchStatus: 'uploadComplete'
-            }
-          }
-        }
-
-        let sendMessageToUpdateImportBatch = {
-          Message: JSON.stringify(sendMessageToUpdateImportBatchStatus),
-          TopicArn: await snsSharedLib.snsTopicArn(_izContext, `InImportBatchMainUpdate`)
-        };
-        _izContext.logger.debug("sendMessageToUpdateImportBatch", sendMessageToUpdateImportBatch);
-        await sns.publishAsync(_izContext, sendMessageToUpdateImportBatch);
-
-      }
-
-    } else {
-      errorsFound.push("error importKeyType")
-    }
-
-    if (errorsFound.length) { // if error send message to update error in importBatchMain
-      let updateImportBatchMainError = {
-        objInstanceFull: {
-          identifiers: {
-            importBatchId: importBatchId
-          },
-          fields: {
-            importBatchStatus: "errorToUpload",
-            errorsFound: errorsFound,
-            processingError: true
-          }
-        }
-      }
-
-      let sendMessageToUpdateImportBatchMain = {
-        Message: JSON.stringify(updateImportBatchMainError),
-        TopicArn: await snsSharedLib.snsTopicArn(_izContext, "InImportBatchMainUpdate")
-      };
-      _izContext.logger.debug('sendMessageToUpdateImportBatchMain::', sendMessageToUpdateImportBatchMain);
-      await sns.publishAsync(_izContext, sendMessageToUpdateImportBatchMain);
-
-      let deleteFileObjectS3 = await s3.send(new DeleteObjectCommand(objectS3Param));
-      _izContext.logger.debug("Delete object response: ", deleteFileObjectS3)
-
-    }
+    //(<endpointHook>)
+    //(</endpointHook>)
 
   } catch (err) {
     _izContext.logger.error('error ProcessImageAfterUploadMain: ', err)

package/src/reStructure/TemplateData/flowSchema/components/upload/relate/libs/template.ejs

@@ -19,7 +19,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 const externalRequest = require('@izara_project/izara-core-library-external-request');
 const lambda = externalRequest.lambda;
-
+const lambdaSharedLib = require('@izara_project/izara-core-library-lambda')
 const { ApiGatewayManagementApiClient, PostToConnectionCommand } = require("@aws-sdk/client-apigatewaymanagementapi");
 const hash = require('@izara_project/izara-shared-core').objectHash;
 <% if (uploadS3) { %>
@@ -57,17 +57,17 @@ async function postToConnection(message, connectionId) {
  * @param {string} functionName
  * @param {Object} payload
  */
-async function getDataFromInvokeFunction(_izContext, functionName, payload) {
+async function processStaticLimit(_izContext, functionName, payload) {
   return await lambda.invokeSync(_izContext, functionName, payload)
 }
 
-const getDataFromInvokeFunctionWithCache = inMemoryCacheLib(
-  getDataFromInvokeFunction,
+const processStaticLimitWithCache = inMemoryCacheLib(
+  processStaticLimit,
   {
     max: 100,
     maxAge: 86400000,
     promise: true,
-    profileName: "getDataFromInvokeFunction",
+    profileName: "processStaticLimit",
     normalizer: function (args) {
       return hash(args[1], args[2])
     }

package/src/reStructure/TemplateData/flowSchema/externalTopic/Process/functionYaml/data.js

@@ -57,7 +57,7 @@ async function createSourceParams(_izContext, flowSchema, srcPath) {
   let handlerType = upperCase(HANDLER.hdrSqs)
   let additionalResourcePermission = defaultIamRolePerAction();
   let route = upperCase(flowSchema.flowTag);
-  let queueName = upperCase(flowSchema.flowTag) + handlerType;
+  let queueName = "Process" + upperCase(flowSchema.flowTag) + handlerType;
   let topicIn = route + "_In";
   additionalResourcePermission.push(
     createIamRole(

package/src/reStructure/TemplateData/flowSchema/externalTopic/Process/handler/data.js

@@ -55,7 +55,7 @@ async function data(_izContext, flowSchema, srcPath) {
 async function createSourceParams(_izContext, flowSchema, srcPath) {
   let functionName = "Process" + upperCase(flowSchema.flowTag)
   let handlerType = upperCase(HANDLER.hdrSqs)
-  let queueName = upperCase(flowSchema.flowTag) + handlerType;
+  let queueName = "Process" + upperCase(flowSchema.flowTag) + handlerType;
 
   return {
     templatePath: templatePath,

package/src/reStructure/TemplateData/flowSchema/externalTopic/sns-in-sqs/data.js

@@ -62,18 +62,18 @@ function createDataForDefaultSnsInSqs(_izContext, flowSchema, srcPath) {
   if (flowSteps.includes("In")) {
     generatedSnsTopicInForFlowSchema.push(
       {
-        queueName: upperCase(flowSchema.flowTag),
+        queueName: "Process" + upperCase(flowSchema.flowTag) + upperCase(HANDLER.hdrSqs)
       }
     )
   }
 
-  if (flowSteps.includes("Out") && flowSchema.outputTopic === true) {
-    generatedSnsTopicInForFlowSchema.push(
-      {
-        queueName: upperCase(flowSchema.flowTag) + "Complete" + upperCase(HANDLER.hdrSqs)
-      }
-    )
-  }
+  // if (flowSteps.includes("Out") && flowSchema.outputTopic === true) {
+  //   generatedSnsTopicInForFlowSchema.push(
+  //     {
+  //       queueName: upperCase(flowSchema.flowTag) + "Complete" + upperCase(HANDLER.hdrSqs)
+  //     }
+  //   )
+  // }
 
   for (let defaultSnsInSqsData of generatedSnsTopicInForFlowSchema) {
     resultsForCreateDefaultSnsInSqs.push({

package/src/reStructure/TemplateData/flowSchema/flowSchemaMainFunction/data.js

@@ -70,7 +70,7 @@ async function createParamsForCreateSource(_izContext, flowSchema, srcPath) {
       functionName,
       tableName,
       flowSchemaComplete,
-      triggerType
+      triggerType,
     },
     setting: {
       savePath: path.join(srcPath, SOURCE_PATH.flowSchema, upperCase(flowSchema.flowTag), "source/"),

package/src/reStructure/TemplateData/flowSchema/flowSchemaMainFunction/template.ejs

@@ -36,7 +36,8 @@ const triggeredCacheSharedLib = require('@izara_project/izara-core-library-trigg
 const { createFieldNamesFromRequestParamsByObjectSchema } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/GenerateCodeLibs.js')
 <% } else if (statusType === "storedCache") { -%>
 const storedCacheSharedLib = require('@izara_project/izara-core-library-stored-cache')
-<% } %>
+<% } -%>
+const { createFlowTypeConcat } = require('@izara_project/izara-core-library-service-schemas').utils
 //(<optionalRequire>)
 //(</optionalRequire>)
 /**
@@ -73,13 +74,14 @@ module.exports.<%- functionName %> = async (
     <% if (statusType === "statusField") { %>
       <%- include(statusFieldTemplate) %>
     <% } else if (statusType === "storedCache") { %>
-      <%- include(storedCacheTemplate, {tableName:tableName,flowSchemaComplete:flowSchemaComplete}) %>
+      <%- include(storedCacheTemplate, {tableName:tableName, flowSchemaComplete:flowSchemaComplete,flowTag}) %>
 
     <% } else if (statusType === "triggerCache") { %>
       <%- include(triggerCacheTemplate, {
         tableName: tableName,
         flowSchemaComplete: flowSchemaComplete,
-        triggerType: triggerType
+        triggerType: triggerType,
+        flowTag
         }) %>
     <% } %>
 

package/src/reStructure/TemplateData/flowSchema/flowSchemaOwnTopic/EndpointComponent/functionYaml/data.js

@@ -111,7 +111,7 @@ async function createSourceParams(_izContext, flowSchema, srcPath) {
   return {
     templatePath: templatePath,
     templateData: {
-      resourceLocation: path.join(SOURCE_PATH.resourceLocationFlowSchema, flowSchema.flowTag, "source/"),
+      resourceLocation: path.join(SOURCE_PATH.resourceLocationFlowSchema, upperCase(flowSchema.flowTag), "source/"),
       functionName,
       handlerType,
       additionalResourcePermission,

package/src/reStructure/TemplateData/flowSchema/flowSchemaOwnTopic/FlowSchemaComponent/handler/template.ejs

@@ -39,6 +39,10 @@ module.exports.main = middleware.wrap(async (event, context, callback) => {
       const connectionId = event.requestContext.connectionId;
       let correlationId = event._izContext.correlationIds.get(consts.X_CORRELATION_ID)
 
+      //(<createIdentifiersFlow>)
+      let identifiers
+      //(</createIdentifiersFlow>)
+
       switch (route) {
 
         case '$default':
@@ -47,16 +51,35 @@ module.exports.main = middleware.wrap(async (event, context, callback) => {
         case '<%- route %>':
           console.log("event in route webSocket", event);
           let eventParams = JSON.parse(event.body)
-
-          await dynamodbSharedLib.putItem(
+          let flowSchema = getObjectSchema.getFlowSchemaS3WithCache(
             event._izContext,
-            await dynamodbSharedLib.tableName(event._izContext, "WebSocketTask"),
             {
-              taskKey: correlationId,
-              connectionId: connectionId,
+              flowTag: "<%- route %>",
+              serviceTag: process.env.iz_serviceTag
             }
           )
 
+          if (flowSchema.statusType === "statusField" || flowSchema.statusType === "storedCache" || flowSchema.statusType === "triggerCache") {
+            await dynamodbSharedLib.putItem(event._izContext,
+              await dynamodbSharedLib.tableName(event._izContext, "WebSocketTask"),
+              {
+                taskKey: `${utils.createFlowTypeConcat(event._izContext, { flowTag: "<%- route %>", serviceTag: process.env.iz_serviceTag })}${identifiers}`,
+                connectionId: connectionId,
+              }
+            )
+
+          } else if (flowSchema.statusType === "none") {
+            await dynamodbSharedLib.putItem(
+              event._izContext,
+              await dynamodbSharedLib.tableName(event._izContext, "WebSocketTask"),
+              {
+                taskKey: `${utils.createFlowTypeConcat(event._izContext, { flowTag: "<%- route %>", serviceTag: process.env.iz_serviceTag })}${correlationId}`,
+                connectionId: connectionId,
+              }
+            )
+          }
+
+
           let callingFlow = eventParams?.callingFlow ? eventParams.callingFlow : {};
           await <%- functionName %>.<%- functionName %>(
             event._izContext,

package/src/reStructure/TemplateData/flowSchema/flowSchemaOwnTopic/sns-in/data.js

@@ -72,17 +72,17 @@ function createDataForDefaultSnsInSqs(_izContext, flowSchema, srcPath) {
 
   let defaultDsqQueueDataList = [];
 
-  if (flowSchema.outputTopic) {
-    if (flowSteps.includes("Out")) {
-      if (flowSchema.outputTopic) {
-        defaultDsqQueueDataList.push(
-          {
-            queueName: upperCase(topicIn) + "CompleteHdrSqs"
-          }
-        )
-      }
-    }
-  }
+  // if (flowSchema.outputTopic) {
+  //   if (flowSteps.includes("Out")) {
+  //     if (flowSchema.outputTopic) {
+  //       defaultDsqQueueDataList.push(
+  //         {
+  //           queueName: upperCase(topicIn) + "CompleteHdrSqs"
+  //         }
+  //       )
+  //     }
+  //   }
+  // }
 
 
   for (let defaultSnsInSqsData of generatedSnsTopicInForFlowSchema) {

package/src/reStructure/TemplateData/flowSchema/flowStep/handler/template.ejs

@@ -24,6 +24,7 @@ const izara = require("@izara_project/izara-middleware");
 const middleware = izara.middlewareHandler;
 const recordHandlerSharedLib = require("@izara_project/izara-core-library-record-handler")
 const Logger = require('@izara_project/izara-core-library-logger');
+const callingFlowSharedLib = require('@izara_project/izara-core-library-calling-flow');
 
 const <%- functionName %> = require('./<%- functionName %>_Main')
 

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

@@ -178,8 +178,10 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
     for (const flowSchema of allLocalFlowSchemas.records) {
       // console.log("flowSchema in Generate TemplateData", flowSchema);
       const webSocketGenerateCodeLibs = createWebSocketGenerateCodeLibs(_izContext, flowSchema, saveFilePath)
-      const flowSchemaEndpointMainFunction = await createFlowSchemaEndpointMainFunction(_izContext, flowSchema, saveFilePath);
-      createSourceParams.push(...webSocketGenerateCodeLibs, ...flowSchemaEndpointMainFunction)
+      if (!flowSchema.event.includes("s3")) {
+        const flowSchemaEndpointMainFunction = await createFlowSchemaEndpointMainFunction(_izContext, flowSchema, saveFilePath);
+        createSourceParams.push(...webSocketGenerateCodeLibs, ...flowSchemaEndpointMainFunction)
+      }
 
       // event has [s3, extTopic, ownTopic, eventBridge, lambdaSync]
       for (const event of flowSchema.event) {
@@ -190,22 +192,22 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
           const functionYamlCreateObjectWebSocket = createFunctionYamlCreateObjectWebSocket(_izContext, flowSchema, saveFilePath);
           const handlerCreateObjectWebSocket = createHandlerCreateObjectWebSocket(_izContext, flowSchema, saveFilePath);
           const mainFunctionCreateObjectWebSocket = await createMainFunctionCreateObjectWebSocket(_izContext, flowSchema, saveFilePath);
-          const webSocketCreateObjectCompleteFunctionYaml = createWebSocketCreateObjectCompleteFunctionYaml(_izContext, flowSchema, saveFilePath);
-          const webSocketCreateObjectCompleteQueue = createWebSocketCreateObjectCompleteQueue(_izContext, saveFilePath);
-          const webSocketCreateObjectCompleteMainFunction = createWebSocketCreateObjectCompleteMainFunction(_izContext, flowSchema, saveFilePath)
-          const webSocketCreateObjectCompleteHandler = createWebSocketCreateObjectCompleteHandler(_izContext, flowSchema, saveFilePath);
+          // const webSocketCreateObjectCompleteFunctionYaml = createWebSocketCreateObjectCompleteFunctionYaml(_izContext, flowSchema, saveFilePath);
+          // const webSocketCreateObjectCompleteQueue = createWebSocketCreateObjectCompleteQueue(_izContext, saveFilePath);
+          // const webSocketCreateObjectCompleteMainFunction = createWebSocketCreateObjectCompleteMainFunction(_izContext, flowSchema, saveFilePath)
+          // const webSocketCreateObjectCompleteHandler = createWebSocketCreateObjectCompleteHandler(_izContext, flowSchema, saveFilePath);
 
           // const webSocketCreateObjectStordCache = createWebSocketCreateObjectStoredCache(_izContext, saveFilePath);
 
-          const getPreSignUrlFunctionYaml = createReservedLimitFunctionYaml(_izContext, flowSchema, saveFilePath);
-          const getPreSignUrlHandler = createReservedLimitHandler(_izContext, flowSchema, saveFilePath);
-          const getPreSignUrlMainFunction = createReservedLimitMainFunction(_izContext, flowSchema, saveFilePath);
-          const getPreSignUrlQueue = createReservedLimitQueueName(_izContext, saveFilePath);
+          const reservedLimitFunctionYaml = createReservedLimitFunctionYaml(_izContext, flowSchema, saveFilePath);
+          const reservedLimitHandlerFunction = createReservedLimitHandler(_izContext, flowSchema, saveFilePath);
+          const reservedLimitMainFunction = await createReservedLimitMainFunction(_izContext, flowSchema, saveFilePath);
+          const reservedLimitQueueName = createReservedLimitQueueName(_izContext, saveFilePath);
 
-          const reservedLimitCompleteFunctionYaml = createPresignUrlFunctionYaml(_izContext, flowSchema, saveFilePath);
-          const reservedLimitCompleteMainFunction = createPresignUrlMainFunction(_izContext, flowSchema, saveFilePath);
-          const reservedLimitCompleteHandler = createPresignUrlHandler(_izContext, flowSchema, saveFilePath);
-          const reservedLimitCompleteQueue = createPresignUrlQueueName(_izContext, saveFilePath);
+          const presignUrlFunctionYaml = createPresignUrlFunctionYaml(_izContext, flowSchema, saveFilePath);
+          const presignUrlMainFunction = createPresignUrlMainFunction(_izContext, flowSchema, saveFilePath);
+          const presignUrlHandlerFunction = createPresignUrlHandler(_izContext, flowSchema, saveFilePath);
+          const presignUrlQueueName = createPresignUrlQueueName(_izContext, saveFilePath);
 
           const processAfterUploadFunctionYmlS3 = createProcessAfterUploadS3FunctionYmlS3(_izContext, flowSchema, saveFilePath);
           // const processAfterUploadFunctionYamlHdrDsq = createProcessAfterUploadS3FunctionYmlDsq(_izContext, saveFilePath);
@@ -223,24 +225,24 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
             ...functionYamlCreateObjectWebSocket,
             ...handlerCreateObjectWebSocket,
             ...mainFunctionCreateObjectWebSocket,
-            ...webSocketCreateObjectCompleteFunctionYaml,
-            ...webSocketCreateObjectCompleteQueue,
-            ...webSocketCreateObjectCompleteMainFunction,
-            ...webSocketCreateObjectCompleteHandler
+            // ...webSocketCreateObjectCompleteFunctionYaml,
+            // ...webSocketCreateObjectCompleteQueue,
+            // ...webSocketCreateObjectCompleteMainFunction,
+            // ...webSocketCreateObjectCompleteHandler
           ];
 
           const getPreSignUrlResources = [
-            ...getPreSignUrlFunctionYaml,
-            ...getPreSignUrlHandler,
-            ...getPreSignUrlMainFunction,
-            ...getPreSignUrlQueue
+            ...reservedLimitFunctionYaml,
+            ...reservedLimitHandlerFunction,
+            ...reservedLimitMainFunction,
+            ...reservedLimitQueueName
           ];
 
           const reservedLimitResources = [
-            ...reservedLimitCompleteFunctionYaml,
-            ...reservedLimitCompleteHandler,
-            ...reservedLimitCompleteMainFunction,
-            ...reservedLimitCompleteQueue
+            ...presignUrlFunctionYaml,
+            ...presignUrlHandlerFunction,
+            ...presignUrlMainFunction,
+            ...presignUrlQueueName
           ];
 
           const processAfterUploadResources = [