json-api-mocker 3.0.0 → 3.1.0

package/dist/server.d.ts

@@ -1,21 +1,24 @@
-import type { Config } from './types';
-export declare class MockServer {
-    private app;
-    private configPath;
-    private config;
-    private serverConfig;
-    private logs;
-    private readonly MAX_LOGS;
-    private upload;
-    private wss;
-    private clients;
-    constructor(serverConfig?: Config, configPath?: string);
-    private loadConfig;
-    private saveConfig;
-    private setupConfigRoutes;
-    private setupMockRoutes;
-    private sendResponse;
-    private setupUploadRoute;
-    start(port?: number): void;
-    private broadcastLog;
-}
+import { Express } from 'express';
+import { Config } from './types';
+export declare class MockServer {
+    private app;
+    private server;
+    private wss;
+    private config;
+    private configPath;
+    constructor(config: Config, configPath?: string);
+    getApp(): Express;
+    private setupMiddleware;
+    private logRequest;
+    private generateMockData;
+    private handleRequest;
+    private setupAdminRoutes;
+    private getAdminHtml;
+    private setupRoutes;
+    private createRoute;
+    private findRouteConfig;
+    private generateMockResponse;
+    private setupWebSocket;
+    start(): void;
+    close(): void;
+}

package/dist/server.js

@@ -1,328 +1,260 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockServer = void 0;
-const express_1 = __importDefault(require("express"));
-const cors_1 = __importDefault(require("cors"));
-const fs_1 = require("fs");
-const path_1 = require("path");
-const uuid_1 = require("uuid");
-const mockjs_1 = __importDefault(require("mockjs"));
-const multer_1 = __importDefault(require("multer"));
-const ws_1 = require("ws");
-class MockServer {
-    constructor(serverConfig = {}, configPath = 'data.json') {
-        this.logs = []; // 存储请求日志
-        this.MAX_LOGS = 1000; // 最大日志数量
-        this.clients = new Set();
-        this.app = (0, express_1.default)();
-        this.serverConfig = serverConfig;
-        this.configPath = (0, path_1.join)(process.cwd(), configPath);
-        this.config = this.loadConfig();
-        // 添加跨域支持
-        this.app.use((0, cors_1.default)());
-        this.app.use(express_1.default.json());
-        // 注意：先设置配置管理接口，再设置mock接口
-        this.setupConfigRoutes();
-        this.setupMockRoutes();
-        // 使用内存存储
-        this.upload = (0, multer_1.default)({
-            storage: multer_1.default.memoryStorage()
-        });
-        // 添加文件上传路由
-        this.setupUploadRoute();
-        // 使用固定的 WebSocket 端口
-        this.wss = new ws_1.WebSocketServer({ port: serverConfig.wsPort || 88866 });
-        this.wss.on('connection', (ws) => {
-            this.clients.add(ws);
-            ws.send(JSON.stringify({
-                type: 'init',
-                data: this.logs
-            }));
-            ws.on('close', () => {
-                this.clients.delete(ws);
-            });
-        });
-    }
-    loadConfig() {
-        try {
-            const data = (0, fs_1.readFileSync)(this.configPath, 'utf-8');
-            const fullConfig = JSON.parse(data);
-            // 确保返回的是数组
-            const routes = fullConfig.routes || [];
-            // 验每个配置项
-            return routes.filter(api => {
-                const isValid = api &&
-                    api.id &&
-                    api.route &&
-                    typeof api.route.path === 'string' &&
-                    api.route.methods &&
-                    typeof api.route.methods === 'object';
-                if (!isValid) {
-                    console.warn('Filtered out invalid API config:', api);
-                }
-                return isValid;
-            });
-        }
-        catch (error) {
-            console.error('Error loading config:', error);
-            return [];
-        }
-    }
-    saveConfig() {
-        try {
-            const data = (0, fs_1.readFileSync)(this.configPath, 'utf-8');
-            const fullConfig = JSON.parse(data);
-            // 处理每个 API 的响应数据
-            const processedRoutes = this.config.map(api => ({
-                ...api,
-                route: {
-                    ...api.route,
-                    methods: Object.entries(api.route.methods).reduce((acc, [method, config]) => ({
-                        ...acc,
-                        [method]: {
-                            ...config,
-                            // 解析并重新格式化 JSON，移除多余的转义
-                            response: typeof config.response === 'string'
-                                ? JSON.stringify(JSON.parse(config.response))
-                                : JSON.stringify(config.response),
-                            headers: config.headers || {}
-                        }
-                    }), {})
-                }
-            }));
-            fullConfig.routes = processedRoutes;
-            (0, fs_1.writeFileSync)(this.configPath, JSON.stringify(fullConfig, null, 2));
-        }
-        catch (error) {
-            console.error('Error saving config:', error);
-        }
-    }
-    setupConfigRoutes() {
-        const baseProxy = this.serverConfig.baseProxy || '';
-        // 获取所有API配置
-        this.app.get('/api/_config', (req, res) => {
-            console.log('Sending config:', this.config);
-            res.json(this.config);
-        });
-        // 创建新API配置
-        this.app.post('/api/_config', (req, res) => {
-            const newApi = {
-                id: (0, uuid_1.v4)(),
-                route: req.body.route
-            };
-            this.config.push(newApi);
-            this.saveConfig();
-            res.json(newApi);
-        });
-        // 更新API配置
-        this.app.put('/api/_config/:id', (req, res) => {
-            const index = this.config.findIndex(api => api.id === req.params.id);
-            if (index === -1) {
-                res.status(404).json({ error: 'API not found' });
-                return;
-            }
-            this.config[index] = {
-                id: req.params.id,
-                route: req.body.route
-            };
-            this.saveConfig();
-            res.json(this.config[index]);
-        });
-        // 删除API配置
-        this.app.delete('/api/_config/:id', (req, res) => {
-            const index = this.config.findIndex(api => api.id === req.params.id);
-            if (index === -1) {
-                res.status(404).json({ error: 'API not found' });
-                return;
-            }
-            this.config.splice(index, 1);
-            this.saveConfig();
-            res.status(204).send();
-        });
-        // 添加日志接口
-        this.app.get('/api/_logs', (req, res) => {
-            const { page = 1, size = 20 } = req.query;
-            const start = (Number(page) - 1) * Number(size);
-            const end = start + Number(size);
-            const total = this.logs.length;
-            res.json({
-                total,
-                list: this.logs.slice(start, end)
-            });
-        });
-        // 清除日志
-        this.app.delete('/api/_logs', (req, res) => {
-            this.logs = [];
-            res.status(204).send();
-        });
-    }
-    setupMockRoutes() {
-        const baseProxy = this.serverConfig.baseProxy || '';
-        this.app.all('*', (req, res, next) => {
-            // 如果是配置接口，跳过日志记录
-            if (req.path === '/api/_config' || req.path.startsWith('/api/_config/') ||
-                req.path === '/api/_logs' || req.path.startsWith('/api/_logs/')) {
-                return next();
-            }
-            const startTime = Date.now();
-            const originalSend = res.send;
-            // 修复 this 指向问题
-            const self = this;
-            // 记录请求日志
-            res.send = function (body) {
-                const endTime = Date.now();
-                const duration = endTime - startTime;
-                const log = {
-                    id: (0, uuid_1.v4)(),
-                    path: req.path,
-                    method: req.method,
-                    timestamp: new Date().toISOString(),
-                    status: res.statusCode,
-                    duration,
-                    params: {
-                        query: req.query,
-                        body: req.body,
-                        params: req.params
-                    },
-                    requestBody: req.body,
-                    responseBody: body
-                };
-                // 使用正确的 this 引用
-                self.logs.unshift(log);
-                if (self.logs.length > self.MAX_LOGS) {
-                    self.logs.pop();
-                }
-                // 广播新日志
-                self.broadcastLog(log);
-                return originalSend.call(this, body);
-            };
-            next();
-        });
-        // 处理所有mock请求，但排除配置接口
-        this.app.all('*', (req, res, next) => {
-            try {
-                // 如果是配置接口，跳过这个中间件
-                if (req.path === '/api/_config' || req.path.startsWith('/api/_config/')) {
-                    return next();
-                }
-                console.log('Received request for path:', req.path);
-                console.log('Current config:', this.config);
-                if (!Array.isArray(this.config)) {
-                    console.error('Config is not an array:', this.config);
-                    res.status(500).json({ error: 'Internal server error' });
-                    return;
-                }
-                const api = this.config.find(api => {
-                    if (!api || !api.route || typeof api.route.path !== 'string') {
-                        console.error('Invalid API config:', api);
-                        return false;
-                    }
-                    // 移除 baseProxy 前缀再比较
-                    const requestPath = req.path.replace(baseProxy, '');
-                    return api.route.path === requestPath;
-                });
-                if (!api) {
-                    res.status(404).json({ error: 'API not found' });
-                    return;
-                }
-                if (!api.route || !api.route.methods) {
-                    res.status(500).json({ error: 'Invalid API configuration' });
-                    return;
-                }
-                const method = req.method.toLowerCase();
-                const methodConfig = api.route.methods[method];
-                if (!methodConfig) {
-                    res.status(405).json({ error: 'Method not allowed' });
-                    return;
-                }
-                if (methodConfig.delay) {
-                    setTimeout(() => {
-                        this.sendResponse(res, methodConfig);
-                    }, methodConfig.delay);
-                }
-                else {
-                    this.sendResponse(res, methodConfig);
-                }
-            }
-            catch (error) {
-                console.error('Error handling request:', error);
-                res.status(500).json({ error: 'Internal server error' });
-            }
-        });
-    }
-    sendResponse(res, config) {
-        try {
-            // 设置响应头
-            if (config.headers) {
-                Object.entries(config.headers).forEach(([key, value]) => {
-                    res.setHeader(key, value);
-                });
-            }
-            // 处理响应数据
-            let responseData = config.response;
-            if (typeof responseData === 'string') {
-                try {
-                    responseData = JSON.parse(responseData);
-                }
-                catch (e) {
-                    console.error('Failed to parse response string:', e);
-                    responseData = { error: 'Invalid response format' };
-                }
-            }
-            // 使用 Mock.js 处理数据
-            const mockedData = mockjs_1.default.mock(responseData);
-            res.status(config.status || 200).json(mockedData);
-        }
-        catch (error) {
-            console.error('Error processing response:', error);
-            res.status(500).json({
-                error: 'Internal server error',
-                details: error instanceof Error ? error.message : 'Unknown error'
-            });
-        }
-    }
-    setupUploadRoute() {
-        // 处理文件上传
-        this.app.post('/api/upload', this.upload.single('file'), (req, res) => {
-            if (!req.file) {
-                return res.status(400).json({
-                    code: 400,
-                    message: 'No file uploaded',
-                    data: null
-                });
-            }
-            // 只返回模拟数据，不保存文件
-            res.json({
-                code: 200,
-                message: 'success',
-                data: {
-                    url: mockjs_1.default.Random.image('200x200'),
-                    filename: req.file.originalname,
-                    size: req.file.size
-                }
-            });
-        });
-    }
-    start(port) {
-        const serverPort = port || this.serverConfig.port || 3000;
-        this.app.listen(serverPort, () => {
-            console.log(`Mock server is running on http://localhost:${serverPort}`);
-        });
-    }
-    // 广播日志给所有客户端
-    broadcastLog(log) {
-        const message = JSON.stringify({
-            type: 'log',
-            data: log
-        });
-        this.clients.forEach(client => {
-            if (client.readyState === ws_1.WebSocket.OPEN) {
-                client.send(message);
-            }
-        });
-    }
-}
-exports.MockServer = MockServer;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockServer = void 0;
+const mockjs_1 = __importDefault(require("mockjs"));
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const ws_1 = require("ws");
+const http_1 = __importDefault(require("http"));
+class MockServer {
+    constructor(config, configPath = 'data.json') {
+        this.app = (0, express_1.default)();
+        this.wss = null;
+        this.logRequest = (req, res, next) => {
+            const startTime = Date.now();
+            const requestId = Math.random().toString(36).substring(7);
+            console.log(`[${new Date().toISOString()}] Request ${requestId}:`);
+            console.log(`  Method: ${req.method}`);
+            console.log(`  URL: ${req.url}`);
+            console.log(`  Query Params: ${JSON.stringify(req.query)}`);
+            console.log(`  Body: ${JSON.stringify(req.body)}`);
+            res.on('finish', () => {
+                const duration = Date.now() - startTime;
+                console.log(`[${new Date().toISOString()}] Response ${requestId}:`);
+                console.log(`  Status: ${res.statusCode}`);
+                console.log(`  Duration: ${duration}ms`);
+                console.log('----------------------------------------');
+            });
+            next();
+        };
+        this.config = config;
+        this.configPath = configPath;
+        this.server = http_1.default.createServer(this.app);
+        this.setupMiddleware();
+        this.setupAdminRoutes();
+        this.setupRoutes();
+        if (config.websocket?.enabled) {
+            this.setupWebSocket();
+        }
+    }
+    getApp() {
+        return this.app;
+    }
+    setupMiddleware() {
+        this.app.use((0, cors_1.default)());
+        this.app.use(express_1.default.json());
+        this.app.use('/uploads', express_1.default.static('uploads'));
+        this.app.use(this.logRequest);
+    }
+    generateMockData(config) {
+        try {
+            if (config.mock?.enabled && config.mock.template) {
+                const { total, template } = config.mock;
+                return mockjs_1.default.mock({
+                    [`data|${total}`]: [template]
+                }).data;
+            }
+            return config.response;
+        }
+        catch (error) {
+            console.error('Error generating mock data:', error);
+            return config.response;
+        }
+    }
+    handleRequest(config) {
+        return (req, res) => {
+            try {
+                let responseData = this.generateMockData(config);
+                if (config.pagination?.enabled && Array.isArray(responseData)) {
+                    const page = parseInt(req.query.page) || 1;
+                    const pageSize = parseInt(req.query.pageSize) || config.pagination.pageSize;
+                    const startIndex = (page - 1) * pageSize;
+                    const endIndex = startIndex + pageSize;
+                    const paginatedData = responseData.slice(startIndex, endIndex);
+                    res.header('X-Total-Count', responseData.length.toString());
+                    responseData = paginatedData;
+                }
+                res.json(responseData);
+            }
+            catch (error) {
+                console.error('Error handling request:', error);
+                res.status(500).json({ error: 'Internal server error' });
+            }
+        };
+    }
+    setupAdminRoutes() {
+        // 管理后台页面
+        this.app.get('/admin', (req, res) => {
+            const html = this.getAdminHtml();
+            if (html) {
+                res.type('html').send(html);
+            }
+            else {
+                res.status(404).send('Admin page not found');
+            }
+        });
+        // 获取当前配置
+        this.app.get('/admin/api/config', (req, res) => {
+            res.json(this.config);
+        });
+        // 保存配置
+        this.app.put('/admin/api/config', (req, res) => {
+            try {
+                const newConfig = req.body;
+                // 简单校验
+                if (!newConfig.server || !newConfig.routes) {
+                    res.status(400).json({ success: false, error: '配置格式不正确:缺少 server 或 routes' });
+                    return;
+                }
+                // 写入文件
+                const fullPath = path_1.default.resolve(process.cwd(), this.configPath);
+                fs_1.default.writeFileSync(fullPath, JSON.stringify(newConfig, null, 2), 'utf-8');
+                // 更新内存中的配置
+                this.config = newConfig;
+                console.log(`配置已保存到: ${fullPath}`);
+                res.json({ success: true, message: '配置已保存,部分改动(如新增路由)需重启服务生效' });
+            }
+            catch (error) {
+                console.error('保存配置失败:', error);
+                res.status(500).json({ success: false, error: error.message });
+            }
+        });
+    }
+    getAdminHtml() {
+        const candidates = [
+            path_1.default.join(__dirname, 'public', 'admin.html'),
+            path_1.default.join(__dirname, '..', 'public', 'admin.html'),
+            path_1.default.join(process.cwd(), 'public', 'admin.html'),
+        ];
+        for (const p of candidates) {
+            if (fs_1.default.existsSync(p)) {
+                return fs_1.default.readFileSync(p, 'utf-8');
+            }
+        }
+        return null;
+    }
+    setupRoutes() {
+        this.config.routes.forEach((route) => {
+            Object.entries(route.methods).forEach(([method, methodConfig]) => {
+                this.createRoute(route.path, method, methodConfig);
+            });
+        });
+    }
+    createRoute(path, method, config) {
+        const fullPath = `${this.config.server.baseProxy}${path}`;
+        console.log(`创建路由: ${method.toUpperCase()} ${fullPath}`);
+        switch (method.toLowerCase()) {
+            case 'get':
+                this.app.get(fullPath, this.handleRequest(config));
+                break;
+            case 'post':
+                if (path === '/upload/avatar') {
+                    // 对于文件上传路由，使用特殊处理
+                    this.app.post(fullPath, (req, res) => {
+                        const mockResponse = this.generateMockData(config);
+                        res.json(mockResponse);
+                    });
+                }
+                else {
+                    this.app.post(fullPath, this.handleRequest(config));
+                }
+                break;
+            case 'put':
+                this.app.put(`${fullPath}/:id`, this.handleRequest(config));
+                break;
+            case 'delete':
+                this.app.delete(`${fullPath}/:id`, this.handleRequest(config));
+                break;
+        }
+    }
+    findRouteConfig(path, method) {
+        const route = this.config.routes.find(r => r.path === path);
+        return route?.methods[method] || null;
+    }
+    generateMockResponse(config) {
+        if (config.mock?.enabled && config.mock.template) {
+            return mockjs_1.default.mock(config.mock.template);
+        }
+        return config.response;
+    }
+    setupWebSocket() {
+        if (!this.config.websocket)
+            return;
+        this.wss = new ws_1.Server({
+            server: this.server,
+            path: this.config.websocket.path
+        });
+        this.wss.on('connection', (ws) => {
+            console.log('WebSocket client connected');
+            // 处理客户端消息
+            ws.on('message', (message) => {
+                try {
+                    const data = JSON.parse(message.toString());
+                    const eventConfig = this.config.websocket?.events?.[data.event];
+                    if (eventConfig?.mock.enabled) {
+                        const response = mockjs_1.default.mock(eventConfig.mock.template);
+                        ws.send(JSON.stringify({
+                            event: data.event,
+                            data: response
+                        }));
+                    }
+                }
+                catch (error) {
+                    console.error('Error handling WebSocket message:', error);
+                }
+            });
+            // 设置自动发送数据的定时器
+            if (this.config.websocket && this.config.websocket.events) {
+                Object.entries(this.config.websocket.events).forEach(([event, config]) => {
+                    if (config.mock.interval) {
+                        setInterval(() => {
+                            const response = mockjs_1.default.mock(config.mock.template);
+                            ws.send(JSON.stringify({
+                                event,
+                                data: response
+                            }));
+                        }, config.mock.interval);
+                    }
+                });
+            }
+            ws.on('close', () => {
+                // 移除日志，避免测试完成后的日志输出
+                // console.log('WebSocket client disconnected');
+            });
+        });
+    }
+    start() {
+        this.server.listen(this.config.server.port, () => {
+            console.log(`Mock 服务器已启动:`);
+            console.log(`- HTTP 地址: http://localhost:${this.config.server.port}`);
+            console.log(`- 管理后台: http://localhost:${this.config.server.port}/admin`);
+            if (this.config.websocket?.enabled) {
+                console.log(`- WebSocket 地址: ws://localhost:${this.config.server.port}${this.config.websocket.path}`);
+            }
+            console.log(`- 基础路径: ${this.config.server.baseProxy}`);
+            console.log('可用的接口:');
+            this.config.routes.forEach(route => {
+                Object.keys(route.methods).forEach(method => {
+                    console.log(`  ${method.toUpperCase()} http://localhost:${this.config.server.port}${this.config.server.baseProxy}${route.path}`);
+                });
+            });
+        });
+    }
+    close() {
+        // 关闭所有 WebSocket 连接
+        if (this.wss) {
+            this.wss.clients.forEach(client => {
+                client.close();
+            });
+            this.wss.close();
+        }
+        // 关闭 HTTP 服务器
+        this.server.close();
+    }
+}
+exports.MockServer = MockServer;