warehouse-mock 1.0.0 → 1.1.0

package/README.md

@@ -1,90 +1,39 @@
-# warehouse-mock
+# warehouse-mock-plugin
 
-一个专为 Vue 2 项目设计的 Webpack 插件，支持 RPC 风格接口 mock，零业务代码侵入，实时更新。
+<div align="center">
 
-[![npm version](https://img.shields.io/npm/v/warehouse-mock.svg)](https://www.npmjs.com/package/warehouse-mock)
-[![license](https://img.shields.io/npm/l/warehouse-mock.svg)](https://github.com/CodeMomentYY/warehouse-mock/blob/main/LICENSE)
+极简 Vue Mock 插件，零业务代码侵入，完美支持 RPC 风格接口
 
-## ✨ 特性
+[![npm version](https://img.shields.io/npm/v/warehouse-mock-plugin.svg)](https://www.npmjs.com/package/warehouse-mock-plugin)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-- ✅ **RPC 风格接口支持**: 完美支持 `/api?user.account.getInfo` 格式
-- ✅ **零业务代码侵入**: 只需修改配置文件，无需改动业务逻辑
-- ✅ **实时更新**: 修改 Mock 数据后刷新页面即可，无需重启服务
-- ✅ **按需 Mock**: 只拦截配置了 Mock 数据的接口，其他接口不受影响
-- ✅ **TypeScript 编写**: 类型安全，易于维护
-- ✅ **兼容性强**: 支持 Webpack 4/5，Vue CLI 3/4/5
+</div>
 
-## 📦 安装
+## 安装
 
 ```bash
-npm install warehouse-mock --save-dev
+npm install warehouse-mock-plugin --save-dev
 ```
 
-## 🚀 快速开始
+## 快速开始
 
 ### 1. 配置 vue.config.js
 
 ```javascript
-const WarehouseMockPlugin = require('warehouse-mock');
-const webpack = require('webpack');
-const path = require('path');
+const WarehouseMockPlugin = require('warehouse-mock-plugin');
 
 const isMock = process.env.MOCK === 'true';
-const mockPlugin = isMock ? new WarehouseMockPlugin({
-  mockPath: path.resolve(__dirname, 'warehouseMock'),
-}) : null;
 
 module.exports = {
   configureWebpack: config => {
-    if (isMock && mockPlugin) {
-      config.plugins.push(
-        new webpack.DefinePlugin({
-          'process.env.VUE_APP_MOCK': JSON.stringify('true'),
-        })
-      );
-      config.plugins.push(mockPlugin);
+    if (isMock) {
+      config.plugins.push(new WarehouseMockPlugin());
     }
-  },
-  
-  devServer: {
-    // Vue CLI 5.x (Webpack 5)
-    setupMiddlewares: (middlewares, devServer) => {
-      if (isMock && mockPlugin) {
-        return mockPlugin.setupMiddlewares(middlewares, devServer);
-      }
-      return middlewares;
-    },
-    
-    // Vue CLI 3.x/4.x (Webpack 4) 使用这个：
-    // before: isMock && mockPlugin ? (app) => mockPlugin.runBefore(app) : undefined,
   }
 };
 ```
 
-### 2. 修改 API 配置
-
-在 `src/const/config.js` 中添加 Mock 模式判断：
-
-```javascript
-const config = { env: process.env.VUE_APP_ENV || 'dev' };
-
-// Mock 模式优先判断
-if (process.env.VUE_APP_MOCK === 'true') {
-  Object.assign(config, {
-    API: '/mock-api',
-  });
-} else if (config.env === 'dev') {
-  Object.assign(config, {
-    API: 'https://fat-api.hellobike.com/api',
-  });
-}
-
-export default config;
-```
-
-### 3. 添加 Mock 脚本
-
-在 `package.json` 中：
+### 2. 添加 Mock 脚本
 
 ```json
 {
@@ -94,114 +43,133 @@ export default config;
 }
 ```
 
-### 4. 创建 Mock 数据
+### 3. 配置 API 切换
 
-创建 `warehouseMock` 目录并添加 Mock 数据文件：
+在 `src/const/config.js` 中：
 
-**warehouseMock/user.account.getInfo.json**:
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "userId": 12345,
-    "userName": "Mock 测试用户"
-  }
+```javascript
+if (process.env.VUE_APP_MOCK === 'true') {
+  config.API = '/mock-api';
+} else {
+  config.API = 'https://your-api.com';
 }
 ```
 
+### 4. 创建 Mock 数据
+
+在项目根目录创建 `warehouseMock/` 文件夹，添加 JSON 文件：
+
+```
+warehouseMock/
+├── user.account.getInfo.json
+└── user.taurus.pointInfo.json
+```
+
 ### 5. 启动
 
 ```bash
 npm run mock
 ```
 
-## ⚙️ 配置选项
+## 配置选项
 
 ```typescript
-new WarehouseMockPlugin({
-  // 必填：Mock 数据存放目录
-  mockPath: string;
+interface MockPluginOptions {
+  // Mock 数据目录，默认 'warehouseMock'
+  mockPath?: string;
   
-  // 可选：需要拦截的 API 路径前缀，默认 ['/api', '/mock-api']
+  // 需要拦截的 API 路径前缀，默认 ['/api', '/mock-api']
   apiPrefixes?: string[];
   
-  // 可选：本地 API 路径前缀，默认 '/mock-api'
+  // 本地代理路径前缀，默认 '/mock-api'
   localApiPrefix?: string;
-})
+  
+  // 是否启用，默认 true
+  enabled?: boolean;
+  
+  // 是否自动注入环境变量 VUE_APP_MOCK，默认 true
+  injectEnv?: boolean;
+  
+  // 响应延迟（毫秒），模拟网络延迟，默认 0
+  delay?: number;
+  
+  // 代理配置：未匹配的请求转发到真实 API
+  proxy?: {
+    target: string;
+    changeOrigin?: boolean;
+  };
+}
 ```
 
-## 📝 Mock 文件命名规则
-
-### RPC 风格（推荐）
-
-| 请求 URL | Mock 文件名 |
-|---------|-----------|
-| `/api?user.account.getInfo` | `user.account.getInfo.json` |
-| `/api?user.taurus.pointInfo` | `user.taurus.pointInfo.json` |
-| `/api?common.welfare.banner.query` | `common.welfare.banner.query.json` |
-
-### RESTful 风格
+## 使用示例
 
-| 请求 URL | Mock 文件名（二选一） |
-|---------|---------------------|
-| `/api/user/info` | `api_user_info.json` (扁平化) |
-| `/api/user/info` | `api/user/info.json` (嵌套) |
+### 基础配置
 
-## 🔍 调试工具
-
-### 查看可用 Mock 列表
-
-访问: `http://localhost:8080/__mock_list__`
-
-### 直接访问 Mock 数据
-
-访问: `http://localhost:8080/mock-api?user.account.getInfo`
+```javascript
+new WarehouseMockPlugin({
+  mockPath: 'warehouseMock',
+  apiPrefixes: ['/api', '/mock-api']
+})
+```
 
-## 💡 为什么选择 warehouse-mock？
+### 代理模式
 
-### 适用场景
+未匹配的请求转发到真实 API：
 
-- ✅ 后端接口未就绪，需要前端先行开发
-- ✅ 后端接口不稳定，需要本地 Mock 数据测试
-- ✅ 需要模拟特殊场景（错误、超时、边界数据等）
-- ✅ 使用 RPC 风格接口的项目（如 hellobike）
+```javascript
+new WarehouseMockPlugin({
+  proxy: {
+    target: 'https://fat-api.hellobike.com',
+    changeOrigin: true
+  }
+})
+```
 
-### 对比其他方案
+### 模拟网络延迟
 
-| 方案 | warehouse-mock | Mock.js | json-server |
-|-----|---------------|---------|-------------|
-| 零代码侵入 | ✅ | ❌ 需修改业务代码 | ❌ 需单独启动服务 |
-| RPC 支持 | ✅ | ❌ | ❌ |
-| 实时更新 | ✅ | ❌ | ✅ |
-| TypeScript | ✅ | ❌ | ❌ |
-| Webpack 集成 | ✅ | ❌ | ❌ |
+```javascript
+new WarehouseMockPlugin({
+  delay: 500  // 500ms 延迟
+})
+```
 
-## 📚 完整示例
+## Mock 文件命名规则
 
-查看完整的示例项目：[example-vue2](https://github.com/CodeMomentYY/warehouse-mock/tree/main/packages/example-vue2)
+### RPC 风格 (推荐)
 
-## ❓ 常见问题
+| 请求 URL | Mock 文件名 |
+|---------|-----------|
+| `GET /api?user.account.getInfo` | `user.account.getInfo.json` |
+| `POST /mock-api?user.taurus.pointInfo` | `user.taurus.pointInfo.json` |
 
-**Q: Mock 没有生效？**
+### RESTful 风格
 
-确保在 `src/const/config.js` 中添加了 Mock 模式判断，将 API 地址改为 `/mock-api`。
+| 请求 URL | Mock 文件名 |
+|---------|-----------|
+| `GET /api/user/info` | `api_user_info.json` (扁平化) |
+| `GET /api/user/info` | `api/user/info.json` (嵌套) |
 
-**Q: 修改 Mock 数据后需要重启服务吗？**
+## 调试工具
 
-不需要！直接刷新浏览器页面即可。
+### 查看可用 Mock 列表
 
-**Q: 可以只 Mock 部分接口吗？**
+访问: `http://localhost:8080/__mock_list__`
 
-可以！只有存在对应 JSON 文件的接口才会使用 Mock 数据。
+### 直接访问 Mock 数据
 
-## 📄 许可证
+访问: `http://localhost:8080/mock-api?user.account.getInfo`
 
-MIT © CodeMomentYY
+## 核心特性
 
-## 🔗 相关链接
+- ✅ **极简配置** - vue.config.js 只需 3 行代码
+- ✅ **零业务侵入** - 无需修改接口调用代码
+- ✅ **RPC 风格支持** - 原生支持 RPC 接口
+- ✅ **实时热更新** - 修改 Mock 数据，刷新即可
+- ✅ **按需拦截** - 只拦截配置了 Mock 文件的接口
+- ✅ **代理模式** - 未匹配请求转发到真实 API
+- ✅ **自动注入环境变量** - 无需手动配置 DefinePlugin
+- ✅ **兼容性强** - 支持 Webpack 4/5，Vue CLI 3/4/5
 
-- [GitHub 仓库](https://github.com/CodeMomentYY/warehouse-mock)
-- [问题反馈](https://github.com/CodeMomentYY/warehouse-mock/issues)
-- [更新日志](https://github.com/CodeMomentYY/warehouse-mock/releases)
+## License
 
+MIT

package/dist/index.d.ts

@@ -1,13 +1,26 @@
 import { Compiler } from 'webpack';
 interface MockPluginOptions {
-    mockPath: string;
+    mockPath?: string;
     apiPrefixes?: string[];
     localApiPrefix?: string;
+    enabled?: boolean;
+    proxy?: {
+        target: string;
+        changeOrigin?: boolean;
+    };
+    injectEnv?: boolean;
+    delay?: number;
+    admin?: {
+        enabled?: boolean;
+        port?: number;
+    };
 }
 declare class WarehouseMockPlugin {
     private options;
     private resolvedMockPath;
-    constructor(options: MockPluginOptions);
+    private isEnabled;
+    private adminServer;
+    constructor(options?: MockPluginOptions);
     /**
      * 实时扫描 mock 目录，获取所有 mock 文件名列表
      */
@@ -17,6 +30,14 @@ declare class WarehouseMockPlugin {
      */
     getLocalApiPrefix(): string;
     apply(compiler: Compiler): void;
+    /**
+     * 启动管理后台服务
+     */
+    private startAdminServer;
+    /**
+     * 自动注入环境变量 VUE_APP_MOCK
+     */
+    private injectEnvironmentVariable;
     /**
      * 公共方法：设置中间件 (Webpack 5 / Vue CLI 5+)
      */
@@ -28,6 +49,11 @@ declare class WarehouseMockPlugin {
     private getResolvedMockPath;
     private ensureMockDirectory;
     private createDemoFile;
+    private readInterfaceConfig;
     private handleRequest;
+    /**
+     * 代理请求到真实 API（改进版）
+     */
+    private proxyRequest;
 }
 export = WarehouseMockPlugin;

package/dist/index.js

@@ -6,9 +6,32 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 class WarehouseMockPlugin {
-    constructor(options) {
+    constructor(options = {}) {
+        var _a, _b;
         this.resolvedMockPath = '';
-        this.options = Object.assign({ apiPrefixes: ['/api', '/mock-api'], localApiPrefix: '/mock-api' }, options);
+        this.isEnabled = true;
+        this.adminServer = null;
+        // 默认配置
+        this.options = {
+            mockPath: options.mockPath || 'warehouseMock',
+            apiPrefixes: options.apiPrefixes || ['/api', '/mock-api'],
+            localApiPrefix: options.localApiPrefix || '/mock-api',
+            enabled: options.enabled !== undefined ? options.enabled : true,
+            proxy: options.proxy || undefined,
+            injectEnv: options.injectEnv !== undefined ? options.injectEnv : true,
+            delay: options.delay || 0,
+            admin: {
+                enabled: ((_a = options.admin) === null || _a === void 0 ? void 0 : _a.enabled) !== undefined ? options.admin.enabled : true,
+                port: ((_b = options.admin) === null || _b === void 0 ? void 0 : _b.port) || 3100,
+            },
+        };
+        // 判断是否启用（支持环境变量控制）
+        if (process.env.MOCK === 'false' || process.env.VUE_APP_MOCK === 'false') {
+            this.isEnabled = false;
+        }
+        if (this.options.enabled === false) {
+            this.isEnabled = false;
+        }
     }
     /**
      * 实时扫描 mock 目录，获取所有 mock 文件名列表
@@ -33,7 +56,16 @@ class WarehouseMockPlugin {
         return this.options.localApiPrefix || '/mock-api';
     }
     apply(compiler) {
+        // 如果未启用，直接返回
+        if (!this.isEnabled) {
+            console.log(chalk_1.default.yellow('[WarehouseMock] Mock 模式未启用'));
+            return;
+        }
         this.resolvedMockPath = path_1.default.resolve(compiler.context, this.options.mockPath);
+        // 自动注入环境变量 VUE_APP_MOCK
+        if (this.options.injectEnv) {
+            this.injectEnvironmentVariable(compiler);
+        }
         // 确保 mock 目录存在
         if (!fs_1.default.existsSync(this.resolvedMockPath)) {
             try {
@@ -46,21 +78,96 @@ class WarehouseMockPlugin {
             }
         }
         const mockFileList = this.getMockFileList();
-        console.log(chalk_1.default.cyan(`[WarehouseMock] 已加载 ${mockFileList.length} 个 mock 文件: ${mockFileList.join(', ')}`));
-        const devServerOptions = compiler.options.devServer || {};
-        const originalSetupMiddlewares = devServerOptions.setupMiddlewares;
-        if (!compiler.options.devServer) {
-            compiler.options.devServer = {};
-        }
-        // 适用于 Webpack 5 (setupMiddlewares)
-        compiler.options.devServer.setupMiddlewares = (middlewares, devServer) => {
-            return this.setupMiddlewares(middlewares, devServer, originalSetupMiddlewares);
-        };
-        // 适用于 Webpack 4 (before)
-        const originalBefore = devServerOptions.before;
-        compiler.options.devServer.before = (app, server, compilerArg) => {
-            this.runBefore(app, server, compilerArg, originalBefore);
-        };
+        console.log(chalk_1.default.cyan(`[WarehouseMock] 已加载 ${mockFileList.length} 个 mock 文件`));
+        if (mockFileList.length > 0) {
+            console.log(chalk_1.default.gray(`  → ${mockFileList.join(', ')}`));
+        }
+        if (this.options.proxy) {
+            console.log(chalk_1.default.cyan(`[WarehouseMock] 代理模式: 未匹配请求 → ${this.options.proxy.target}`));
+        }
+        // 启动管理后台
+        if (this.options.admin && this.options.admin.enabled) {
+            this.startAdminServer();
+        }
+        // 注意：devServer 的配置需要在 vue.config.js 中手动配置
+        // 对于 Webpack 5 使用 setupMiddlewares
+        // 对于 Webpack 4 使用 before
+    }
+    /**
+     * 启动管理后台服务
+     */
+    startAdminServer() {
+        var _a;
+        try {
+            // 动态导入管理后台服务
+            let createAdminServer;
+            try {
+                // 尝试导入已安装的包
+                createAdminServer = require('warehouse-mock-admin').createAdminServer;
+            }
+            catch (e) {
+                // 如果找不到，尝试相对路径（开发环境）
+                const adminPath = require('path').resolve(__dirname, '../../mock-admin/dist/server/index.js');
+                createAdminServer = require(adminPath).createAdminServer;
+            }
+            if (!createAdminServer) {
+                throw new Error('无法加载管理后台模块');
+            }
+            const adminResult = createAdminServer({
+                mockPath: this.resolvedMockPath,
+                port: ((_a = this.options.admin) === null || _a === void 0 ? void 0 : _a.port) || 3100,
+            });
+            this.adminServer = adminResult;
+            console.log(chalk_1.default.green(`\n╭────────────────────────────────────────────────────╮`));
+            console.log(chalk_1.default.green(`│  🎨 Mock 数据管理后台已启动                          │`));
+            console.log(chalk_1.default.green(`│                                                    │`));
+            console.log(chalk_1.default.green(`│  ➜  访问地址: ${chalk_1.default.cyan(adminResult.url).padEnd(31)} │`));
+            console.log(chalk_1.default.green(`│                                                    │`));
+            console.log(chalk_1.default.green(`│  在浏览器中打开上面的地址来管理 Mock 数据            │`));
+            console.log(chalk_1.default.green(`╰────────────────────────────────────────────────────╯\n`));
+        }
+        catch (err) {
+            console.log(chalk_1.default.yellow('[WarehouseMock] 管理后台包未安装或加载失败，跳过启动'));
+            console.log(chalk_1.default.gray('  提示：运行 npm install warehouse-mock-admin 来安装管理后台'));
+            if (err.message && !err.message.includes('Cannot find module')) {
+                console.log(chalk_1.default.gray(`  错误详情: ${err.message}`));
+            }
+        }
+    }
+    /**
+     * 自动注入环境变量 VUE_APP_MOCK
+     */
+    injectEnvironmentVariable(compiler) {
+        try {
+            // 使用 compiler 的 webpack 实例
+            const { webpack } = compiler;
+            if (webpack && webpack.DefinePlugin) {
+                const definePlugin = new webpack.DefinePlugin({
+                    'process.env.VUE_APP_MOCK': JSON.stringify('true'),
+                });
+                if (!compiler.options.plugins) {
+                    compiler.options.plugins = [];
+                }
+                compiler.options.plugins.push(definePlugin);
+                console.log(chalk_1.default.gray('[WarehouseMock] 已注入环境变量: VUE_APP_MOCK=true'));
+            }
+            else {
+                // 备用方案：直接require webpack
+                const webpackModule = require('webpack');
+                const definePlugin = new webpackModule.DefinePlugin({
+                    'process.env.VUE_APP_MOCK': JSON.stringify('true'),
+                });
+                if (!compiler.options.plugins) {
+                    compiler.options.plugins = [];
+                }
+                compiler.options.plugins.push(definePlugin);
+                console.log(chalk_1.default.gray('[WarehouseMock] 已注入环境变量: VUE_APP_MOCK=true'));
+            }
+        }
+        catch (err) {
+            console.error(chalk_1.default.red(`[WarehouseMock] 注入环境变量失败: ${err}`));
+            console.log(chalk_1.default.yellow('[WarehouseMock] 请在 vue.config.js 中手动配置 DefinePlugin'));
+        }
     }
     /**
      * 公共方法：设置中间件 (Webpack 5 / Vue CLI 5+)
@@ -130,8 +237,22 @@ class WarehouseMockPlugin {
             console.error(chalk_1.default.yellow(`[WarehouseMock] 创建示例文件失败: ${e}`));
         }
     }
+    // 读取接口配置
+    readInterfaceConfig(apiName, mockPath) {
+        const configPath = path_1.default.join(mockPath, apiName, '.config.json');
+        if (fs_1.default.existsSync(configPath)) {
+            try {
+                const content = fs_1.default.readFileSync(configPath, 'utf-8');
+                return JSON.parse(content);
+            }
+            catch (e) {
+                return null;
+            }
+        }
+        return null;
+    }
     handleRequest(req, res, next, mockPath) {
-        var _a, _b;
+        var _a, _b, _c;
         const url = req.path || ((_a = req.url) === null || _a === void 0 ? void 0 : _a.split('?')[0]);
         if (!url) {
             return next();
@@ -144,6 +265,8 @@ class WarehouseMockPlugin {
             res.end(JSON.stringify({
                 mockList: fileList,
                 localApiPrefix: this.getLocalApiPrefix(),
+                proxy: ((_b = this.options.proxy) === null || _b === void 0 ? void 0 : _b.target) || null,
+                enabled: this.isEnabled,
             }));
             return;
         }
@@ -153,38 +276,132 @@ class WarehouseMockPlugin {
         }
         // 检查是否在允许的 API 前缀范围内
         const { apiPrefixes } = this.options;
-        const isApiRequest = (_b = apiPrefixes === null || apiPrefixes === void 0 ? void 0 : apiPrefixes.some((prefix) => url.startsWith(prefix))) !== null && _b !== void 0 ? _b : true;
+        const isApiRequest = (_c = apiPrefixes === null || apiPrefixes === void 0 ? void 0 : apiPrefixes.some((prefix) => url.startsWith(prefix))) !== null && _c !== void 0 ? _c : true;
         if (!isApiRequest) {
             return next();
         }
         let filePath = '';
         let matched = false;
         let matchedName = '';
+        let interfaceConfig = null;
         // 1. 优先尝试 Query String 匹配 (RPC 风格接口，如 /api?user.taurus.pointInfo)
         if (req.url && req.url.includes('?')) {
             const queryPart = req.url.split('?')[1];
             if (queryPart) {
                 const params = new URLSearchParams(queryPart);
                 for (const key of params.keys()) {
-                    // 尝试匹配 key.json (例如 user.taurus.pointInfo.json)
-                    const queryFilePath = path_1.default.join(mockPath, `${key}.json`);
-                    if (fs_1.default.existsSync(queryFilePath) && fs_1.default.statSync(queryFilePath).isFile()) {
-                        filePath = queryFilePath;
-                        matchedName = key;
-                        matched = true;
-                        break;
+                    // 先尝试目录模式（优先，支持多场景）
+                    const dirPath = path_1.default.join(mockPath, key);
+                    if (fs_1.default.existsSync(dirPath) && fs_1.default.statSync(dirPath).isDirectory()) {
+                        // 读取接口配置（新格式）
+                        const config = this.readInterfaceConfig(key, mockPath);
+                        if (config) {
+                            // 新格式：检查是否启用
+                            if (config.enabled === false) {
+                                console.log(chalk_1.default.yellow(`[WarehouseMock] ✗ 接口已禁用: ${key}`));
+                                break; // 接口被禁用，不拦截
+                            }
+                            // 根据 activeScene 读取场景文件
+                            const activeScene = config.activeScene || 'default';
+                            const sceneFilePath = path_1.default.join(dirPath, `${activeScene}.json`);
+                            if (fs_1.default.existsSync(sceneFilePath)) {
+                                filePath = sceneFilePath;
+                                matchedName = key;
+                                matched = true;
+                                interfaceConfig = config;
+                                break;
+                            }
+                        }
+                        else {
+                            // 旧格式：查找 mock: true 的文件（向后兼容）
+                            const files = fs_1.default.readdirSync(dirPath).filter(f => f.endsWith('.json') && f !== '.config.json');
+                            for (const file of files) {
+                                const fullPath = path_1.default.join(dirPath, file);
+                                try {
+                                    const content = fs_1.default.readFileSync(fullPath, 'utf-8');
+                                    const jsonData = JSON.parse(content);
+                                    if (jsonData.mock === true) {
+                                        filePath = fullPath;
+                                        matchedName = key;
+                                        matched = true;
+                                        break;
+                                    }
+                                }
+                                catch (e) {
+                                    // 文件解析失败，跳过
+                                }
+                            }
+                            if (matched)
+                                break;
+                        }
                     }
-                    // 也尝试匹配 value (例如 method=user.taurus.pointInfo)
-                    const value = params.get(key);
-                    if (value) {
-                        const valueFilePath = path_1.default.join(mockPath, `${value}.json`);
-                        if (fs_1.default.existsSync(valueFilePath) && fs_1.default.statSync(valueFilePath).isFile()) {
-                            filePath = valueFilePath;
-                            matchedName = value;
+                    // 再尝试单文件模式（向后兼容）
+                    if (!matched) {
+                        const queryFilePath = path_1.default.join(mockPath, `${key}.json`);
+                        if (fs_1.default.existsSync(queryFilePath) && fs_1.default.statSync(queryFilePath).isFile()) {
+                            filePath = queryFilePath;
+                            matchedName = key;
                             matched = true;
                             break;
                         }
                     }
+                    // 也尝试匹配 value (例如 method=user.taurus.pointInfo)
+                    const value = params.get(key);
+                    if (value && !matched) {
+                        const valueDirPath = path_1.default.join(mockPath, value);
+                        if (fs_1.default.existsSync(valueDirPath) && fs_1.default.statSync(valueDirPath).isDirectory()) {
+                            // 读取接口配置（新格式）
+                            const config = this.readInterfaceConfig(value, mockPath);
+                            if (config) {
+                                // 新格式：检查是否启用
+                                if (config.enabled === false) {
+                                    console.log(chalk_1.default.yellow(`[WarehouseMock] ✗ 接口已禁用: ${value}`));
+                                    break;
+                                }
+                                // 根据 activeScene 读取场景文件
+                                const activeScene = config.activeScene || 'default';
+                                const sceneFilePath = path_1.default.join(valueDirPath, `${activeScene}.json`);
+                                if (fs_1.default.existsSync(sceneFilePath)) {
+                                    filePath = sceneFilePath;
+                                    matchedName = value;
+                                    matched = true;
+                                    interfaceConfig = config;
+                                    break;
+                                }
+                            }
+                            else {
+                                // 旧格式：查找 mock: true 的文件（向后兼容）
+                                const files = fs_1.default.readdirSync(valueDirPath).filter(f => f.endsWith('.json') && f !== '.config.json');
+                                for (const file of files) {
+                                    const fullPath = path_1.default.join(valueDirPath, file);
+                                    try {
+                                        const content = fs_1.default.readFileSync(fullPath, 'utf-8');
+                                        const jsonData = JSON.parse(content);
+                                        if (jsonData.mock === true) {
+                                            filePath = fullPath;
+                                            matchedName = value;
+                                            matched = true;
+                                            break;
+                                        }
+                                    }
+                                    catch (e) {
+                                        // 跳过
+                                    }
+                                }
+                                if (matched)
+                                    break;
+                            }
+                        }
+                        if (!matched) {
+                            const valueFilePath = path_1.default.join(mockPath, `${value}.json`);
+                            if (fs_1.default.existsSync(valueFilePath) && fs_1.default.statSync(valueFilePath).isFile()) {
+                                filePath = valueFilePath;
+                                matchedName = value;
+                                matched = true;
+                                break;
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -216,29 +433,160 @@ class WarehouseMockPlugin {
             }
         }
         if (matched) {
-            console.log(chalk_1.default.green(`[WarehouseMock] 拦截: ${matchedName} -> ${path_1.default.basename(filePath)}`));
-            try {
-                const data = fs_1.default.readFileSync(filePath, 'utf-8');
+            console.log(chalk_1.default.green(`[WarehouseMock] ✓ 拦截: ${req.url || url}`));
+            // 获取延时配置（优先使用接口级别的 delay）
+            const delayTime = (interfaceConfig === null || interfaceConfig === void 0 ? void 0 : interfaceConfig.delay) !== undefined
+                ? interfaceConfig.delay
+                : this.options.delay || 0;
+            // 获取场景名称
+            const sceneName = (interfaceConfig === null || interfaceConfig === void 0 ? void 0 : interfaceConfig.activeScene) || path_1.default.basename(filePath, '.json');
+            console.log(chalk_1.default.gray(`  → 场景: ${sceneName}`));
+            if (delayTime > 0) {
+                console.log(chalk_1.default.gray(`  → 延迟: ${delayTime}ms`));
+            }
+            // 模拟网络延迟
+            const respond = () => {
                 try {
-                    const jsonData = JSON.parse(data);
+                    const fileContent = fs_1.default.readFileSync(filePath, 'utf-8');
+                    try {
+                        const jsonData = JSON.parse(fileContent);
+                        // 新格式：纯净的场景数据（不包含 mock、scene、delay 等元数据）
+                        // 旧格式：包含 mock、scene、delay、data 字段
+                        let responseData = jsonData;
+                        // 兼容旧格式
+                        if (jsonData.mock !== undefined && jsonData.data !== undefined) {
+                            responseData = jsonData.data;
+                        }
+                        res.setHeader('Content-Type', 'application/json');
+                        res.setHeader('X-Mock-By', 'WarehouseMock');
+                        res.setHeader('X-Mock-Scene', sceneName);
+                        res.end(JSON.stringify(responseData));
+                    }
+                    catch (jsonErr) {
+                        console.warn(chalk_1.default.yellow(`[WarehouseMock] 无效的 JSON 文件: ${filePath}`));
+                        res.setHeader('Content-Type', 'text/plain');
+                        res.end(fileContent);
+                    }
+                }
+                catch (e) {
+                    console.error(chalk_1.default.red(`[WarehouseMock] 读取 Mock 文件失败: ${e}`));
+                    res.statusCode = 500;
+                    res.end('Mock Read Error');
+                }
+            };
+            // 应用延迟
+            if (delayTime > 0) {
+                setTimeout(respond, delayTime);
+            }
+            else {
+                respond();
+            }
+            return;
+        }
+        // 未匹配到 Mock 文件
+        if (this.options.proxy) {
+            // 如果配置了代理，转发到真实 API
+            console.log(chalk_1.default.gray(`[WarehouseMock] ⊳ 代理: ${req.url || url} → ${this.options.proxy.target}`));
+            this.proxyRequest(req, res, next);
+        }
+        else {
+            // 未配置代理，直接放行
+            next();
+        }
+    }
+    /**
+     * 代理请求到真实 API（改进版）
+     */
+    proxyRequest(req, res, next) {
+        if (!this.options.proxy) {
+            return next();
+        }
+        try {
+            const http = require('http');
+            const https = require('https');
+            const url = require('url');
+            // 构建完整的目标 URL
+            // 将 /mock-api?xxx 转换为 真实API/api?xxx
+            const targetUrl = this.options.proxy.target + req.url.replace('/mock-api', '/api');
+            const parsedUrl = url.parse(targetUrl);
+            const isHttps = parsedUrl.protocol === 'https:';
+            const lib = isHttps ? https : http;
+            // 清理请求头
+            const headers = Object.assign({}, req.headers);
+            delete headers.host;
+            headers.host = parsedUrl.hostname;
+            // 创建代理请求
+            const proxyReq = lib.request({
+                hostname: parsedUrl.hostname,
+                port: parsedUrl.port || (isHttps ? 443 : 80),
+                path: parsedUrl.path,
+                method: req.method,
+                headers: headers,
+                timeout: 30000, // 30秒超时
+            }, (proxyRes) => {
+                // 转发响应头
+                res.writeHead(proxyRes.statusCode, proxyRes.headers);
+                // 转发响应体
+                proxyRes.pipe(res);
+            });
+            // 错误处理
+            proxyReq.on('error', (err) => {
+                console.error(chalk_1.default.red(`[WarehouseMock] 代理请求失败: ${err.message}`));
+                console.error(chalk_1.default.red(`  目标地址: ${targetUrl}`));
+                // 返回友好的错误信息
+                if (!res.headersSent) {
+                    res.statusCode = 502;
                     res.setHeader('Content-Type', 'application/json');
-                    res.end(JSON.stringify(jsonData));
+                    res.end(JSON.stringify({
+                        code: -1,
+                        msg: `代理请求失败: ${err.message}`,
+                        error: 'PROXY_ERROR'
+                    }));
                 }
-                catch (jsonErr) {
-                    console.warn(chalk_1.default.yellow(`[WarehouseMock] 无效的 JSON 文件: ${filePath}`));
-                    res.setHeader('Content-Type', 'text/plain');
-                    res.end(data);
+            });
+            // 超时处理
+            proxyReq.on('timeout', () => {
+                proxyReq.destroy();
+                if (!res.headersSent) {
+                    res.statusCode = 504;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({
+                        code: -1,
+                        msg: '代理请求超时',
+                        error: 'PROXY_TIMEOUT'
+                    }));
                 }
-                return;
+            });
+            // 转发请求体
+            if (req.method === 'POST' || req.method === 'PUT') {
+                // 处理 POST/PUT 请求的 body
+                let body = '';
+                req.on('data', (chunk) => {
+                    body += chunk.toString();
+                });
+                req.on('end', () => {
+                    if (body) {
+                        proxyReq.write(body);
+                    }
+                    proxyReq.end();
+                });
             }
-            catch (e) {
-                console.error(chalk_1.default.red(`[WarehouseMock] 读取 Mock 文件失败: ${e}`));
+            else {
+                proxyReq.end();
+            }
+        }
+        catch (err) {
+            console.error(chalk_1.default.red(`[WarehouseMock] 代理配置错误: ${err}`));
+            if (!res.headersSent) {
                 res.statusCode = 500;
-                res.end('Mock Read Error');
-                return;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({
+                    code: -1,
+                    msg: `代理配置错误: ${err}`,
+                    error: 'PROXY_CONFIG_ERROR'
+                }));
             }
         }
-        next();
     }
 }
 module.exports = WarehouseMockPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "warehouse-mock",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "一个专为 Vue 2 项目设计的 Webpack 插件，支持 RPC 风格接口 mock，零业务代码侵入，实时更新",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,13 +38,16 @@
     "chalk": "^4.1.2",
     "chokidar": "^3.5.3"
   },
+  "optionalDependencies": {
+    "warehouse-mock-admin": "^1.0.0"
+  },
   "devDependencies": {
-    "typescript": "^5.0.0",
-    "webpack": "^5.0.0",
-    "webpack-dev-server": "^4.0.0",
+    "@types/node": "^18.0.0",
     "@types/webpack": "^5.0.0",
     "@types/webpack-dev-server": "^4.0.0",
-    "@types/node": "^18.0.0"
+    "typescript": "^5.0.0",
+    "webpack": "^5.0.0",
+    "webpack-dev-server": "^4.0.0"
   },
   "peerDependencies": {
     "webpack": "^4.0.0 || ^5.0.0"
@@ -53,4 +56,3 @@
     "node": ">=12.0.0"
   }
 }
-