feat: result action and swagger

Author: code-by-ai

.gitignore

@@ -1 +1,3 @@
-node_modules
+node_modules
+mock
+mock.config.json

README.md

@@ -1,9 +1,28 @@
 ## dev-mock-cli
+支持能力/价值：
+- Mock API
+- 读取Swagger API，并生成接口
+- 无需担心跨域问题
+- 安装和启动方便
+
+待办：
+- [待确认]支持版本：node>=14
+- 发布启动的配置信息汇总，提示产品使用文档：CLI使用说明，配置说明mock.config.json
+- 同时只能支持一个风格，当风格切换时，检测到有mock文件夹，则提示清空
+- TODO: restful: 读取swagger，生成json，处理中，晚上CLI的文档，用来测试
+- TODO: 读取配置文件，全局使用处理
+- TODO: .js默认加载
+- TODO: mock能力细节处理
+- 安装则生成mock.config.json
+- 生成单元测试
+- 录制演示视频
+- 优化打印日志，全部英文显示
 
 ### 二、启动一个Mock-API服务
 
 #### action 风格的api
 
+
 在mock文件新建`[Action].json`文件，Action为对应api的名字，如果请求地址路径有参数，可以创建多层
 
 比如一个请求url: `http://localhost:9000/list`, Action: "List"的api，数据为
@@ -66,33 +85,13 @@ npm run publish:patch
 2、撤回 24 小时内发布的版本，撤回后 24 小时内不允许发布
 
 ```
-npm unpublish u-admin-cli@1.0.2
+npm unpublish dev-mock-cli@1.0.2
 ```
 
 ### 五、本地开发
 
 ```
-cd u-admin-cli
+cd dev-mock-cli
 yarn install
 yarn start [command]
-```
-
-
-## 待办
-
-- 安装在项目中
-- 自动安装和启动，mock api
-- 支持restful风格API
-- 本地直接打开项目使用文档
-
-
-- 配置html页面
-- 添加默认配置
-- 读取项目中的参数
-- 优化日志
-- 通过swagger API生成mock API
-- 需要增加错误判断，避免程序报错退出
-- 单元测试
-- 使用文档
-- 若端口被占用，重新启动一个端口
-- 录制视频
+```

bin/index.js

@@ -6,6 +6,12 @@ import { commandOptions } from './config.js';
 
 const yargsCommand = yargs(hideBin(process.argv));
 
+// 检查是否提供了命令
+if (process.argv.length < 3) {
+  console.error("请提供一个命令，例如: 'dev-mock-cli help'");
+  process.exit(1); // 非正常退出
+}
+
 commandOptions.forEach(commandConfig => {
   const { command, descriptions, options, callback } = commandConfig;
   yargsCommand.command(

command/action.js

@@ -1,61 +1,54 @@
 import fs from 'fs';
-import { NotFoundResponse } from './response.js';
+import { createProxyMiddleware } from 'http-proxy-middleware';
+import { ResponseExample } from './response.js';
+import { getAllAction } from '../utils/index.js';
+import { getConfig } from '../utils/config.js';
+import { generateApi, createAPIFile, fetchAndCreateRoutes } from './localAction.js';
 
-const checkFileExist = filePath => {
-  // 检查当前目录是否存在
-  if (!fs.existsSync(filePath) && type === 'action') {
-    if (create) {
-      fs.mkdir(`mock`, function (err) {
-        if (err) {
-          return console.error(err.message);
-        }
-        fs.mkdirSync(`./mock/api`);
-        const data = JSON.stringify(ResponseExample, '', '\t');
-        fs.writeFileSync('./mock/api/list.json', data);
-      });
-      console.log(
-        chalk.green(
-          `curl --location --request POST 'http://localhost:9000/api' \ --header 'Content-Type: application/json' \ --data-raw '{ "Action": "list" }'`
-        )
-      );
-    } else {
-      console.log(
-        'The current directory mock folder does not exist, you can create it use : ' + chalk.red('u-admin-cli mock -n')
-      );
-    }
-  }
-};
-
-const action = ({ app, filePath }) => {
-  // 如果在mock下，判断下key的值
-  app.post('*', async (req, res) => {
-    const key = req.params[0].substring(1);
-    const { Action } = req.body;
-    if (key) {
-      const fileList = [];
-      try {
-        fs.readdirSync(filePath).forEach(fileName => {
-          fileList.push(fileName);
-        });
-      } catch (err) {
-        res.send(NotFoundResponse);
-      }
 
-      if (!fileList.includes(key) || !Action) {
-        res.send(NotFoundResponse);
-      }
-    }
+const action = async ({ app, filePath }) => {
+  // TODO: 配置信息需要统一处理，作为全局使用，type的每个优先级需要确认和逻辑开发
+  const { proxyApiUrl, swaggerApiJSON=[] } = await getConfig();
+  
+  // 如果 mock 文件夹不存在，自动创建它
+  if (!fs.existsSync(filePath)) {
+    createAPIFile(ResponseExample, filePath, 'ActionName.json');
+  }
 
-    const file = `${filePath}${key}/${Action}.json`; //文件路径，__dirname为当前运行js文件的目录
+  // 获取所有 action 名称
+  const allActions = getAllAction(filePath);
+  if (allActions.length === 0) {
+    console.warn('No actions found in the mock directory.');
+    return;
+  }
+  
+  // Step 1: 中间件来拦截请求并动态修改 URL
+  // app.use('/', (req, res, next) => {
+  //   const { Action } = req.body;
+  //   if (!Action) {
+  //     // 如果请求体中没有 Action，返回 400 错误
+  //     return res.status(400).send({ error: 'Action field is required' });
+  //   }
+  //   // 动态修改请求的 URL，将它转发到 /{Action} 路径
+  //   req.url = `/${Action}`;
+  //   next();  // 继续处理下一个中间件
+  // });
 
-    fs.readFile(file, 'utf-8', function (err, data) {
-      if (err) {
-        res.send(NotFoundResponse);
-      } else {
-        res.send(data);
-      }
-    });
-  });
+  // Step2: 为每个 action 注册对应的路由
+  generateApi(app, filePath, allActions);
+  
+  // Step3: 获取swagger api json的数据，注册接口
+  // 调用 fetchAndCreateRoutes 函数
+  await fetchAndCreateRoutes({app, swaggerApiJSON});
+  
+  // Step4: 获取代理配置并设置代理
+  if (proxyApiUrl) {
+    app.use('*', createProxyMiddleware({
+        target: proxyApiUrl,
+        changeOrigin: true,
+      })
+    );
+  }
 };
 
-export default action;
+export default action;

command/localAction.js

@@ -0,0 +1,95 @@
+import path from 'path';
+import fs from 'fs';
+import Mock from 'mockjs';
+import axios from 'axios';
+import { createSwaggerMockData } from './swaggerAction.js'
+export const createAPIFile = (dataJson, folderPath, fileName) => {
+    const apiFolderPath = path.resolve(folderPath);  // 定义 API 目录的绝对路径
+    const filePath = path.resolve(apiFolderPath, fileName);  // 定义 get.json 文件的绝对路径
+    
+    // 递归创建目录，确保 mock/api 文件夹存在
+    if (!fs.existsSync(apiFolderPath)) {
+      fs.mkdirSync(apiFolderPath, { recursive: true });
+    }
+    
+    const data = JSON.stringify(dataJson || ResponseExample, null, 2);
+    fs.writeFileSync(filePath, data);
+    console.log(`File created at: ${filePath}`);
+  };
+  
+export const generateApi = (app, filePath, actions) => {
+    actions.forEach(action => {
+      app.use(`/${action}`, async (req, res) => {
+        const { Action } = req.body;
+        const actionFile = path.join(filePath, `${Action}.json`);
+        if (!fs.existsSync(actionFile)) {
+          return res.status(404).send(NotFoundResponse);
+        }
+        
+        fs.readFile(actionFile, 'utf-8', (err, data) => {
+          if (err) {
+            console.error(`Error reading file: ${actionFile}`, err);
+            return res.status(404).send(NotFoundResponse);
+          }
+          try {
+            const mockData = Mock.mock(JSON.parse(data));
+            res.send(mockData);
+          } catch (parseError) {
+            console.error(`Error parsing JSON from file: ${actionFile}`, parseError);
+            return res.status(500).send({ error: 'Invalid JSON format' });
+          }
+        });
+      });
+    });
+  }
+  
+  // swagger生成路由
+export const createRoutes = ({ app, data }) => {
+    const paths = data.paths || {}
+    if(!paths){
+      return
+    }
+    const keys = Object.keys(paths);
+    const limit = Math.min(keys.length, 100); // 只生成前100个路由
+  
+    for (let i = 0; i < limit; i++) {
+      const pathKey = keys[i];
+      const pathInfo = paths[pathKey];
+      const lastSegment = `/${pathKey.split('/').pop()}`;
+      
+      Object.keys(pathInfo).forEach(method => {
+        app[method](lastSegment, async (req, res) => {
+          const { Action } = req.body;
+          if (Action) {
+            // TODO: 这里指读取了$ref字段，如果没有关联需要处理下
+            const responseSchema = pathInfo[method].responses['200'].schema['$ref'].split('/').pop();
+            const response = data.definitions[responseSchema]
+            const mockResponse = await createSwaggerMockData(data, response)
+            return res.status(200).json(mockResponse);
+          } else {
+            return res.status(404).send(NotFoundResponse);
+          }
+        });
+      });
+    }
+  };
+  
+  // Step3: 获取swagger api json的数据，注册接口
+export const fetchAndCreateRoutes = async ({ app, swaggerApiJSON }) => {
+    const routePromises = swaggerApiJSON.map(async (item) => {
+      const { type, url } = item;
+      if (type === 'action') {
+        try {
+          // TODO: 优化, 全局加载，方便后面读取直接使用
+          const response = await axios.get(url);
+          const data = response.data;
+          createRoutes({ app, data });
+        } catch (error) {
+          console.error('Error fetching data from URL:', url, error);
+        }
+      }
+    });
+  
+    // 等待所有的请求完成
+    await Promise.all(routePromises);
+};

command/localRestful.js

@@ -0,0 +1,96 @@
+import fs from 'fs';
+import chalk from 'chalk';
+import path from 'path';
+import Mock from 'mockjs';
+import { mockRestfulAPI, ResponseExample, NotFoundResponse } from './response.js'
+
+// 确保目录存在，并创建API文件
+const createAPIFile = (dataJson, folderPath, fileName) => {
+    const apiFolderPath = path.resolve(folderPath);  // 定义 API 目录的绝对路径
+    const filePath = path.resolve(apiFolderPath, fileName);  // 定义 get.json 文件的绝对路径
+    // 递归创建目录，确保 mock/api 文件夹存在
+    if (!fs.existsSync(apiFolderPath)) {
+      fs.mkdirSync(apiFolderPath, { recursive: true });
+    }
+    
+    const data = JSON.stringify(dataJson || ResponseExample, null, '\t');
+    fs.writeFileSync(filePath, data);
+    console.log(`File created at: ${filePath}`);
+};
+
+// 创建多个 API 文件
+export const createMultipleAPIFiles = (apiArray, basePath) => {
+    apiArray.forEach(item => {
+      const filePath = path.join(basePath, item.url);
+      createAPIFile(item.content, filePath, item.fileName);
+    });
+};
+  
+  // 检查文件夹是否存在，如果不存在就自动创建
+export const checkFileExist = (filePath, autoCreate = false) => {
+    const mkdirExist = fs.existsSync(filePath);
+    if (mkdirExist) {
+      return true;
+    }
+    if (!fs.existsSync(filePath) && !autoCreate) {
+      console.log(
+        'The current directory mock folder does not exist, you can create it use : ' + chalk.red('u-admin-cli mock -n')
+      );
+      return false;
+    } else {
+      fs.mkdirSync(filePath, { recursive: true });  // 使用 mkdirSync 保证同步执行，不需要回调函数
+      createMultipleAPIFiles(mockRestfulAPI, filePath);
+      console.log(chalk.green(`Auto create API folder successful: ${filePath}`));
+      return true;
+    }
+};
+
+// 替换url中的变量为占位符,
+// /user/1 -> /user/{id}、
+// /user/12/23 -> /user/12/23 | /user/{id}/23 | /user/12/{id}
+/* url中第一个/user不变，
+1、先精准匹配，
+2、依次将每一个替换成变量{id}，先替换1个，再2个...
+3、只到所有的替换成{id},每次替换完成后，读取上面的文件目录是否存在，如果存在则读取,终止，不存在则继续替换，都没有则返回404
+*/
+const replaceUrlWithPlaceholders = (url, placeholder = '{id}') => {
+    const parts = url.split('/').filter(Boolean);
+    const patterns = [];
+  
+    // 1. 精确匹配
+    patterns.push(url);
+    
+    // 2. 依次将每个部分替换成变量{id}
+    for (let i = 1; i <= parts.length; i++) {
+      for (let j = 0; j < parts.length; j++) {
+        const currentPattern = [...parts];
+        if (j < i) {
+          currentPattern[j] = placeholder; // 替换为占位符
+        }
+        patterns.push(currentPattern.join('/'));
+      }
+    }
+  
+    return patterns;
+};
+  
+export const checkFileExistsAndRespond = (url, filePath, req, res) => {
+    const patterns = replaceUrlWithPlaceholders(url);
+    for (const pattern of patterns) {
+      const method = req.method.toLowerCase();
+      const fileToLoad = path.join(filePath, `${pattern}/${method}.json`);
+  
+      if (fs.existsSync(fileToLoad)) {
+        fs.readFile(fileToLoad, 'utf-8', (err, data) => {
+          if (err) {
+            res.send(NotFoundResponse);
+          } else {
+            res.send(Mock.mock(JSON.parse(data)));
+          }
+        });
+        return; // 成功读取后终止
+      }
+    }
+    // 如果没有匹配到任何文件
+    res.send(NotFoundResponse);
+};