jacky-proxy 1.0.0

package/src/commands/rules-add.js

@@ -0,0 +1,82 @@
+/**
+ * rules add 命令实现
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function rulesAddCommand(options) {
+  const configPath = path.join(process.cwd(), options.config || 'config/match-rules.json');
+
+  // 加载现有配置
+  let config = {
+    global: { ignoreProps: [] },
+    interfaces: []
+  };
+
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    } catch (error) {
+      console.error(`❌ 读取配置文件失败: ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  // 确保 interfaces 数组存在
+  if (!config.interfaces) {
+    config.interfaces = [];
+  }
+
+  // 检查接口是否已存在
+  const existingIndex = config.interfaces.findIndex(
+    r => r.interfaceName === options.interface
+  );
+
+  const newRule = {
+    interfaceName: options.interface
+  };
+
+  if (options.ignore) {
+    newRule.ignoreProps = options.ignore.split(',').map(s => s.trim());
+  }
+
+  if (options.essential) {
+    newRule.essentialProps = options.essential.split(',').map(s => s.trim());
+  }
+
+  if (options.deepIgnore !== undefined) {
+    newRule.deepIgnore = options.deepIgnore;
+  }
+
+  if (existingIndex >= 0) {
+    // 更新现有规则
+    config.interfaces[existingIndex] = {
+      ...config.interfaces[existingIndex],
+      ...newRule
+    };
+    console.log(`✅ 更新接口规则: ${options.interface}`);
+  } else {
+    // 添加新规则
+    config.interfaces.push(newRule);
+    console.log(`✅ 添加接口规则: ${options.interface}`);
+  }
+
+  // 保存配置
+  try {
+    // 确保目录存在
+    const configDir = path.dirname(configPath);
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    console.log(`✅ 配置已保存: ${configPath}`);
+  } catch (error) {
+    console.error(`❌ 保存配置文件失败: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = rulesAddCommand;
+

package/src/commands/rules-list.js

@@ -0,0 +1,67 @@
+/**
+ * rules list 命令实现
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function rulesListCommand(options) {
+  const configPath = path.join(process.cwd(), options.config || 'config/match-rules.json');
+
+  if (!fs.existsSync(configPath)) {
+    console.error(`❌ 配置文件不存在: ${configPath}`);
+    process.exit(1);
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+
+    console.log('\n📋 匹配规则配置:');
+    console.log('═══════════════════════════════════════════════════════\n');
+
+    // 全局规则
+    if (config.global) {
+      console.log('🌐 全局规则:');
+      if (config.global.ignoreProps && config.global.ignoreProps.length > 0) {
+        console.log(`  忽略属性: ${config.global.ignoreProps.join(', ')}`);
+      }
+      if (config.global.description) {
+        console.log(`  说明: ${config.global.description}`);
+      }
+      console.log('');
+    }
+
+    // 接口规则
+    if (config.interfaces && config.interfaces.length > 0) {
+      console.log('🔧 接口规则:');
+      config.interfaces.forEach((rule, index) => {
+        console.log(`\n  ${index + 1}. ${rule.interfaceName}`);
+        if (rule.ignoreProps && rule.ignoreProps.length > 0) {
+          console.log(`     忽略属性: ${rule.ignoreProps.join(', ')}`);
+        }
+        if (rule.essentialProps && rule.essentialProps.length > 0) {
+          console.log(`     必需属性: ${rule.essentialProps.join(', ')}`);
+        }
+        if (rule.deepIgnore !== undefined) {
+          console.log(`     深度忽略: ${rule.deepIgnore}`);
+        }
+        if (rule.sortProps && rule.sortProps.length > 0) {
+          console.log(`     排序配置: ${JSON.stringify(rule.sortProps)}`);
+        }
+        if (rule.description) {
+          console.log(`     说明: ${rule.description}`);
+        }
+      });
+    } else {
+      console.log('  (无接口规则)');
+    }
+
+    console.log('\n═══════════════════════════════════════════════════════');
+  } catch (error) {
+    console.error(`❌ 读取配置文件失败: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = rulesListCommand;
+

package/src/commands/rules-remove.js

@@ -0,0 +1,43 @@
+/**
+ * rules remove 命令实现
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function rulesRemoveCommand(options) {
+  const configPath = path.join(process.cwd(), options.config || 'config/match-rules.json');
+
+  if (!fs.existsSync(configPath)) {
+    console.error(`❌ 配置文件不存在: ${configPath}`);
+    process.exit(1);
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+
+    if (!config.interfaces) {
+      console.log('⚠️  配置中没有接口规则');
+      return;
+    }
+
+    const index = config.interfaces.findIndex(
+      r => r.interfaceName === options.interface
+    );
+
+    if (index === -1) {
+      console.log(`⚠️  未找到接口规则: ${options.interface}`);
+      return;
+    }
+
+    config.interfaces.splice(index, 1);
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    console.log(`✅ 已删除接口规则: ${options.interface}`);
+  } catch (error) {
+    console.error(`❌ 操作失败: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = rulesRemoveCommand;
+

package/src/commands/rules-test.js

@@ -0,0 +1,72 @@
+/**
+ * rules test 命令实现
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+async function rulesTestCommand(options) {
+  const configPath = path.join(process.cwd(), options.config || 'config/match-rules.json');
+  const requestPath = path.join(process.cwd(), options.request);
+
+  // 加载配置
+  if (!fs.existsSync(configPath)) {
+    console.error(`❌ 配置文件不存在: ${configPath}`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(requestPath)) {
+    console.error(`❌ 请求文件不存在: ${requestPath}`);
+    process.exit(1);
+  }
+
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    const requestData = JSON.parse(fs.readFileSync(requestPath, 'utf-8'));
+
+    // 查找接口规则
+    const interfaceRule = config.interfaces?.find(
+      r => r.interfaceName === options.interface
+    );
+
+    if (!interfaceRule) {
+      console.log(`⚠️  未找到接口规则: ${options.interface}`);
+      console.log('   使用全局规则进行测试');
+    }
+
+    console.log('\n🧪 测试匹配规则:');
+    console.log('═══════════════════════════════════════════════════════\n');
+    console.log(`接口名称: ${options.interface}`);
+    console.log(`请求文件: ${options.request}`);
+    console.log('\n配置的规则:');
+
+    if (interfaceRule) {
+      if (interfaceRule.ignoreProps) {
+        console.log(`  忽略属性: ${interfaceRule.ignoreProps.join(', ')}`);
+      }
+      if (interfaceRule.essentialProps) {
+        console.log(`  必需属性: ${interfaceRule.essentialProps.join(', ')}`);
+      }
+      if (interfaceRule.deepIgnore !== undefined) {
+        console.log(`  深度忽略: ${interfaceRule.deepIgnore}`);
+      }
+    } else {
+      console.log('  (使用全局规则)');
+      if (config.global?.ignoreProps) {
+        console.log(`  全局忽略属性: ${config.global.ignoreProps.join(', ')}`);
+      }
+    }
+
+    console.log('\n请求数据:');
+    console.log(JSON.stringify(requestData, null, 2));
+
+    console.log('\n✅ 测试完成（此命令仅显示配置信息，实际匹配需要在服务器运行时测试）');
+    console.log('═══════════════════════════════════════════════════════');
+  } catch (error) {
+    console.error(`❌ 测试失败: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = rulesTestCommand;
+

package/src/commands/start.js

@@ -0,0 +1,203 @@
+/**
+ * start 命令实现
+ * 启动 Mock 服务器
+ * 支持：
+ * 1. 直接启动 Raw 文件夹（自动转换后启动）
+ * 2. 启动已有的 base-data + mocks 结构（通过 mock-id）
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * 查找项目根目录（包含 server.js 和 package.json 的目录）
+ */
+function findProjectRoot() {
+  // 从当前文件所在目录开始向上查找
+  let currentDir = __dirname;
+  
+  // 当前文件在 src/commands/start.js，所以需要向上两级
+  // 但为了更通用，我们向上查找直到找到 server.js 或 package.json
+  while (currentDir !== path.dirname(currentDir)) {
+    const serverPath = path.join(currentDir, 'server.js');
+    const packagePath = path.join(currentDir, 'package.json');
+    
+    if (fs.existsSync(serverPath) || fs.existsSync(packagePath)) {
+      return currentDir;
+    }
+    
+    currentDir = path.dirname(currentDir);
+  }
+  
+  // 如果没找到，返回默认的项目根目录（从 __dirname 向上两级）
+  return path.resolve(__dirname, '../..');
+}
+
+/**
+ * 检查路径是否是 Raw 文件夹（以 .folder 结尾的目录）
+ */
+function isRawFolder(pathStr) {
+  if (!pathStr) return false;
+  
+  // 检查是否是绝对路径或相对路径
+  const fullPath = path.isAbsolute(pathStr) 
+    ? pathStr 
+    : path.join(process.cwd(), pathStr);
+  
+  // 检查路径是否存在且是目录
+  if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isDirectory()) {
+    return false;
+  }
+  
+  // 检查是否以 .folder 结尾
+  return path.basename(fullPath).endsWith('.folder');
+}
+
+/**
+ * 查找默认的 Raw 文件夹（以 .folder 结尾的文件夹）
+ */
+function findDefaultRawFolder() {
+  try {
+    const files = fs.readdirSync(process.cwd(), { withFileTypes: true });
+    const folderFiles = files
+      .filter(dirent => dirent.isDirectory() && dirent.name.endsWith('.folder'))
+      .map(dirent => path.join(process.cwd(), dirent.name));
+    
+    if (folderFiles.length > 0) {
+      folderFiles.sort();
+      return folderFiles[0];
+    }
+  } catch (error) {
+    // 忽略错误，返回 null
+  }
+  
+  return null;
+}
+
+/**
+ * start 命令主函数
+ */
+async function startCommand(mockIdOrPath, options) {
+  let finalMockId = mockIdOrPath;
+  
+  // 检查是否是 Raw 文件夹路径
+  if (isRawFolder(mockIdOrPath)) {
+    console.log('🔍 检测到 Raw 文件夹，将自动转换后启动...');
+    
+    const rawFolderPath = path.isAbsolute(mockIdOrPath)
+      ? mockIdOrPath
+      : path.join(process.cwd(), mockIdOrPath);
+    
+    // 如果设置了 --no-migrate，直接报错
+    if (options.noMigrate) {
+      console.error('错误: 指定了 --no-migrate，但提供的是 Raw 文件夹路径');
+      console.error('提示: 请先使用 jacky-proxy migrate 命令转换，或移除 --no-migrate 参数');
+      process.exit(1);
+    }
+    
+    // 执行迁移
+    const migrateCommand = require('./migrate');
+    const scenarioName = options.scenario || '场景1';
+    const targetFolder = options.target || 'mocks/test-folder';
+    const ignoreInterfaces = options.ignore
+      ? options.ignore.split(',').map(s => s.trim()).filter(s => s)
+      : [];
+    
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════');
+    console.log('  自动迁移 Raw 文件夹');
+    console.log('═══════════════════════════════════════════════════════');
+    console.log(`场景名称: ${scenarioName}`);
+    console.log(`目标文件夹: ${targetFolder}`);
+    console.log(`Raw 文件夹: ${rawFolderPath}`);
+    if (ignoreInterfaces.length > 0) {
+      console.log(`忽略接口: ${ignoreInterfaces.join(', ')}`);
+    }
+    console.log('');
+    
+    // 调用迁移命令（非交互式）
+    const migrateOptions = {
+      scenario: scenarioName,
+      target: targetFolder,
+      raw: rawFolderPath,
+      ignore: options.ignore || '',
+      interactive: false
+    };
+    
+    try {
+      await migrateCommand(migrateOptions);
+      
+      // 从配置文件中读取新创建的 mock-id（配置文件在工作目录）
+      const workDir = process.cwd();
+      const configPath = path.join(workDir, options.config || 'proxy.config.json');
+      if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const folder = config.folders.list.find(f => f.path === targetFolder);
+        if (folder) {
+          finalMockId = String(folder.id);
+          console.log(`\n✅ 迁移完成，将使用场景 ID: ${finalMockId}`);
+        } else {
+          console.warn('警告: 无法在配置文件中找到新创建的场景，使用默认 ID: 1');
+          finalMockId = '1';
+        }
+      } else {
+        console.warn('警告: 配置文件不存在，使用默认 ID: 1');
+        finalMockId = '1';
+      }
+    } catch (error) {
+      console.error('迁移失败:', error.message);
+      process.exit(1);
+    }
+  } else {
+    // 检查是否是数字（mock-id）
+    const mockIdNum = parseInt(mockIdOrPath);
+    if (isNaN(mockIdNum)) {
+      console.warn(`警告: "${mockIdOrPath}" 不是有效的 mock-id，将尝试作为 ID 使用`);
+    }
+    finalMockId = mockIdOrPath;
+  }
+  
+  // 设置环境变量
+  const workDir = process.cwd(); // 保存当前工作目录
+  process.env.MOCK_ID = finalMockId;
+  process.env.PORT = options.port || '5001';
+  process.env.WORK_DIR = workDir; // 设置工作目录环境变量
+  process.env.CONFIG_PATH = path.join(workDir, options.config || 'proxy.config.json');
+  process.env.DEBUG = options.debug ? 'true' : 'false'; // 设置 Debug 模式
+
+  console.log('');
+  console.log('═══════════════════════════════════════════════════════');
+  console.log('  启动 Mock 服务器');
+  console.log('═══════════════════════════════════════════════════════');
+  console.log(`场景 ID: ${finalMockId}`);
+  console.log(`端口: ${process.env.PORT}`);
+  console.log('');
+
+  // 查找项目根目录
+  const projectRoot = findProjectRoot();
+  const serverPath = path.join(projectRoot, 'server.js');
+  
+  // 检查 server.js 是否存在
+  if (!fs.existsSync(serverPath)) {
+    console.error(`错误: 找不到 server.js 文件`);
+    console.error(`  期望位置: ${serverPath}`);
+    console.error(`  当前工作目录: ${process.cwd()}`);
+    console.error(`  项目根目录: ${projectRoot}`);
+    process.exit(1);
+  }
+  
+  // 切换到项目根目录（这样 server.js 中的相对路径才能正确工作）
+  const originalCwd = process.cwd();
+  process.chdir(projectRoot);
+  
+  try {
+    require(serverPath);
+  } catch (error) {
+    console.error('启动服务器失败:', error);
+    process.chdir(originalCwd); // 恢复原始工作目录
+    process.exit(1);
+  }
+}
+
+module.exports = startCommand;
+