@izara_project/izara-market-library-service-schemas 1.0.35 → 1.0.36

package/src/reStructure/TemplateData/flowSchema/createRecordByStatusType/wbs/mainFunction/template.ejs

@@ -33,7 +33,7 @@ const sns = externalRequest.sns
 const utils = require('@izara_project/izara-market-library-service-schemas/src/MainLibs/src/Utils')
 const NoRetryError = require('@izara_project/izara-core-library-core').NoRetryError
 const { v4: uuidv4 } = require('uuid')
-const coreConsts = require("@izara_project/izara-core-library-core/src/Consts");
+const consts = require('@izara_project/izara-middleware/src/MiddlewareCore/Consts')
 const { TOPIC_NAME_GENERATE_CODE } = require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/Consts')
 /**
  *
@@ -68,7 +68,7 @@ module.exports.<%- functionMain%> = async (
     // receive flowTag and identifiers
     let flowSchema = await getObjectSchema.getFlowSchemaS3WithCache(_izContext, {
       flowTag: requestParams.flowTag,
-      serviceTag: requestParams.serviceTag,
+      serviceTag: process.env.iz_serviceTag,
     })
 
     _izContext.logger.debug("flowSchema", flowSchema)
@@ -76,13 +76,80 @@ module.exports.<%- functionMain%> = async (
       throw new NoRetryError(`flowTag not found ${requestParams.flowTag}`)
     }
 
+    // get data from dynamoDB of objectType of flowSchema
+    const getStoredCache = async (objectType) => {
+      const objectSchema = await getObjectSchema.getObjSchemaS3WithCache(
+        _izContext,
+        {
+          objectType: objectType,
+          serviceTag: process.env.iz_serviceTag,
+        })
+
+      _izContext.logger.debug("==> objectSchema", objectSchema)
+
+      // this returns the table name of the first storage resource with storageType "dynamoDB"
+      const tableName = Object.values(objectSchema.storageResources).find(
+        (storageResource) => storageResource.storageType === "dynamoDB"
+      )?.tableName
+      _izContext.logger.debug("==> tableName", tableName)
+
+      // const identifierPK = objectSchema[identifierPK].find(
+      //   (identifier) => identifier.type === "partitionKey"
+      // )?.fieldName
+
+      // const identifierSK = objectSchema[identifierSK].find(
+      //   (identifier) => identifier.type === "sortKey"
+      // )?.fieldName
+
+      let identifierPK = null
+      let identifierSK = null
+      objectSchema.identifiers.map((identifier) => {
+        if (identifier.type === "partitionKey") {
+          identifierPK = identifier.fieldName
+        } else if (identifier.type === "sortKey") {
+          identifierSK = identifier.fieldName
+        }
+      })
+
+      _izContext.logger.debug("==> identifierPK", identifierPK)
+      _izContext.logger.debug("==> identifierSK", identifierSK)
+
+      const payloadGetStoredCache = {
+        [identifierPK]: requestParams.identifiers[identifierPK],
+      }
+      if (identifierSK) {
+        payloadGetStoredCache[identifierSK] = requestParams.identifiers[identifierSK]
+      }
+
+      _izContext.logger.debug("==> payloadGetStoredCache", payloadGetStoredCache)
+
+      // const getStoredCache = await dynamodbSharedLib.getItem(
+      //   _izContext,
+      //   await dynamodbSharedLib.tableName(_izContext, tableName),
+      //   payloadGetStoredCache
+      // )
+
+      const getStoredCache = await dynamodbSharedLib.query(
+        _izContext,
+        await dynamodbSharedLib.tableName(_izContext, tableName),
+        payloadGetStoredCache
+      )
+      _izContext.logger.debug("==> getStoredCache:::", getStoredCache)
+      return ({
+        data: getStoredCache.Items[0],
+        identifierPK: identifierPK,
+      })
+    }
+
+    // Initialize storedCacheData variable that will be used in multiple switch cases
+    let storedCacheData = null;
     switch (flowSchema.statusType) {
       case "statusField":
-        let payload = {
+        const payload = {
           identifiers: requestParams.identifiers,
           objectType: flowSchema.objType.objectType
         }
-        let result = await externalRequest.lambda.invokeSync(
+        const result = await externalRequest.lambda.invokeSync(
           _izContext,
           await lambdaSharedLib.lambdaFunctionName(_izContext, "GetHdrInv", flowSchema.objType.serviceTag),
           payload
@@ -91,23 +158,58 @@ module.exports.<%- functionMain%> = async (
           throw new NoRetryError(`statusField not found ${requestParams.identifiers}`)
         }
         return result
-        case "storedCache":
+
+
+      case "storedCache":
         // if statusType=storedCache then query storedCache > post message to client -> remove connectionId if status = error || complete
-        const getStoredCache = await dynamodbSharedLib.getItem(
-          _izContext,
-          await dynamodbSharedLib.tableName(_izContext, flowSchema.flowTag + "Main"),
-          {
-            taskKey: requestParams.identifiers,
-            connectionId: requestParams.connectionId
+
+        storedCacheData = await getStoredCache(flowSchema.objType.objectType)
+        _izContext.logger.debug("==> storedCacheData", storedCacheData)
+
+        if (!storedCacheData) {
+          throw new NoRetryError(`storedCache not found ${requestParams.identifiers} ${requestParams.sortKey}`)
+        }
+        let payloadPostMessage = {
+          identifierTask: requestParams.identifiers[storedCacheData.identifierPK],
+          connectionId: _izContext.correlationIds.get(consts.CONNECTION_ID),
+          flowType: {
+            flowTag: flowSchema.flowTag,
+            serviceTag: process.env.iz_serviceTag,
           }
-        )
-        if (!getStoredCache) {
-          throw new NoRetryError(`storedCache not found ${requestParams.identifiers}`)
         }
-        return getStoredCache
+
+        _izContext.logger.debug('==> payloadPostMessage', payloadPostMessage)
+        if (storedCacheData.data.cacheStatus !== "error" && storedCacheData.data.cacheStatus != "complete") {
+          await dynamodbSharedLib.putItem(
+            _izContext,
+            await dynamodbSharedLib.tableName(_izContext, "FlowTagRegisterRecords"),
+            payloadPostMessage
+          )
+
+          return payloadPostMessage;
+        } else {
+          await dynamodbSharedLib.deleteItem(
+            _izContext,
+            await dynamodbSharedLib.tableName(_izContext, "FlowTagRegisterRecords"),
+            {
+              identifierTask: requestParams.identifiers[storedCacheData.identifierPK],
+              connectionId: _izContext.correlationIds.get(consts.CONNECTION_ID)
+            }
+          )
+        }
+
+        return storedCacheData;
+
       case "none":
         // if statusType=none -> post message to client ---- not remove connectionId when post message, can remove connectionId when cannot use connectionId only(user disconnect)
-        break
+        storedCacheData = await getStoredCache(flowSchema.objType.objectType)
+
+        _izContext.logger.debug("==> objectSchema", storedCacheData)
+        if (!storedCacheData) {
+          throw new NoRetryError(`none not found ${requestParams.identifiers}`)
+        }
+        return storedCacheData
+
       default:
         throw new NoRetryError(`statusType not found ${flowSchema.statusType}`)
     }

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

@@ -19,18 +19,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 const path = require("path")
 
-
-// const {
-//   HANDLER,
-// STORAGE_TYPES
-// } = require('@izara_project/izara-core-library-service-schemas/src/Consts');
-
-const STORAGE_TYPES = {
-  dynamoDB: "dynamoDB",
-  graph: "graph"
-}
 const templatePath = path.join(__dirname, '../../resourceYaml/dynamodb/template.ejs')
-const { SOURCE_PATH, SAVE_FILE_NAME } = require('../../../../MainLibs/src/Consts.js')
+const { SOURCE_PATH, SAVE_FILE_NAME, defaultIamRolePerAction, createIamRole, DYNAMO_RESOURCE, resourceNames, RESOURCE_CLASSES, FUNCTION_NAME, SOURCE_GENERATE_IAM_ROLE } = require('../../../../MainLibs/src/Consts.js')
 
 /**
  * create param of crateSouce for FindData And processLogical
@@ -39,43 +29,92 @@ const { SOURCE_PATH, SAVE_FILE_NAME } = require('../../../../MainLibs/src/Consts
  * @param {String} srcPath
  * @returns {Object[]}
  */
-const createAwaitingMultipleStepDynamoDbData = (_izContext, flowSchema, srcPath) => {
+const createAwaitingMultipleStepDynamoDbData = (_izContext, flowSchema, allLocalObjectSchemas, srcPath) => {
+  if (!flowSchema.event.includes("ownTopic")) {
+    return [];
+  }
 
-  let resultsForCreateSource = [];
-  const defaultDynamoDataLists = [];
+  const objectSchema = allLocalObjectSchemas.records.find(schema =>
+    schema.objectType === flowSchema.objType.objectType);
 
-  if (flowSchema.statusType === "storedCache") {
-    defaultDynamoDataLists.push(
-      {
-        tableName: flowSchema.flowTag + "Main",
-        resourceName: flowSchema.flowTag + "Main",
-        attributes: [
-          {
-            keyType: "partitionKey",
-            AttributeName: flowSchema.flowTag + "Id",
-            AttributeType: "S"
-          }
-        ]
-      }
-    )
+  if (!objectSchema) {
+    return [];
+  }
+
+  if (!objectSchema.storageResources) {
+    return [];
+  }
+
+  // ex.
+  // storageResources: {
+  //   cacheTable: {
+  //     storageType: "dynamoDB",
+  //     tableName: "TranslateIdsCacheMain"
+  //   }
+  // }
+
+  // Check if there's exactly one DynamoDB storage resource
+  const dynamoDbEntries = Object.entries(objectSchema.storageResources)
+    .filter(([_, value]) => value.storageType === "dynamoDB");
+
+  console.debug(`DynamoDB entries: ${JSON.stringify(dynamoDbEntries)}`);
+
+  if (dynamoDbEntries.length !== 1) {
+    console.warn(`Object schema ${objectSchema.objectType} for ${flowSchema.flowTag} needs to have exactly one DynamoDB storage resource.`);
+    return []; // Either no DynamoDB storage or more than one found
   }
 
-  for (let defaultDynamoData of defaultDynamoDataLists) {
-    resultsForCreateSource.push({
-      templatePath: templatePath,
-      templateData: defaultDynamoData,
-      setting: {
-        initialData: 'Resources:\n',
-        savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
-        saveFileName: SAVE_FILE_NAME.dynamoDbYaml,
-        fileExtension: '.yml',
-        isAppend: true
-      }
-    });
+  const storageResourceEntry = dynamoDbEntries[0];
+
+  if (!storageResourceEntry) {
+    return [];
   }
-  // console.log("resultsForCreateSource default dynamo", resultsForCreateSource)
 
-  return resultsForCreateSource;
-}
+  const [_, storageResource] = storageResourceEntry;
+  const tableName = storageResource.tableName;
+
+  const attributes = objectSchema.identifiers
+    .map(identifier => ({
+      keyType: identifier.type,
+      AttributeName: identifier.fieldName,
+      AttributeType: "S"
+    }));
+
+  let additionalResourcePermission = defaultIamRolePerAction();
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.dynamoDbTable]: [
+          DYNAMO_RESOURCE.putItem,
+          DYNAMO_RESOURCE.getItem,
+          DYNAMO_RESOURCE.query,
+          DYNAMO_RESOURCE.deleteItem,
+          DYNAMO_RESOURCE.updateItem
+        ]
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.dynamoDbTable, tableName)
+      ]
+    )
+  );
+
+  return [{
+    templatePath,
+    templateData: {
+      tableName,
+      resourceName: tableName,
+      attributes,
+      additionalResourcePermission,
+      roleName: SOURCE_GENERATE_IAM_ROLE.RegisterRole,
+    },
+    setting: {
+      initialData: 'Resources:\n',
+      savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
+      saveFileName: SAVE_FILE_NAME.dynamoDbYaml,
+      fileExtension: '.yml',
+      isAppend: true
+    }
+  }];
+};
 
-module.exports = createAwaitingMultipleStepDynamoDbData
+module.exports = createAwaitingMultipleStepDynamoDbData;

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

@@ -32,6 +32,7 @@ const {
   FUNCTION_NAME,
   SAVE_FILE_NAME,
   SOURCE_GENERATE_IAM_ROLE,
+  HANDLER,
 } = require("../../../../../MainLibs/src/Consts");
 
 /**
@@ -45,17 +46,15 @@ const {
  */
 
 function data(_izContext, flowSchema, srcPath) {
-  const flowStepSplitKey = Object.keys(flowSchema.flowSteps)[0].split("_");
+  const flowStepSplitKeyOut = Object.keys(flowSchema.flowSteps)[1].split("_");
   // console.log({ flowStepSplitKey })
-  let queueName = flowStepSplitKey[3] + 'Out';
-  let queueNameSubscription = flowStepSplitKey[3];
-
+  let queueName = upperCase(flowSchema.flowTag) + "ExternalTopicOut" + upperCase(HANDLER.hdrSqs)
   return [{
     templatePath,
     templateData: {
       queueName: upperCase(queueName),
-      queueNameSubscription: upperCase(queueNameSubscription),
       roleName: SOURCE_GENERATE_IAM_ROLE.ExternalTopicRole,
+      firstLetterUpperCase: upperCase
     },
     setting: {
       initialData: "Resource\n",

package/src/reStructure/TemplateData/flowSchema/externalTopic/sns-in-sqs/template.ejs

@@ -1,10 +1,4 @@
-##===== SNS Subscription
-  SubscriptionOut<%- queueNameSubscription %>:
-    Type: AWS::SNS::Subscription
-    Properties:
-      TopicArn: !Ref Out<%- queueNameSubscription %>
-      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueNameSubscription %>Out"
-      Protocol: "sqs"
+##===== ExternalTopic
 ##===== [Queue]
   <%- queueName %>:
     Type: "AWS::SQS::Queue"

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

@@ -33,7 +33,7 @@ const {
   SOURCE_GENERATE_IAM_ROLE
 } = require("../../../../../MainLibs/src/Consts");
 
-const templatePath = path.join(__dirname, "../../../../TemplateData/resourceYaml/sns-out/template.ejs");
+const templatePath = path.join(__dirname, "./template.ejs");
 // /ResourceYaml/sns-out/template.ejs
 // /OutPerActionComplete/OutUpdateComplete/sns-out/data.js
 
@@ -52,8 +52,7 @@ function data(_izContext, flowSchema, srcPath) {
 }
 
 function createParamsForCreateSource(_izContext, flowSchema, srcPath) {
-  const flowStepSplitKey = Object.keys(flowSchema.flowSteps)[1].split('_');
-  const queueName = flowStepSplitKey[3]
+  const queueName = upperCase(flowSchema.flowTag)
   return [
     {
       templatePath: templatePath,

package/src/reStructure/TemplateData/flowSchema/externalTopic/sns-out/template.ejs

@@ -3,8 +3,6 @@
     Type: AWS::SNS::Topic
     Properties:
       DisplayName: "SNS Message out"
-      TopicName: ${self:custom.iz_serviceTag}_${self:custom.iz_stage}_<%- firstLetterUpperCase(queueName) %>_Out
+      TopicName: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(queueName) %>
 
-  <%_ function firstLetterUpperCase(text) {
-    return text.charAt(0).toUpperCase() + text.slice(1)
-  } _%>
+      <%_ function firstLetterUpperCase(text) { return text.charAt(0).toUpperCase() + text.slice(1) } _%>

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

@@ -33,7 +33,8 @@ const {
   FUNCTION_NAME,
   shortNameHandler,
   externalResourceYaml,
-  SOURCE_GENERATE_IAM_ROLE
+  SOURCE_GENERATE_IAM_ROLE,
+  SQS_RESOURCE
 } = require("../../../../../../MainLibs/src/Consts");
 
 const templatePath = path.join(__dirname, "template.ejs");
@@ -55,13 +56,40 @@ function createSourceParams(_izContext, flowSchema, srcPath) {
   let externalTopicName = FUNCTION_NAME.flowSchemaExternalTopic + 'Out';
   let functionConfig = "ExtTopicOut" + upperCase(shortNameHandler(handlerType));
   let additionalResourcePermission = defaultIamRolePerAction();
+  let flowStepInSplitKey = Object.keys(flowSchema.flowSteps)[0].split("_");
   // const action = flowSchema.flowTag || 'defaultAction'; // Using flowTag as the action name
   // const event = resourceNames(RESOURCE_CLASSES.sqs, upperCase(action) + upperCase(handler));
-
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sqs]: [
+          SQS_RESOURCE.getQueueAttributes,
+          SQS_RESOURCE.receiveMessage,
+          SQS_RESOURCE.deleteMessage,
+        ]
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.sqs, functionName + handlerType),
+        resourceNames(RESOURCE_CLASSES.sqs, functionName + handlerType + "DLQ"),
+        // resourceNames(RESOURCE_CLASSES.sqs, functionName + "Out"),
+        // resourceNames(RESOURCE_CLASSES.sqs, functionName + "OutDLQ"),
+      ]
+    ),
+    // createIamRole(
+    //   {
+    //     [RESOURCE_CLASSES.sns]: [
+    //       SNS_RESOURCE.publish,
+    //     ]
+    //   },
+    //   [
+    //     resourceNames(RESOURCE_CLASSES.sns, flowStepInSplitKey[2] + flowStepInSplitKey[3]),
+    //   ]
+    // )
+  );
   return {
     templatePath: templatePath,
     templateData: {
-      resourceLocation: path.join(SOURCE_PATH.resourceLocationFlowSchemaExternalTopic, flowSchema.flowTag, "source/"),
+      resourceLocation: path.join(SOURCE_PATH.resourceLocationFlowSchema, flowSchema.flowTag, "source/"),
       functionName,
       handlerType,
       functionNameConfig: functionConfig,

package/src/reStructure/TemplateData/flowSchema/externalTopic/sqs/functionYaml/template.ejs

@@ -1,14 +1,14 @@
 <%_ const join = require('path').join _%>
 <%- firstLetterUpperCase(functionNameConfig) %>:
-  handler: <%- join(resourceLocation,  `${firstLetterUpperCase(functionName)}_${firstLetterUpperCase(handlerType)}.main`) %>
+  handler: <%- join(resourceLocation,  `${firstLetterUpperCase(functionName)}Out_${firstLetterUpperCase(handlerType)}.main`) %>
   name: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(functionNameConfig) %>
   events:
     - sqs:
-        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(functionName) %>
+        arn: arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(functionName) + firstLetterUpperCase(handlerType) %>
         batchSize: 10
   role: <%- firstLetterUpperCase(roleName) _%>Role
-    #<#<%_ functionName _%><%_ handlerType _%>IamRole#>
-    #<#/<%_ functionName _%><%_ handlerType _%>IamRole#>
+  #<#<%- functionName %><%- handlerType %>IamRole#>
+  #<#/<%- functionName %><%- handlerType %>IamRole#>
 <%_ function firstLetterUpperCase(text){
   return text.charAt(0).toUpperCase() + text.slice(1)
 } _%>

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

@@ -41,22 +41,21 @@ function createParamsForCreateSource(_izContext, flowSchema, srcPath) {
     _izContext.logger.error(`flowStepInSplitKey.length < 4: ${flowStepInSplitKey.length} ${flowSchema.flowTag}`);
     return null;
   }
-  const ExternalTopicName = FUNCTION_NAME.flowSchemaExternalTopic + 'Out';
-  let queueName = (flowStepInSplitKey[2]) + (flowStepInSplitKey[3]) + 'Out';
-  let functionName = upperCase(FUNCTION_NAME.flowSchemaExternalTopic)
+  let functionName = upperCase(flowSchema.flowTag) + "ExternalTopicOut"
   let handlerType = upperCase(HANDLER.hdrSqs);
   return {
     templatePath: templatePath,
     templateData: {
-      queueName,
-      fileName: ExternalTopicName + 'Out_Main',
-      functionMain: ExternalTopicName + 'Out',
+      queueName: functionName + handlerType,
+      fileName: functionName + '_Main',
+      functionMain: functionName + 'Main',
       handler: HANDLER.hdrSqs,
       firstLetterUpperCase: upperCase,
+      functionName
     },
     setting: {
-      savePath: path.join(srcPath, SOURCE_PATH.flowSchemaExternalTopic, flowSchema.flowTag, 'source/'),
-      saveFileName: `${functionName}Out_${handlerType}`,
+      savePath: path.join(srcPath, SOURCE_PATH.flowSchema, flowSchema.flowTag, 'source/'),
+      saveFileName: `${functionName}_${handlerType}`,
       fileExtension: ".js",
       isAppend: false
     }

package/src/reStructure/TemplateData/flowSchema/externalTopic/sqs/handler/template.ejs

@@ -29,7 +29,7 @@ const { <%- functionMain %> } =require('./<%- firstLetterUpperCase(fileName) %>.
 // validate event properties in body.Message of sqs event
 middlewareHandler.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema());
 // set schema for record.body.Message
-// const perRecordsValidatorSchema = {
+const perRecordsValidatorSchema = {}
 //   type: "object",
 //   required: ['param1', 'param2', 'param3', 'param4',],
 //   properties: {
@@ -63,18 +63,18 @@ middlewareHandler.setValidatorSchema(recordHandlerSharedLib.baseValidatorSchema(
 // };
 
 // set schema for record.body.MessageAttributes
-const messageAttributeValidatorSchema = {
-  type: "object",
-  required: ['msgAtrrParam1', 'msgAtrrParam2'],
-  properties: {
-    msgAtrrParam1: {
-      type: "string"
-    },
-    msgAtrrParam2: {
-      type: "object"
-    }
-  }
-};
+// const messageAttributeValidatorSchema = {
+//   type: "object",
+//   required: ['msgAtrrParam1', 'msgAtrrParam2'],
+//   properties: {
+//     msgAtrrParam1: {
+//       type: "string"
+//     },
+//     msgAtrrParam2: {
+//       type: "object"
+//     }
+//   }
+// };
 
 module.exports.main = middlewareHandler.wrap(async (event, context, callback) => {
 

package/src/reStructure/TemplateData/flowSchema/externalTopic/sqs/mainFunction/data.js

@@ -38,7 +38,7 @@ function data(_izContext, flowSchema, srcPath) {
 }
 
 function createParamsForCreateSource(_izContext, flowSchema, srcPath) {
-  let functionName = upperCase(FUNCTION_NAME.flowSchemaExternalTopic)
+  let functionName = upperCase(flowSchema.flowTag) + "ExternalTopicOut";
   let snsTopicIn = Object.keys(flowSchema.flowSteps)
   let snsTopicInWithoutUnderscore = snsTopicIn[0].replace(/_/g, '')
   let handlerType = upperCase(HANDLER.hdrSqs);
@@ -48,11 +48,11 @@ function createParamsForCreateSource(_izContext, flowSchema, srcPath) {
     templatePath: templatePath,
     templateData: {
       snsTopicIn: snsTopicInWithoutUnderscore,
-      externalTopicOutMain: FUNCTION_NAME.flowSchemaExternalTopic + 'Out',
+      externalTopicOutMain: functionName,
     },
     setting: {
-      savePath: path.join(srcPath, SOURCE_PATH.flowSchemaExternalTopic, flowSchema.flowTag, 'source/'),
-      saveFileName: `${functionName}Out_Main`,
+      savePath: path.join(srcPath, SOURCE_PATH.flowSchema, flowSchema.flowTag, 'source/'),
+      saveFileName: `${functionName}_Main`,
       fileExtension: ".js",
       isAppend: false
     }