chanjs 2.7.4 → 2.7.5

package/App.js

@@ -1,533 +0,0 @@
-import express from "express";
-import fs from "fs";
-import path from "path";
-
-// 引入基础组件
-import DatabaseManager from "./base/Database.js";
-
-// 引入配置和工具
-import { Paths } from "./config/index.js";
-import { loadConfig, loaderSort, loadController } from "./loader/index.js";
-import { Cors, setBody, setCookie, setFavicon, setHeader, setStatic, setTemplate, waf, compress, log } from "./middleware/index.js";
-import { notFoundResponse, parseDatabaseError, errorResponse } from "./response/index.js";
-import { store } from "./storage/index.js";
-import { schedule } from "./schedule/schedule.js";
-import { sse } from "./realtime/sse.js";
-import { websocket } from "./realtime/websocket.js";
-import { importFile } from "./global/import.js";
-
-import "./global/index.js";
-
-/**
- * Chan 应用核心类
- * @class Chan
- * @description 管理应用程序的路由、中间件、数据库连接和服务
- * @example
- * const app = new Chan();
- * await app.start();
- */
-class Chan {
-
-  /**
-   * 构造函数
-   * @constructor
-   * @description 初始化 Express 应用和核心组件
-   */
-  constructor() {
-    this.app = express();
-    // 数据库连接管理
-    this.dbManager = new DatabaseManager();
-    // 应用路由
-    this.router = express.Router();
-  }
-
-  /**
-   * 启动应用程序
-   * @async
-   * @description 执行完整的启动流程
-   * 包括：初始化配置、数据库、扩展、中间件、路由、错误处理
-   * @returns {Promise<void>}
-   */
-  async start() {
-    //加载配置
-    await this.config();
-    //暴露 Paths 到 Chan 静态属性（DI：业务侧通过 Chan.paths 或 this.paths 访问）
-    Chan.paths = Paths;
-    //初始化 Redis 适配器（WAF 封禁 / Rate Limit 共享存储）
-    await this.loadRedis();
-    //加载数据库
-    await this.loadDB();
-    //加载扩展方法
-    await this.loadExtend();
-    //加载中间件
-    await this.loadAppMiddleware();
-    //设置app
-    this.setApp();
-     //加载路由
-    await this.loadRouter();
-    await this.loadCommonRouter();
-    this.useRouter();
-    //404 500 处理（放在最后，确保所有路由都已注册）
-    this.setErrorHandler();
-    //执行 beforeStart 钩子（用户自定义的初始化逻辑）
-    await this._runBeforeStart();
-  }
-
-  /**
-   * 注册 beforeStart 钩子
-   * @param {Function} fn - 钩子函数（支持 async）
-   * @description 在 start() 流程末尾、run() 之前执行
-   * 适合做：缓存预热、定时任务注册、健康检查初始化等
-   * @example
-   * chan.beforeStart(async () => {
-   *   schedule.every('clean-log', 60000, cleanLogs);
-   * });
-   */
-  beforeStart(fn) {
-    if (typeof fn !== 'function') {
-      throw new Error('beforeStart 参数必须是函数');
-    }
-    if (!this._beforeStartHooks) this._beforeStartHooks = [];
-    this._beforeStartHooks.push(fn);
-  }
-
-  /**
-   * 执行 beforeStart 钩子
-   * @private
-   */
-  async _runBeforeStart() {
-    if (!this._beforeStartHooks || !this._beforeStartHooks.length) return;
-    for (const fn of this._beforeStartHooks) {
-      try {
-        await fn();
-      } catch (err) {
-        console.error('[Chan] beforeStart 钩子执行失败:', err.message);
-      }
-    }
-  }
-
-  /**
-   * 优雅停机
-   * @async
-   * @description 关闭 HTTP 服务、定时任务、数据库连接、Redis
-   * 监听 SIGTERM / SIGINT 信号自动触发
-   * @returns {Promise<void>}
-   */
-  async shutdown() {
-    if (this._shuttingDown) return;
-    this._shuttingDown = true;
-    console.log('[Chan] 开始优雅停机...');
-
-    // 5 秒强制退出兜底（原 30s 过长，连接已主动销毁，5s 足够收尾）
-    const forceExitTimer = setTimeout(() => {
-      console.error('[Chan] 优雅停机超时（5s），强制退出');
-      process.exit(1);
-    }, 5000);
-    forceExitTimer.unref?.();
-
-    try {
-      // 1. 停止接收新请求 + 主动销毁所有 keep-alive 连接
-      //    说明：server.close() 只停止 listen，会等所有现有连接关闭才回调，
-      //    浏览器默认 keep-alive 会导致 30s 超时，所以必须主动 destroy。
-      if (this.server) {
-        if (this._sockets && this._sockets.size > 0) {
-          for (const socket of this._sockets) {
-            try { socket.destroy(); } catch (e) { /* 忽略已关闭的 socket */ }
-          }
-          this._sockets.clear();
-        }
-        await new Promise(resolve => this.server.close(resolve));
-        console.log('[Chan] HTTP 服务已关闭');
-      }
-
-      // 2. 关闭实时通信（SSE / WebSocket，先于定时任务关闭，避免推送失败）
-      try {
-        sse.shutdown();
-      } catch (e) {
-        console.error('[Chan] 关闭 SSE 失败:', e.message);
-      }
-      try {
-        websocket.shutdown();
-      } catch (e) {
-        console.error('[Chan] 关闭 WebSocket 失败:', e.message);
-      }
-
-      // 3. 停止所有定时任务
-      try {
-        schedule.shutdown();
-      } catch (e) {
-        console.error('[Chan] 停止定时任务失败:', e.message);
-      }
-
-      // 4. 关闭数据库连接
-      try {
-        await this.dbManager.closeAll();
-      } catch (e) {
-        console.error('[Chan] 关闭数据库失败:', e.message);
-      }
-
-      // 5. 关闭 Redis / 存储适配层
-      try {
-        await store.close();
-      } catch (e) {
-        console.error('[Chan] 关闭存储适配层失败:', e.message);
-      }
-
-      console.log('[Chan] 优雅停机完成');
-    } finally {
-      clearTimeout(forceExitTimer);
-      process.exit(0);
-    }
-  }
-
-  /**
-   * 注册进程信号监听器（自动触发优雅停机）
-   * @private
-   */
-  _registerSignalHandlers() {
-    if (this._signalRegistered) return;
-    this._signalRegistered = true;
-
-    const handler = async (signal) => {
-      // 幂等守卫：首次信号触发停机，后续信号直接忽略，避免日志噪音
-      if (this._shuttingDown) {
-        // 第二次 ctrl+c：直接强制退出，让用户能快速中断
-        console.error(`[Chan] 再次收到 ${signal}，强制退出`);
-        process.exit(1);
-      }
-      console.log(`[Chan] 收到 ${signal} 信号`);
-      await this.shutdown();
-    };
-
-    process.on('SIGTERM', () => handler('SIGTERM'));
-    process.on('SIGINT', () => handler('SIGINT'));
-  }
-
-  /**
-   * 加载配置
-   * @async
-   * @returns {Promise<void>}
-   * @description 加载应用配置并设置到全局变量
-   */
-  async config() {
-    let config = await loadConfig();
-    Chan.config = config;
-  }
-
-  /**
-   * 初始化存储适配层
-   * @async
-   * @description
-   * 根据 config.REDIS_ENABLED 决定使用 Redis 还是内存模式
-   * - Redis 启用且连接成功 → 使用 Redis 后端
-   * - Redis 未启用或连接失败 → 降级到内存模式（Map+TTL，上限 10 万条）
-   * WAF 封禁状态、Rate Limit 计数都依赖此适配层
-   */
-  async loadRedis() {
-    const config = Chan.config || {};
-    try {
-      await store.init({
-        REDIS_ENABLED: config.REDIS_ENABLED,
-        REDIS: config.REDIS,
-      });
-    } catch (err) {
-      console.warn(`[Chan] 存储适配层初始化失败，使用内存模式: ${err.message}`);
-    }
-  }
-
-  /**
-   * 加载数据库
-   * @async
-   * @returns {Promise<void>}
-   * @description 根据配置初始化所有数据库连接
-   */
-  async loadDB() {
-    const dbList = Chan.config?.db || [];
-    for (const [index, item] of dbList.entries()) {
-      const key = item.key || String(index);
-      try {
-        // 已通过 dbList.entries() 拿到 item，无需再做 if (!dbConfig) return 死代码判断
-        const connection = this.dbManager.add(key, item, { isDefault: index === 0 });
-        if (index === 0) {
-          Chan.db = this.dbManager.get();
-        }
-      } catch (error) {
-        console.error(`[DB] 数据库 ${key} 初始化失败: ${error.message}`);
-      }
-    }
-
-    console.log(`[DB] 初始化完成，已加载 ${dbList.length} 个数据库`);
-  }
-
-  /**
-   * 加载扩展模块
-   * @async
-   * @returns {Promise<void>}
-   * @description 加载 common、helper、extend 目录下的扩展模块
-   */
-  async loadExtend() {
-    const extensions = [
-      { _path: Paths.commonPath, key: "common" },
-      { _path: Paths.helperPath, key: "helper" },
-      { _path: Paths.extendPath, key: "extend" },
-    ];
-
-    for (const { _path, key } of extensions) {
-      await this.loadFn(_path, key);
-    }
-
-    if (!Chan.helper) {
-      Chan.helper = {};
-    }
-    Chan.helper.loadController = loadController;
-  }
-
-  /**
-   * 加载模块文件
-   * @async
-   * @param {string} _path - 模块目录路径
-   * @param {string} key - 模块键名
-   * @returns {Promise<void>}
-   * @description 从指定目录加载所有 JS 模块并合并到 Chan 静态属性
-   */
-  async loadFn(_path, key) {
-    if (fs.existsSync(_path)) {
-      const files = fs.readdirSync(_path).filter((file) => file.endsWith(".js"));
-      for (const file of files) {
-        const filePath = path.join(_path, file);
-        let helperModule = await importFile(filePath);
-        if (!Chan[key]) {
-          Chan[key] = {};
-        }
-        Object.assign(Chan[key], helperModule);
-      }
-    }
-  }
-
-  /**
-   * 初始化中间件
-   * @async
-   * @returns {Promise<void>}
-   * @description 配置并注册所有应用中间件
-   */
-  async loadAppMiddleware() {
-    const config = Chan.config;
-    const { 
-      views = [], 
-      NODE_ENV = "dev", 
-      APP_NAME = "ChanCMS",
-       APP_VERSION = "1.0.0", 
-       cookieKey, 
-       BODY_LIMIT = "10mb",
-        statics = [], 
-        cors = {}, 
-        PROXY = "false", 
-        logger = {},
-        waf: wafConfig = { enabled: false } 
-      } = config;
-    
-    await waf(this.app, wafConfig);
-    setFavicon(this.app);
-    setStatic(this.app, statics);
-    // 响应压缩中间件：放在 setStatic 之后（静态资源已由 express.static 处理流式响应）、Cors 之前
-    // 跳过 SSE / WebSocket 升级请求，仅对可压缩文本类型且 > 1KB 的响应体压缩
-    this.app.use(compress());
-    setCookie(this.app, cookieKey);
-    setBody(this.app, BODY_LIMIT);
-    Cors(this.app, cors);
-    log(this.app, logger);
-    setTemplate(this.app, { views, NODE_ENV });
-    setHeader(this.app, { APP_NAME, APP_VERSION });
-  }
-
-  /**
-   * 应用配置
-   * @private
-   * @description 设置 Express 应用配置
-   * trust proxy 根据 config.PROXY 动态设置，避免默认 true 导致 X-Forwarded-For 伪造
-   */
-  setApp() {
-    const proxyConfig = Chan.config?.PROXY;
-    if (proxyConfig === 'true' || proxyConfig === true) {
-      // 信任所有代理（仅在反代可信时使用）
-      this.app.set("trust proxy", true);
-    } else if (proxyConfig === 'loopback' || !proxyConfig) {
-      // 默认仅信任本机回环代理
-      this.app.set("trust proxy", "loopback");
-    } else {
-      // 其他值按字面传入（IP / CIDR / 跳数）
-      this.app.set("trust proxy", proxyConfig);
-    }
-  }
-
-  /**
-   * 应用路由
-   * @private
-   * @description 将所有路由应用到 Express 应用
-   */
-  useRouter() {
-    this.app.use(this.router);
-  }
-
-  /**
-   * 应用错误处理404 500
-   * @private
-   * @description 配置全局错误处理中间件
-   */
-  setErrorHandler() {
-    //404（标准 Express 中间件签名，保留 next 参数）
-    this.app.use((req, res, next) => {
-      res.status(404).json(notFoundResponse(req));
-    });
-
-    // 500
-    this.app.use((err, req, res, next) => {
-      if (res.headersSent) return next(err);
-
-      const errorInfo = err?.stack ? this._parseErrorStack(err.stack) : { message: err?.message || err };
-      const requestInfo = `${req.method} ${req.originalUrl}`;
-      console.error(`[Global Error] ${requestInfo} - ${errorInfo.file}:${errorInfo.line || "?"} - ${errorInfo.message}`);
-
-      const parsedError = parseDatabaseError(err);
-      console.error(`[Global Error Details] Database Error - ${parsedError.msg}`);
-      res.status(parsedError.statusCode).json(errorResponse(err, req));
-    });
-  }
-
-  /**
-   * 解析错误堆栈
-   * @private
-   * @param {string} stack - 错误堆栈字符串
-   * @returns {Object} 解析后的错误信息
-   * @description 从错误堆栈中提取文件名、行号、列号等信息
-   */
-  _parseErrorStack(stack) {
-    if (!stack) return { message: '未知错误' };
-
-    const stackLines = stack.split('\n');
-    if (stackLines.length < 2) {
-      return { message: stackLines[0] || '未知错误' };
-    }
-
-    const errorLine = stackLines[1].trim();
-    const match = errorLine.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
-    
-    if (match) {
-      return {
-        message: stackLines[0] || '未知错误',
-        function: match[1],
-        file: match[2],
-        line: match[3],
-        column: match[4]
-      };
-    }
-
-    const fileMatch = errorLine.match(/at\s+(.+?):(\d+):(\d+)/);
-    if (fileMatch) {
-      return {
-        message: stackLines[0] || '未知错误',
-        file: fileMatch[1],
-        line: fileMatch[2],
-        column: fileMatch[3]
-      };
-    }
-
-    return { message: stackLines[0] || '未知错误', file: errorLine };
-  }
-
- 
-
-  /**
-   * 加载模块路由
-   * @async
-   * @returns {Promise<void>}
-   * @description 从 app/modules 目录加载所有模块的路由
-   */
-  async loadRouter() {
-    const configPath = path.join(Paths.appPath, "modules");
-    if (fs.existsSync(configPath)) {
-      const dirs = loaderSort(Chan.config.modules);
-      for (const item of dirs) {
-        let routerFn = await importFile(path.join(Paths.modulesPath, item, "router.js"));
-        // 为每个模块创建子路由并添加前缀
-        const subRouter = express.Router();
-        routerFn(this.app, subRouter, Chan.config);
-        this.app.use(`/${item}`, subRouter);
-      }
-    }
-  }
-
-  /**
-   * 加载公共路由
-   * @async
-   * @returns {Promise<void>}
-   * @description 加载 app/router.js 中的公共路由
-   */
-  async loadCommonRouter() {
-    let router = await importFile(path.join(Paths.appPath, "router.js"));
-    if (router) {
-      router(this.app, this.router, Chan.config);
-    }
-  }
-
-  /**
-   * 准备启动
-   * @param {Function} [cb] - 回调函数
-   * @description 启动 HTTP 服务，并按配置挂载 WebSocket（SSE 由业务侧通过 sse.middleware() 注册路由）
-   */
-  run(cb) {
-    this.server = this.app.listen(Chan.config.PORT, () => {
-        console.log(`Server running on port ${Chan.config.PORT}`);
-        cb?.(Chan.config.PORT);
-      });
-
-    // 跟踪所有 HTTP socket，用于优雅停机时主动销毁（避免 keep-alive 卡住 server.close）
-    this._sockets = new Set();
-    this.server.on('connection', (socket) => {
-      this._sockets.add(socket);
-      socket.on('close', () => this._sockets.delete(socket));
-    });
-
-    // 按配置挂载 WebSocket（config.WEBSOCKET.enabled = true 时启用）
-    this._attachWebSocket();
-    // 注册 SIGTERM / SIGINT 信号处理，支持优雅停机
-    this._registerSignalHandlers();
-  }
-
-  /**
-   * 挂载 WebSocket 服务到 HTTP server
-   * @private
-   * @description 根据 config.WEBSOCKET 配置自动挂载，业务侧通过 Chan.websocket 使用
-   * @example
-   * // config.js
-   * module.exports = {
-   *   WEBSOCKET: { enabled: true, path: '/ws', heartbeatInterval: 30000 }
-   * };
-   * // 业务侧
-   * import { websocket } from 'chanjs';
-   * websocket.on('chat', (socket, payload) => { ... });
-   */
-  _attachWebSocket() {
-    const wsConfig = Chan.config?.WEBSOCKET || {};
-    if (!wsConfig.enabled) return;
-
-    try {
-      websocket.attach(this.server, {
-        path: wsConfig.path || '/ws',
-        heartbeatInterval: wsConfig.heartbeatInterval,
-        verifyClient: wsConfig.verifyClient,
-        onConnection: wsConfig.onConnection,
-      });
-      // 暴露到 Chan 静态属性，便于业务侧通过 import Chan 访问
-      Chan.websocket = websocket;
-    } catch (err) {
-      console.error('[Chan] WebSocket 挂载失败:', err.message);
-    }
-  }
-}
-
-// 不再使用 global.Chan 全局污染
-// 业务侧通过 `import Chan from 'chanjs'` 获取同一个类引用（ESM 模块缓存保证单例）
-// 框架内部直接使用类名 Chan（同一模块作用域）
-
-export default Chan;