@fairys/mocker-cli 0.0.1

package/src/router/base.ts

@@ -0,0 +1,36 @@
+import express from 'express';
+import { fairysMockerBase } from "../base.js"
+import chalk from 'chalk';
+
+
+export class BaseRouter<T> {
+  /**mock 路由器实例*/
+  router: express.Router | null = null;
+  /**服务是否启用*/
+  isEnabled = false;
+  /**加载*/
+  load: (data: T[]) => void = (data) => {
+    /**销毁路由器实例*/
+    this.destroy();
+  };
+
+  /**销毁路由器实例*/
+  destroy: (msg?: string) => void = (msg) => {
+    if (this.router) {
+      // 清空路由器实例
+      this.router.stack = [];
+      this.isEnabled = false;
+    }
+    if (msg) {
+      console.log(chalk.red(msg))
+      console.log('')
+    }
+  };
+
+  useRouter() {
+    if (this.router && fairysMockerBase.router) {
+      fairysMockerBase.router.use(this.router);
+    }
+  }
+
+}

package/src/router/index.ts

@@ -0,0 +1,3 @@
+export * from "./base.js"
+export * from "./mock.js"
+export * from "./proxy.js"

package/src/router/mock.ts

@@ -0,0 +1,38 @@
+import express from 'express';
+import { MockerItem, createMockItemData } from "@fairys/create-mock-data"
+import { BaseRouter } from "./base.js"
+import chalk from "chalk"
+/**mock 路由器实例*/
+export class MockRouter extends BaseRouter<MockerItem> {
+  /**加载mock路由*/
+  load = (mockList: MockerItem[]) => {
+    /**销毁路由器实例*/
+    this.destroy();
+    /**创建路由器实例*/
+    // const router = this.router = Router();
+    const router = this.router = express.Router();
+    this.isEnabled = true;
+    /**加载mock路由*/
+    for (let index = 0; index < mockList.length; index++) {
+      const mockItem = mockList[index];
+      /**加载mock路由*/
+      const method = mockItem.method.toLowerCase() as "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head" | "options";
+      const handler = (req: express.Request, res: express.Response) => {
+        console.log(chalk.cyan(`  🦄 mock请求:` + '\t' + chalk.yellow(`${method}`) + "\t" + chalk.bold(`${mockItem.url}`)))
+        try {
+          const mockData = createMockItemData(mockItem);
+          res.status(Number(mockData.status) || 200).json(mockData.body);
+        } catch (error) {
+          res.status(500).json({
+            code: 500,
+            message: '加载失败',
+          });
+        }
+      };
+      console.log(chalk.green(`  🦄 mock加载:` + '\t' + chalk.yellow(`${method}`) + "\t" + chalk.bold(`${mockItem.url}`)))
+      router[method](mockItem.url, handler);
+    }
+    console.log('')
+    this.useRouter();
+  }
+}

package/src/router/proxy.ts

@@ -0,0 +1,89 @@
+import express from 'express';
+import { ProxyItem } from "@fairys/create-mock-data"
+import { BaseRouter } from "./base.js"
+import { createProxyMiddleware, RequestHandler } from "http-proxy-middleware"
+import chalk from "chalk"
+import { fairysMockerBase } from "../base.js"
+
+/**代理 路由器实例*/
+export class ProxyRouter extends BaseRouter<ProxyItem> {
+  /**代理 路由器实例*/
+  router: express.Router | null = null;
+  wsProxyList: RequestHandler[] = []
+  /**加载代理路由*/
+  load = (proxyList: ProxyItem[]) => {
+    const _that = this;
+    this.destroy();
+    /**创建路由器实例*/
+    const router = this.router = express.Router();
+    this.isEnabled = true;
+
+    for (let index = 0; index < proxyList.length; index++) {
+      const proxyItem = proxyList[index];
+      let protocol = 'http';
+      let _target = proxyItem.target
+      let _path = new RegExp(proxyItem.path)
+
+      if (/^(http:|https:|ws:|wss:)/.test(proxyItem.target)) {
+        const [_protocol] = proxyItem.target.split(":")
+        protocol = _protocol;
+      }
+      if ((protocol !== 'ws' && protocol !== 'wss') && proxyItem.ws) {
+        protocol = 'ws'
+        const [_protocol, ...rest] = proxyItem.target.split(":")
+        _target = [protocol, ...rest].join(":")
+      }
+      console.log(chalk.hex('#AF52DE')(chalk.bold(`  🍇 proxy代理启动:\t${chalk.yellow(protocol)}\t${proxyItem.path} ===> ${_target}\t`)))
+      // 判断是否 ^ 开头
+      if (!proxyItem.path.startsWith('^')) {
+        _path = new RegExp('^' + proxyItem.path)
+      }
+      if (proxyItem.ws) {
+        const wsProxy = createProxyMiddleware({
+          target: proxyItem.target,
+          pathRewrite: proxyItem.pathRewrite,
+          ws: proxyItem.ws,
+          changeOrigin: true,
+        })
+        _that.wsProxyList.push(wsProxy)
+        router.all(_path, wsProxy)
+        // 这个地方有个问题，如果在 rsbuild 中使用，websocket 会有问题
+        if (fairysMockerBase.server) {
+          // 升级 WebSocket 处理
+          fairysMockerBase.server?.on('upgrade', wsProxy.upgrade)
+        }
+      } else {
+        // 这个不生效问题
+        router.all(_path, createProxyMiddleware({
+          target: proxyItem.target,
+          pathRewrite: proxyItem.pathRewrite,
+          ws: proxyItem.ws,
+          changeOrigin: true,
+        }))
+      }
+    }
+    console.log('')
+    this.useRouter();
+  }
+
+  /**销毁路由器实例*/
+  destroy: (msg?: string) => void = (msg) => {
+    if (this.router) {
+      // 清空路由器实例
+      this.router.stack = [];
+      this.isEnabled = false;
+    }
+    /** http 升级 WebSocket 的 upgrade 销毁*/
+    const wsProxyList = this.wsProxyList
+    if (Array.isArray(wsProxyList) && wsProxyList.length && fairysMockerBase.server) {
+      for (let index = 0; index < wsProxyList.length; index++) {
+        const wsProxy = wsProxyList[index];
+        fairysMockerBase.server.off('upgrade', wsProxy.upgrade)
+      }
+    }
+    if (msg) {
+      console.log(chalk.red(msg))
+    }
+    console.log('')
+  };
+}

package/src/utils/decorator.ts

@@ -0,0 +1,90 @@
+
+import express from 'express';
+import { fairysMockerBase } from "../base.js"
+
+export type ClassStruct<TInstanceType extends unknown = unknown> = new (
+  ...args: any[]
+) => TInstanceType;
+
+export interface RouteItemType {
+  method: 'get' | 'delete' | 'post' | 'put' | 'patch' | 'head' | 'options';
+  path: string;
+  funName?: string | symbol;
+}
+
+export interface ControllerItemType {
+  prefix?: string;
+}
+
+/**控制器参数*/
+export const controllerMap = new WeakMap<object, ControllerItemType>();
+/**路由方法参数*/
+export const routesMap = new WeakMap<object, RouteItemType>();
+
+// 类装饰器：统一前缀
+export function Controller(prefix: string) {
+  return (target: any, context: ClassDecoratorContext) => {
+    controllerMap.set(target, { prefix })
+  };
+}
+
+// POST 方法装饰器（新版标准，100% 触发）
+export function Post(path: string) {
+  return (target: any, context: ClassMethodDecoratorContext) => {
+    if (context.kind === 'method') {
+      routesMap.set(target, { method: 'post', path, funName: context.name })
+    }
+  };
+}
+
+// POST 方法装饰器（新版标准，100% 触发）
+export function Get(path: string) {
+  return (target: any, context: ClassMethodDecoratorContext) => {
+    if (context.kind === 'method') {
+      routesMap.set(target, { method: 'get', path, funName: context.name })
+    }
+  };
+}
+
+// Method 方法装饰器
+export function MethodPath(path: string, method: RouteItemType['method'] = 'post') {
+  return (target: any, context: ClassMethodDecoratorContext) => {
+    if (context.kind === 'method') {
+      routesMap.set(target, {
+        method: method.toLowerCase() as RouteItemType['method'],
+        path, funName: context.name
+      })
+    }
+  };
+}
+
+// 注册路由（constructor 调用）
+export function registerRoutes(instance: unknown) {
+  const fairysRouter = fairysMockerBase.fairysMockerRouter;
+  if (!fairysRouter) {
+    console.log('请先初始化内置路由');
+    return;
+  }
+  // 获取原型数据
+  const proto = Object.getPrototypeOf(instance);
+  // 获取控制器前缀
+  const controllerAPIRootPath = controllerMap.get(proto.constructor);
+  /**实例中方法名*/
+  const controllerMethods = Object.getOwnPropertyNames(proto).filter((i) => i !== "constructor");
+  /**遍历实例中方法名*/
+  for (let index = 0; index < controllerMethods.length; index++) {
+    /**获取方法名*/
+    const controllerMethod = controllerMethods[index];
+    /**方法*/
+    const _requestHandle: (req: express.Request, res: express.Response,) => void = proto[controllerMethod];
+    const boundRequestHandle: (req: express.Request, res: express.Response) => void = _requestHandle.bind(instance);
+    /**获取当前方法配置*/
+    const routeItem = routesMap.get(_requestHandle);
+    if (routeItem) {
+      /**拼接前缀*/
+      const fullPath = (controllerAPIRootPath?.prefix || '') + routeItem.path;
+      /**方法*/
+      fairysRouter[routeItem.method](fullPath, (req, res) => boundRequestHandle(req, res));
+    }
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./utils.js"
+export * from "./decorator.js"

package/src/utils/mcok.proxy.ts

@@ -0,0 +1,162 @@
+
+/**保存配置和读取配置*/
+import nodePath from "node:path"
+import fs from 'node:fs';
+import { utils } from "./utils.js";
+import { createProxyData, createMockData, ProxyList, DefineMockList } from "@fairys/create-mock-data";
+
+export const getProxyFile = (rootDir?: string, dir?: string, fileName?: string) => {
+  const _rootDir = rootDir?.trim() || utils.rootDir;
+  const _dir = dir?.trim() || utils.dir;
+  const _fileName = fileName?.trim() || utils.proxyFile;
+  // 读取 .cache.json 文件
+  const proxyDir = nodePath.join(_rootDir, _dir);
+  const cacheFilePath = nodePath.join(proxyDir, _fileName + '.cache.json');
+  if (fs.existsSync(cacheFilePath)) {
+    const cacheFileContent = fs.readFileSync(cacheFilePath, 'utf-8');
+    const cacheData = JSON.parse(cacheFileContent);
+    const proxyList = cacheData.proxyList || [];
+    return {
+      proxyList,
+      rootDir: _rootDir,
+      dir: _dir,
+      fileName: _fileName,
+      cache: _fileName + '.cache.json',
+    }
+  }
+  return undefined
+}
+
+export const createProxyFile = (proxyList: ProxyList, rootDir?: string, dir?: string, fileName?: string) => {
+  const _rootDir = rootDir?.trim() || utils.rootDir;
+  const _dir = dir?.trim() || utils.dir;
+  const _fileName = fileName?.trim() || utils.proxyFile;
+  // 读取 .cache.json 文件
+  const proxyDir = nodePath.join(_rootDir, _dir);
+
+  if (!fs.existsSync(proxyDir)) {
+    fs.mkdirSync(proxyDir, { recursive: true });
+  }
+  const proxyConfig = createProxyData(proxyList)
+
+  const proxyFilePath = nodePath.join(proxyDir, `${_fileName}.ts`);
+  const proxyFileContent = `// 代理配置文件
+// 自动生成于 ${new Date().toISOString()}
+
+/**
+ * 代理配置参数
+ */
+export type ProxyItem = Record<string,{
+  /**转发地址*/
+  target: string,
+  /**路径重写*/
+  pathRewrite?: Record<string, string>,
+  /**是否开启ws*/
+  ws?: boolean
+}> 
+
+export const proxyConfig: ProxyItem = ${JSON.stringify(proxyConfig, null, 2)};
+export default proxyConfig;
+    `;
+  fs.writeFileSync(proxyFilePath, proxyFileContent);
+  // 存储原始的 proxyConfig 到 .cache.json 文件
+  const cacheFilePath = nodePath.join(proxyDir, _fileName + '.cache.json');
+
+  const cacheFileContent = JSON.stringify({
+    proxyList,
+    rootDir: _rootDir,
+    dir: _dir,
+    fileName: _fileName,
+    cache: _fileName + '.cache.json',
+  }, null, 2);
+  fs.writeFileSync(cacheFilePath, cacheFileContent);
+
+  return {
+    proxyConfig,
+    rootDir: _rootDir,
+    dir: _dir,
+    fileName: _fileName,
+    cache: _fileName + '.cache.json',
+  }
+}
+
+export const getMcokFile = (rootDir?: string, dir?: string, fileName?: string) => {
+  const _rootDir = rootDir?.trim() || utils.rootDir;
+  const _dir = dir?.trim() || utils.dir;
+  const _fileName = fileName?.trim() || utils.file;
+  // 读取 .cache.json 文件
+  const mockDir = nodePath.join(_rootDir, _dir);
+  const cacheFilePath = nodePath.join(mockDir, _fileName + '.cache.json');
+  if (fs.existsSync(cacheFilePath)) {
+    const cacheFileContent = fs.readFileSync(cacheFilePath, 'utf-8');
+    const cacheData = JSON.parse(cacheFileContent);
+    const mockList = cacheData.mockList || [];
+    return {
+      mockList,
+      rootDir: _rootDir,
+      dir: _dir,
+      fileName: _fileName,
+      cache: _fileName + '.cache.json',
+    }
+  }
+  return undefined
+}
+
+export const createMockFile = (mockList: DefineMockList, rootDir?: string, dir?: string, fileName?: string) => {
+  const _rootDir = rootDir?.trim() || utils.rootDir;
+  const _dir = dir?.trim() || utils.dir;
+  const _fileName = fileName?.trim() || utils.file;
+  // 读取 .cache.json 文件
+  const mockDir = nodePath.join(_rootDir, _dir);
+
+  if (!fs.existsSync(mockDir)) {
+    fs.mkdirSync(mockDir, { recursive: true });
+  }
+  const mockConfig = createMockData(mockList)
+
+  const mockFilePath = nodePath.join(mockDir, `${_fileName}.ts`);
+  const mockFileContent = `// Mock 配置文件
+// 自动生成于 ${new Date().toISOString()}
+    
+export interface MockerItem {
+  /**该接口允许的 请求方法，默认同时支持 GET 和 POST*/
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+  /**状态码*/
+  status: string;
+  //配置响应延迟时间, 如果传入的是一个数组，则代表延迟时间的范围
+  delay: number | [number, number];
+  /**响应体(可以自定义返回格式)*/
+  body: any;
+  /**接口地址*/
+  url: string;
+  /**列表数据条数（仅 list 格式有效）*/
+  listCount?: number;
+}
+
+/**mock配置 列表*/
+export type DefineMockList = MockerItem[];
+
+export const mockList: DefineMockList = ${JSON.stringify(mockConfig, null, 2)};
+export default mockList;
+    `;
+  fs.writeFileSync(mockFilePath, mockFileContent);
+  // 存储原始的 mockConfig 到 .cache.json 文件
+  const cacheFilePath = nodePath.join(mockDir, _fileName + '.cache.json');
+
+  const cacheFileContent = JSON.stringify({
+    mockList,
+    rootDir: _rootDir,
+    dir: _dir,
+    fileName: _fileName,
+    cache: _fileName + '.cache.json',
+  }, null, 2);
+  fs.writeFileSync(cacheFilePath, cacheFileContent);
+
+  return {
+    mockConfig,
+    rootDir: _rootDir,
+    dir: _dir,
+    fileName: _fileName,
+    cache: _fileName + '.cache.json',
+  }
+}

package/src/utils/utils.ts

@@ -0,0 +1,46 @@
+
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from "node:path"
+
+class Utils {
+  /**根目录*/
+  public rootDir = process.cwd();
+  /**目录名*/
+  public dir = 'mock';
+  /**文件名*/
+  public file = 'index.mock';
+  /**代理文件名*/
+  public proxyFile = 'proxy';
+
+  /**设置根目录*/
+  setRootDir = (value?: string) => {
+    if (value && fs.existsSync(value)) {
+      this.rootDir = value
+    } else {
+      if (value) {
+        console.log('')
+        console.log(chalk.red(`设置的根目录不存在：${value}`))
+        console.log('')
+      }
+      this.rootDir = process.env.FAIRYS_MOCKER_ROOT_DIR || path.join(process.cwd());
+    }
+  }
+
+  /**设置目录名*/
+  setDir = (value?: string) => {
+    this.dir = value || process.env.FAIRYS_MOCKER_DIR || 'mock';
+  }
+
+  /**设置文件名*/
+  setFile = (value?: string) => {
+    this.file = value || process.env.FAIRYS_MOCKER_FILE || 'index.mock';
+  }
+
+  /**设置代理文件名*/
+  setProxyFile = (value?: string) => {
+    this.proxyFile = value || process.env.FAIRYS_MOCKER_PROXY_FILE || 'proxy';
+  }
+}
+
+export const utils = new Utils()