@izara_project/izara-core-generate-service-code 1.0.20 → 1.0.22

package/index.js

@@ -16,9 +16,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import createSource from './src/SourceManager/CreateSource.js';
-import generateCode from './src/GenerateCode.js';
-import generateIntTest from './src/GenerateTests.js';
-import generateResourceIntTest from './src/GenerateResources.js';
+import generateCode from './src/generateCode.js';
+import generateIntTest from './src/generateTests.js';
+import generateResourceIntTest from './src/generateResources.js';
 
 import consts from './src/libs/Consts.js';
 import generateCodeLibs from './src/libs/GenerateCodeLibs.js';
@@ -36,4 +36,4 @@ export {
   generateCodeLibs,
   libs,
   utils
-};
+};

package/jsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "baseUrl": "src",
+    "paths": {
+      "#libs/*": ["libs/*"]
+    }
+  },
+  "include": ["src"]
+}

package/package.json

@@ -1,33 +1,36 @@
 {
   "name": "@izara_project/izara-core-generate-service-code",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "Code for locally generating per service files",
+  "author": "Sven Mason <thebarbariansven@gmail.com>",
+  "license": "AGPL-3.0-or-later",
+  "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
   "main": "index.js",
-  "scripts": {
-    "test": "jest"
-  },
   "repository": {
     "type": "git",
     "url": "git+ssh://git@bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code.git"
   },
-  "author": "Sven Mason <thebarbariansven@gmail.com>",
-  "license": "AGPL-3.0-or-later",
-  "homepage": "https://bitbucket.org/izara-core-support-services/izara-core-support-services-generate-service-code#readme",
-  "devDependencies": {
-    "jest": "^23.6.0"
+  "imports": {
+    "#libs/*": "./src/libs/*"
+  },
+  "scripts": {
+    "test": "jest"
   },
   "jest": {
     "testEnvironment": "node"
   },
+  "devDependencies": {
+    "jest": "^30.3.0"
+  },
   "type": "module",
   "dependencies": {
     "@izara_project/izara-core-library-core": "^1.0.31",
-    "@izara_project/izara-core-library-service-schemas": "^1.0.108",
-    "@izara_project/izara-shared-core": "^1.0.8",
-    "@izara_project/izara-shared-service-schemas": "^1.0.35",
-    "ejs": "^3.1.10",
+    "@izara_project/izara-core-library-logger": "^1.0.8",
+    "@izara_project/izara-core-library-s3": "^1.0.5",
+    "@izara_project/izara-core-library-service-schemas": "^1.0.126",
+    "@izara_project/izara-shared-core": "^1.0.9",
+    "ejs": "^5.0.1",
     "js-beautify": "^1.15.4",
-    "lodash": "^4.17.21",
     "yaml": "^2.8.2"
   }
 }

package/src/SourceManager/CreateSource.js

@@ -78,8 +78,7 @@ function generateDataFromTemplate(template, data) {
 }
 
 /**
- * generate code from template and data then save generated data
- *
+ * Generate code from template and data then save generated data
  * @param {string} template
  * @param {object} data
  * @param {object} setting
@@ -88,8 +87,10 @@ function generateDataFromTemplate(template, data) {
  * @param {string} setting.saveFileName
  * @param {string} setting.fileExtension
  * @param {boolean} setting.isAppend
- * @param {string} setting.initialData // initialData can use when isAppend = true
- * @returns
+ * @param {string} setting.initialData - used when isAppend = true and file does not exist yet
+ * @param {boolean} setting.checkCreateSourcePass - if true, only validate template without writing
+ * @param {boolean} setting.generateHookFile
+ * @returns {Promise<[boolean, object]|void>}
  */
 async function createSource(
   template,
@@ -116,111 +117,57 @@ async function createSource(
       }
     }
 
-    let dataToSave = generateDataFromTemplate(template, data);
-
-    let anyDoubleTagClass;
-    let doubleTagClass;
-
-    if (fileExtension === '.js') {
-      anyDoubleTagClass = TAG_CLASSES.anyDoubleTag;
-      doubleTagClass = TAG_CLASSES.doubleTag;
-    } else if (fileExtension === '.yml') {
-      anyDoubleTagClass = TAG_CLASSES.ymlAnyDoubleTag;
-      doubleTagClass = TAG_CLASSES.ymlDoubleTag;
-    }
-    let hookDataPath = hookPath ? hookPath : join(savePath, '../hook/');
-
+    const isJs = fileExtension === '.js';
+    const isYml = fileExtension === '.yml';
+
+    const anyDoubleTagClass = isJs
+      ? TAG_CLASSES.anyDoubleTag
+      : isYml
+        ? TAG_CLASSES.ymlAnyDoubleTag
+        : undefined;
+    const doubleTagClass = isJs
+      ? TAG_CLASSES.doubleTag
+      : isYml
+        ? TAG_CLASSES.ymlDoubleTag
+        : undefined;
+
+    const hookDataPath = hookPath ?? join(savePath, '../hook/');
+    const filePath = `${savePath}${saveFileName}${fileExtension}`.trim();
+    const hookFilePath =
+      `${hookDataPath}${saveFileName}${fileExtension}`.trim();
+
+    // ensure output and hook directories exist
     if (!fs.existsSync(savePath)) fs.mkdirSync(savePath, { recursive: true });
-    if (generateHookFile)
-      if (!fs.existsSync(hookDataPath))
-        fs.mkdirSync(hookDataPath, { recursive: true });
-
-    // check saveFileName for Hook exists
-    if (
-      fs.existsSync(`${hookDataPath}${saveFileName}${fileExtension}`.trim())
-    ) {
-      const hookData = fs.readFileSync(
-        `${hookDataPath}${saveFileName}${fileExtension}`,
-        'utf8'
-      );
+    if (generateHookFile && !fs.existsSync(hookDataPath))
+      fs.mkdirSync(hookDataPath, { recursive: true });
 
-      //replace data in tag from hook file to actual file
-      let dataAfterHook = dataToSave.replace(
+    let dataToSave = generateDataFromTemplate(template, data);
+
+    // apply hook overrides if hook file exists
+    if (fs.existsSync(hookFilePath)) {
+      const hookData = fs.readFileSync(hookFilePath, 'utf8');
+      dataToSave = dataToSave.replace(
         tagList(anyDoubleTagClass),
-        (match, tagName, content) => {
-          let hookRegex = tagList(doubleTagClass, tagName);
-          let replaceData = hookData.match(hookRegex);
-
-          if (replaceData) {
-            return replaceData;
-          } else {
-            return match;
-          }
-        }
+        (match, tagName) =>
+          hookData.match(tagList(doubleTagClass, tagName)) ?? match
       );
+    }
 
-      dataAfterHook =
-        fileExtension === '.js'
-          ? beautify(dataAfterHook, beautifySetting)
-          : dataAfterHook;
-      if (isAppend) {
-        if (
-          !fs.existsSync(`${savePath}${saveFileName}${fileExtension}`) &&
-          initialData
-        ) {
-          fs.writeFileSync(
-            `${savePath}${saveFileName}${fileExtension}`.trim(),
-            initialData + dataAfterHook + '\n\n',
-            'utf8'
-          );
-        } else {
-          fs.appendFileSync(
-            `${savePath}${saveFileName}${fileExtension}`.trim(),
-            dataAfterHook + '\n\n',
-            'utf8'
-          );
-        }
-      } else {
-        fs.writeFileSync(
-          `${savePath}${saveFileName}${fileExtension}`.trim(),
-          dataAfterHook,
-          'utf8'
-        );
-      }
+    if (isJs) dataToSave = beautify(dataToSave, beautifySetting);
+
+    // write or append to output file
+    if (isAppend) {
+      const shouldWriteWithInitial = !fs.existsSync(filePath) && initialData;
+      const content =
+        (shouldWriteWithInitial ? initialData : '') + dataToSave + '\n\n';
+      shouldWriteWithInitial
+        ? fs.writeFileSync(filePath, content, 'utf8')
+        : fs.appendFileSync(filePath, dataToSave + '\n\n', 'utf8');
     } else {
-      dataToSave =
-        fileExtension === '.js'
-          ? beautify(dataToSave, beautifySetting)
-          : dataToSave;
-      if (isAppend) {
-        if (
-          !fs.existsSync(`${savePath}${saveFileName}${fileExtension}`) &&
-          initialData
-        ) {
-          fs.writeFileSync(
-            `${savePath}${saveFileName}${fileExtension}`.trim(),
-            initialData + dataToSave + '\n\n',
-            'utf8'
-          );
-        } else {
-          fs.appendFileSync(
-            `${savePath}${saveFileName}${fileExtension}`.trim(),
-            dataToSave + '\n\n',
-            'utf8'
-          );
-        }
-      } else {
-        fs.writeFileSync(
-          `${savePath}${saveFileName}${fileExtension}`.trim(),
-          dataToSave,
-          'utf8'
-        );
-      }
+      fs.writeFileSync(filePath, dataToSave, 'utf8');
     }
-
-    return;
   } catch (err) {
-    console.log('error createSource: ', err); // generate
+    console.error('Error in createSource:', err);
     throw err;
   }
 }

package/src/generateCode/generateFlowSchema/GenerateCodeFlowSchema.js

@@ -0,0 +1,221 @@
+/*
+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 event component
+import createFlowSchemaOwnTopicComponent from './event/ownTopicComponent/index.js';
+import createFlowSchemaExtTopicComponent from './event/extTopicComponent/index.js';
+import createFlowSchemaS3Component from './event/s3Component/index.js';
+import createFlowSchemaEventBridgeComponent from './event/eventBridgeComponent/index.js';
+import createLambdaSyncInvComponent from './event/lambdaSyncInvComponent/index.js';
+import createLambdaSyncApiComponent from './event/lambdaSyncApiComponent/index.js';
+
+// import statusType component
+import createStatusFieldComponent from './statusType/statusFieldComponent/index.js';
+import createTriggerCacheComponent from './statusType/triggerCacheComponent/index.js';
+
+// import webSocket component
+import createWebSocketComponent from './webSocketComponent/index.js';
+
+// import register component
+import createRegisterComponent from './registerComponent/index.js';
+
+// import per-flowSchema components
+import createWebSocketGenerateCodeLibs from './libs/data.js';
+import createFlowSchemaEndpointMainFunction from './flowSchemaMainFunction/data.js';
+import buildFlowStepResources from './flowStep/flowStep.js';
+
+import libs from '#libs/Libs.js';
+
+/**
+ * Generates template data from flow schemas
+ * @param {Object} _izContext - Context object with logger
+ * @param {string} appPath - Root path of the service
+ * @param {Array} allLocalFlowSchemas - Array of flow schema objects
+ * @param {Object} settings - Optional generation settings
+ * @returns {Promise<Array>} Array of generated source params
+ */
+async function generateTemplateDataFromFlowSchema(
+  _izContext,
+  appPath,
+  allLocalFlowSchemas,
+  settings
+) {
+  try {
+    const startAllMs = Date.now();
+
+    const EVENT_HANDLERS = {
+      ownTopic: createFlowSchemaOwnTopicComponent,
+      extTopic: createFlowSchemaExtTopicComponent,
+      s3: createFlowSchemaS3Component,
+      eventBridge: createFlowSchemaEventBridgeComponent,
+      lambdaSyncInv: createLambdaSyncInvComponent,
+      lambdaSyncApi: createLambdaSyncApiComponent,
+      generatedCode: null
+    };
+
+    const shouldGenerateWebSocketAndRegister = allLocalFlowSchemas.some(
+      flowSchema =>
+        Array.isArray(flowSchema?.event) &&
+        flowSchema.event.some(e => e === 'ownTopic' || e === 'extTopic')
+    );
+
+    const flowResults = await Promise.all(
+      allLocalFlowSchemas.map(async flowSchema => {
+        const flowStartMs = Date.now();
+        const flowTag = flowSchema?.flowTag ?? '(unknownFlowTag)';
+        const events = Array.isArray(flowSchema?.event) ? flowSchema.event : [];
+
+        console.info(
+          `[FlowSchema:${flowTag}] start events=${JSON.stringify(events)} statusType=${flowSchema?.statusType}`
+        );
+
+        // ── per-flowSchema resources ─────────────────────────────────────────
+        const perFlowParams = [
+          ...createWebSocketGenerateCodeLibs(_izContext, flowSchema, appPath),
+          ...(!flowSchema.event.includes('s3')
+            ? await createFlowSchemaEndpointMainFunction(
+                _izContext,
+                flowSchema,
+                appPath
+              )
+            : []),
+          ...buildFlowStepResources(_izContext, flowSchema, appPath)
+        ];
+
+        // ── event handlers ───────────────────────────────────────────────────
+        const eventPromises = events
+          .filter(event => {
+            if (!(event in EVENT_HANDLERS)) {
+              console.warn(
+                `[FlowSchema:${flowTag}] skip unsupported event=${event}`
+              );
+              return false;
+            }
+            if (EVENT_HANDLERS[event] === null) {
+              console.info(
+                `[FlowSchema:${flowTag}] skip not implemented event=${event}`
+              );
+              return false;
+            }
+            return true;
+          })
+          .map(event =>
+            Promise.resolve(
+              EVENT_HANDLERS[event](_izContext, flowSchema, appPath)
+            ).then(result => {
+              console.info(
+                `[FlowSchema:${flowTag}] done event=${event} generated=${Array.isArray(result) ? result.flat(5).length : 0}`
+              );
+              return result;
+            })
+          );
+
+        // ── statusType handler ───────────────────────────────────────────────
+        const statusPromise = (() => {
+          const { statusType, event } = flowSchema;
+          if (
+            statusType === 'statusField' &&
+            event.includes('ownTopic') &&
+            event.includes('extTopic')
+          ) {
+            return Promise.resolve(
+              createStatusFieldComponent(_izContext, flowSchema, appPath)
+            ).then(result => {
+              console.info(
+                `[FlowSchema:${flowTag}] done statusType=StatusField generated=${Array.isArray(result) ? result.flat(5).length : 0}`
+              );
+              return result;
+            });
+          } else if (statusType === 'triggerCache') {
+            return Promise.resolve(
+              createTriggerCacheComponent(_izContext, flowSchema, appPath)
+            ).then(result => {
+              console.info(
+                `[FlowSchema:${flowTag}] done statusType=TriggerCache generated=${Array.isArray(result) ? result.flat(5).length : 0}`
+              );
+              return result;
+            });
+          } else if (statusType === 'storedCache') {
+            console.info(
+              `[FlowSchema:${flowTag}] skip statusType=StoredCache (noop)`
+            );
+          } else if (statusType === 'none') {
+            console.info(`[FlowSchema:${flowTag}] skip statusType=None (noop)`);
+          } else if (statusType !== 'statusField') {
+            throw new Error('Not supported statusType: ' + statusType);
+          }
+          return Promise.resolve([]);
+        })();
+
+        const results = [
+          ...perFlowParams,
+          ...(await Promise.all([...eventPromises, statusPromise])).flat(5)
+        ];
+
+        const targetFiles = libs.toUniqueFilePaths(results);
+
+        console.info(
+          `[FlowSchema:${flowTag}] completed generated=${results.length} elapsedMs=${Date.now() - flowStartMs}`
+        );
+        if (targetFiles.length)
+          console.info(`[FlowSchema:${flowTag}] targetFiles: `, targetFiles);
+
+        return results;
+      })
+    );
+
+    const createSourceParams = flowResults.flat(5);
+
+    if (shouldGenerateWebSocketAndRegister) {
+      const [webSocketResults, registerResults] = await Promise.all([
+        Promise.resolve(
+          createWebSocketComponent(_izContext, appPath, allLocalFlowSchemas)
+        ),
+        Promise.resolve(
+          createRegisterComponent(_izContext, allLocalFlowSchemas, appPath)
+        )
+      ]);
+
+      createSourceParams.push(...webSocketResults, ...registerResults);
+
+      const wsAndRegisterFiles = libs.toUniqueFilePaths([
+        ...webSocketResults,
+        ...registerResults
+      ]);
+
+      console.info(
+        `[FlowSchema:*] completed webSocket+register generated=${webSocketResults.length + registerResults.length}`
+      );
+      if (wsAndRegisterFiles.length)
+        console.info(
+          '[FlowSchema:*] targetFiles (webSocket+register) : ',
+          wsAndRegisterFiles
+        );
+    }
+
+    console.info(
+      `[FlowSchema:*] all completed flows=${allLocalFlowSchemas.length} generated=${createSourceParams.length} elapsedMs=${Date.now() - startAllMs}`
+    );
+
+    return createSourceParams;
+  } catch (error) {
+    console.error('Error in generateTemplateDataFromFlowSchema:', error);
+    throw error;
+  }
+}
+
+export default generateTemplateDataFromFlowSchema;

package/src/{TemplateData/flowSchema/event/eventBridge → generateCode/generateFlowSchema/event/eventBridgeComponent}/functionYaml/data.js

@@ -20,9 +20,9 @@ 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';
+import consts from '#libs/Consts.js';
+import utils from '#libs/Utils.js';
+import libs from '#libs/Libs.js';
 
 const { firstLetterUpperCase: upperCase } = utils;
 const {
@@ -45,10 +45,6 @@ const templatePath = path.join(__dirname, 'template.ejs');
  * @param {Object} objectSchema
  * @return {{templatePath, templateData,setting}}
  */
-function data(_izContext, flowSchema, srcPath) {
-  return [createSourceParams(_izContext, flowSchema, srcPath)];
-}
-
 function createSourceParams(_izContext, flowSchema, srcPath) {
   const functionName = upperCase(FUNCTION_NAME.flowSchemaEventBridge);
   // const action = SOURCE_GENERATE_IAM_ROLE.EventBridge;
@@ -158,11 +154,11 @@ function createSourceParams(_izContext, flowSchema, srcPath) {
     },
     setting: {
       savePath: path.join(srcPath, SOURCE_PATH.appYaml),
-      saveFileName: upperCase(SAVE_FILE_NAME.flowSchema),
+      saveFileName: SAVE_FILE_NAME.flowSchemaYaml,
       fileExtension: '.yml',
       isAppend: true
     }
   };
 }
 
-export default data;
+export default createSourceParams;

package/src/{TemplateData/flowSchema/event/eventBridge → generateCode/generateFlowSchema/event/eventBridgeComponent}/handler/inv/data.js

@@ -20,8 +20,8 @@ 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 consts from '#libs/Consts.js';
+import utils from '#libs/Utils.js';
 
 const { firstLetterUpperCase: upperCase } = utils;
 const { SOURCE_PATH, HANDLER } = consts;
@@ -42,30 +42,28 @@ function data(_izContext, flowSchema, srcPath) {
   // const action = SOURCE_GENERATE_IAM_ROLE.EventBridge;
   const functionName = 'EventBridge';
   // const fileName = `${upperCase(flowTag)}${upperCase(action)}_${upperCase(handler)}`;
-  return [
-    {
-      templatePath: templatePath,
-      templateData: {
-        functionName: functionName,
-        flowTag: flowTag,
-        // action: action,
-        handler
-        // roleName: SOURCE_GENERATE_IAM_ROLE.EventBridge,
-        // firstLetterUpperCase: upperCase,
-      },
-      setting: {
-        savePath: path.join(
-          srcPath,
-          SOURCE_PATH.flowSchemaEventBridge,
-          flowSchema.flowTag,
-          'source/'
-        ),
-        saveFileName: `${upperCase(functionName)}_${upperCase(handler)}`,
-        fileExtension: '.js',
-        isAppend: false
-      }
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName: functionName,
+      flowTag: flowTag,
+      // action: action,
+      handler
+      // roleName: SOURCE_GENERATE_IAM_ROLE.EventBridge,
+      // firstLetterUpperCase: upperCase,
+    },
+    setting: {
+      savePath: path.join(
+        srcPath,
+        SOURCE_PATH.flowSchemaEventBridge,
+        flowSchema.flowTag,
+        'source/'
+      ),
+      saveFileName: `${upperCase(functionName)}_${upperCase(handler)}`,
+      fileExtension: '.js',
+      isAppend: false
     }
-  ];
+  };
 }
 
 export default data;

package/src/{TemplateData/flowSchema/event/eventBridge/eventBridgeComponent.js → generateCode/generateFlowSchema/event/eventBridgeComponent/index.js}

@@ -2,22 +2,23 @@ import createFlowSchemaEventBridgeFunctionYaml from './functionYaml/data.js';
 import createFlowSchemaEventBridgeHandler from './handler/inv/data.js';
 import createFlowSchemaEventBridgeMainFunction from './mainFunction/data.js';
 
-function createEventBridgeComponent(_izContext, flowSchema, saveFilePath) {
+function createEventBridgeComponent(_izContext, flowSchema, rootServicePath) {
   const component = [
-    ...createFlowSchemaEventBridgeHandler(_izContext, flowSchema, saveFilePath),
-    ...createFlowSchemaEventBridgeMainFunction(
+    createFlowSchemaEventBridgeHandler(_izContext, flowSchema, saveFilePath),
+    createFlowSchemaEventBridgeMainFunction(
       _izContext,
       flowSchema,
       saveFilePath
     ),
-    ...createFlowSchemaEventBridgeFunctionYaml(
+    createFlowSchemaEventBridgeFunctionYaml(
       _izContext,
       flowSchema,
       saveFilePath
     )
   ];
 
-  return component.flat();
+  console.info('generateEventBridgeComponent ✅');
+  return component;
 }
 
 export default createEventBridgeComponent;

package/src/{TemplateData/flowSchema/event/eventBridge → generateCode/generateFlowSchema/event/eventBridgeComponent}/mainFunction/data.js

@@ -20,8 +20,8 @@ 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 consts from '#libs/Consts.js';
+import utils from '#libs/Utils.js';
 
 const { firstLetterUpperCase: upperCase } = utils;
 const { SOURCE_PATH, SOURCE_GENERATE_IAM_ROLE } = consts;
@@ -41,29 +41,27 @@ function data(_izContext, flowSchema, srcPath) {
   // const functionName = "EventBridge" + upperCase(handler);
   // const action = SOURCE_GENERATE_IAM_ROLE.EventBridge;
   // const fileName = `${upperCase(flowTag)}${upperCase(action)}_Main`;
-  return [
-    {
-      templatePath: templatePath,
-      templateData: {
-        functionName: 'EventBridge',
-        flowTag: flowTag,
-        roleName: SOURCE_GENERATE_IAM_ROLE.EventBridge,
-        // action: action,
-        firstLetterUpperCase: upperCase
-      },
-      setting: {
-        savePath: path.join(
-          srcPath,
-          SOURCE_PATH.flowSchemaEventBridge,
-          flowSchema.flowTag,
-          'source/'
-        ),
-        saveFileName: 'EventBridge_Main',
-        fileExtension: '.js',
-        isAppend: false
-      }
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName: 'EventBridge',
+      flowTag: flowTag,
+      roleName: SOURCE_GENERATE_IAM_ROLE.EventBridge,
+      // action: action,
+      firstLetterUpperCase: upperCase
+    },
+    setting: {
+      savePath: path.join(
+        srcPath,
+        SOURCE_PATH.flowSchemaEventBridge,
+        flowSchema.flowTag,
+        'source/'
+      ),
+      saveFileName: 'EventBridge_Main',
+      fileExtension: '.js',
+      isAppend: false
     }
-  ];
+  };
 }
 
 export default data;