chanjs 2.7.4 → 2.7.6

package/helper/index.js

@@ -1,79 +0,0 @@
-/**
- * 聚合导出层 - 从各子模块统一 re-export
- *
- * 框架内部已按职责拆分到 storage/security/realtime/schedule/loader/response/utils
- * 本文件提供扁平化聚合访问，业务侧可用：
- *   import { helper } from "chanjs";
- *   const { getIp, formatDateFields, filterXSS } = helper;
- *
- * 也可直接从子模块导入（更精确）：
- *   import { utils, security, storage } from "chanjs";
- */
-
-// 加载器
-export { loaderSort, loadConfig, clearConfigCache, loadController } from "../loader/index.js";
-
-// 时间处理
-export { formatTime, formatDateFields } from "../utils/time.js";
-
-// 存储相关
-export { cache, DEFAULT_INCR_TTL } from "../storage/index.js";
-export { store } from "../storage/index.js";
-export { default as RedisBackend } from "../storage/redis.js";
-
-// 文件操作
-export {
-  dirname,
-  delImg,
-  getFileTree,
-  readFileContent,
-  saveFileContent,
-  isPathSafe,
-  getFolders,
-} from "../utils/file.js";
-
-// HTML 处理
-export { htmlDecode, htmlEncode, escapeScript } from "../utils/html.js";
-
-// IP 获取
-export { getIp } from "../utils/ip.js";
-
-// JWT 令牌
-export { verifyToken, generateToken, setToken, getToken } from "../security/jwt.js";
-
-// 签名/加密
-export { signData, verifySign, aesEncrypt, aesDecrypt } from "../security/sign.js";
-
-// 网络请求
-export { request } from "../utils/request.js";
-
-// 数据解析
-export { dataParse, arrToObj, parseJsonFields, buildTree } from "../utils/data-parse.js";
-
-// 树形结构
-export { tree, treeById } from "../utils/tree.js";
-
-// 字段过滤
-export { filterFields } from "../utils/filter.js";
-
-// 响应格式化
-export {
-  success,
-  fail,
-  error,
-  parseDatabaseError,
-  notFoundResponse,
-  errorResponse,
-} from "../response/index.js";
-
-// 安全检查
-export { checkKeywords, isIgnored } from "../security/checker.js";
-export { filterXSS } from "../security/xss-filter.js";
-export { createRateLimitMiddleware } from "../security/rate-limit.js";
-
-// 定时任务
-export { schedule } from "../schedule/index.js";
-
-// 实时通信
-export { sse, SSEManager } from "../realtime/index.js";
-export { websocket, WebSocketManager } from "../realtime/index.js";

package/loader/index.js

@@ -1,6 +0,0 @@
-/**
- * 加载器模块 - 配置加载/控制器加载/排序
- * - loadConfig: 依赖 ESM 模块缓存（无 LRU，避免配置更新问题）
- * - loadController: Symbol 标记幂等绑定
- */
-export { loaderSort, loadConfig, clearConfigCache, loadController } from "./loader.js";

package/loader/loader.js

@@ -1,138 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Paths } from "../config/paths.js";
-
-/**
- * 对模块列表进行排序，将 web 模块移到最后
- * @param {Array<string>} modules - 模块名称数组
- * @returns {Array<string>} 排序后的模块数组
- * @description
- * 确保 web 模块始终在模块列表的最后，以便优先加载其他模块的路由
- * @example
- * const modules = ['api', 'web', 'admin'];
- * const sorted = loaderSort(modules);
- * // 返回: ['api', 'admin', 'web']
- */
-export function loaderSort(modules = []) {
-  const index = modules.indexOf("web");
-  if (index !== -1) {
-    const web = modules.splice(index, 1);
-    modules.push(web[0]);
-  }
-  return modules;
-}
-
-/**
- * 加载应用配置文件
- * @async
- * @returns {Promise<Object>} 配置对象
- * @description
- * 从 config/index.js 加载配置
- *
- * 性能优化（P2 #21）：
- * 删除 LRU 缓存层，直接依赖 ESM 模块缓存
- * - ESM import 同一文件返回缓存的模块实例（Node.js 内置机制）
- * - 旧版 LRU 缓存有 5 分钟 TTL，配置变更后不生效，需要手动 clearConfigCache
- * - 现在配置变更直接重启进程即可，符合生产实践
- */
-export async function loadConfig() {
-  const configPath = path.join(Paths.configPath, "index.js");
-  try {
-    const module = await import(`file://${configPath}`);
-    return module.default || module;
-  } catch (error) {
-    console.error("[Config] 加载配置失败", error.message);
-    return {};
-  }
-}
-
-/**
- * 清除配置缓存（已废弃）
- * @deprecated P2 #21 优化后，配置直接依赖 ESM 缓存，无需手动清理
- * 保留函数仅为向后兼容，调用为空操作
- * @example
- * clearConfigCache(); // 空操作，无需调用
- */
-export function clearConfigCache() {
-  // ESM 模块缓存由 Node.js 管理，无需手动清理
-}
-
-/**
- * 已绑定方法标记（Symbol 幂等）
- * 避免重复 loadController 时对同一方法多次 bind 形成嵌套
- * @private
- */
-const BOUND_SYMBOL = Symbol('chanjs:bound');
-
-/**
- * 加载指定模块的所有控制器
- * @async
- * @param {string} moduleName - 模块名称
- * @returns {Promise<Object>} 控制器对象，键为控制器名称
- * @description
- * 从 modules/{moduleName}/controller 目录加载所有 .js 文件
- * 每个文件会被加载并绑定实例，然后以文件名作为键存储
- *
- * 性能优化（P2 #18）：
- * - 用 Symbol 标记已 bind 过的方法，避免重复 bind 形成嵌套
- * - ESM 模块缓存导致同一实例可能被多次 loadController，原版每次都重新 bind
- * - 现在首次 bind 后标记，后续调用直接跳过
- *
- * @example
- * const controllers = await loadController('api');
- * console.log(controllers.User); // User 控制器实例
- */
-export async function loadController(moduleName) {
-  const controller = {};
-
-  const dir = path.join(Paths.modulesPath, moduleName, "controller");
-
-  if (!fs.existsSync(dir)) {
-    console.error(`模块路径不存在，跳过加载控制器: ${dir}`);
-    return controller;
-  }
-
-  const files = fs.readdirSync(dir).filter((file) => file.endsWith(".js"));
-
-  for (const file of files) {
-    const filePath = path.join(dir, file);
-    const name = file.replace(/\.js$/i, "");
-
-    try {
-      const module = await import(`file://${filePath}`);
-      let instance = module?.default || module;
-
-      // 绑定实例的所有方法（Symbol 幂等，避免重复 bind）
-      if (instance && typeof instance === 'object') {
-        const proto = Object.getPrototypeOf(instance);
-        if (proto) {
-          Object.getOwnPropertyNames(proto).forEach((methodName) => {
-            if (
-              methodName !== "constructor" &&
-              typeof instance[methodName] === "function"
-            ) {
-              const method = instance[methodName];
-              // 已 bind 过的方法直接跳过（避免重复 bind 嵌套）
-              if (method[BOUND_SYMBOL]) return;
-              // bind 创建新函数，标记后存回实例
-              const bound = method.bind(instance);
-              Object.defineProperty(bound, BOUND_SYMBOL, {
-                value: true,
-                enumerable: false,
-                writable: false,
-                configurable: false,
-              });
-              instance[methodName] = bound;
-            }
-          });
-        }
-      }
-
-      controller[name] = instance;
-    } catch (e) {
-      console.error(`加载控制器失败: ${filePath}`, e);
-    }
-  }
-
-  return controller;
-}

package/middleware/compress.js

@@ -1,185 +0,0 @@
-import zlib from 'zlib';
-
-/**
- * 响应压缩中间件（零依赖，基于 Node 原生 zlib）
- * 改进点：
- * 1. 支持 br / gzip / deflate，按 Accept-Encoding 优先级选择
- * 2. 仅压缩可压缩文本类型（html/css/js/json/plain/svg+xml）
- * 3. 跳过 SSE（text/event-stream）和 WebSocket 升级请求
- * 4. 阈值 1KB，避免小包压缩负收益
- * 5. 压缩失败自动回退原样输出，不影响请求
- * 6. chunks 缓冲上限 10MB，超出后 bypass 直接放行不压缩，避免内存爆炸
- * 7. 拦截 res.write/res.end 后在 finish/close 时恢复，避免泄漏
- */
-
-// 压缩阈值：响应体 > 1KB 才压缩
-const DEFAULT_THRESHOLD = 1024;
-
-// chunks 缓冲上限：10MB，超出后 bypass 直接放行不压缩
-const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
-
-// 可压缩的 Content-Type 集合（精确匹配，charset 后缀在判断时已剥离）
-const COMPRESSIBLE_TYPES = new Set([
-  'text/html',
-  'text/css',
-  'application/json',
-  'application/javascript',
-  'text/plain',
-  'image/svg+xml',
-]);
-
-/**
- * 根据 Accept-Encoding 选择最优编码
- * 优先级：br > gzip > deflate
- * @param {string} acceptEncoding - 请求头 Accept-Encoding 值
- * @returns {'br'|'gzip'|'deflate'|null}
- */
-function pickEncoding(acceptEncoding) {
-  if (!acceptEncoding) return null;
-  const enc = acceptEncoding.toLowerCase();
-  if (enc.includes('br')) return 'br';
-  if (enc.includes('gzip')) return 'gzip';
-  if (enc.includes('deflate')) return 'deflate';
-  return null;
-}
-
-/**
- * 使用 Node 原生 zlib 同步压缩 Buffer
- * @param {Buffer} buf - 待压缩数据
- * @param {'br'|'gzip'|'deflate'} encoding - 压缩编码
- * @returns {Buffer} 压缩后的 Buffer
- */
-function compressBuffer(buf, encoding) {
-  switch (encoding) {
-    case 'br':      return zlib.brotliCompressSync(buf);
-    case 'gzip':    return zlib.gzipSync(buf);
-    case 'deflate': return zlib.deflateSync(buf);
-    default:        return buf;
-  }
-}
-
-/**
- * 创建压缩中间件
- * @param {Object} [options]
- * @param {number} [options.threshold=1024] - 压缩阈值（字节），响应体小于该值不压缩
- * @returns {Function} Express 中间件
- */
-export function compress(options = {}) {
-  const threshold = options.threshold || DEFAULT_THRESHOLD;
-
-  return (req, res, next) => {
-    // WebSocket 升级请求直接跳过（不适用 HTTP 响应压缩）
-    if (req.headers.upgrade && req.headers.upgrade.toLowerCase() === 'websocket') {
-      return next();
-    }
-
-    const encoding = pickEncoding(req.headers['accept-encoding'] || '');
-    // 客户端不支持任何压缩编码，直接放行
-    if (!encoding) return next();
-
-    // 缓存原方法（bind 避免 this 丢失）
-    const originalEnd = res.end.bind(res);
-    const originalWrite = res.write.bind(res);
-    const chunks = [];
-    let totalSize = 0;
-    let bypassed = false;  // 超过缓冲上限后 bypass 标志
-
-    // 恢复 res.write/res.end 的函数：在 finish/close 时调用，避免拦截函数泄漏
-    const restore = () => {
-      res.write = originalWrite;
-      res.end = originalEnd;
-    };
-
-    // 拦截 res.write：收集 buffer 片段（流式输出场景）
-    res.write = (chunk, ...args) => {
-      if (bypassed) return originalWrite(chunk, ...args);
-      if (chunk) {
-        if (typeof chunk === 'string') {
-          chunk = Buffer.from(chunk, args[0] || 'utf8');
-        }
-        if (Buffer.isBuffer(chunk)) {
-          chunks.push(chunk);
-          totalSize += chunk.length;
-          // 缓冲超限：bypass 直接放行后续 write/end
-          if (totalSize > MAX_BUFFER_BYTES) {
-            console.warn(`[compress] 响应体超过 ${MAX_BUFFER_BYTES} 字节，bypass 直接放行不压缩`);
-            bypassed = true;
-          }
-        }
-      }
-      return true;
-    };
-
-    // 拦截 res.end：收集最后一片 buffer 后决定是否压缩
-    res.end = (chunk, encodingArg) => {
-      if (bypassed) {
-        // bypass 模式：直接走原 end，恢复后退出
-        restore();
-        if (chunk) return originalEnd(chunk, encodingArg);
-        return originalEnd();
-      }
-
-      // res.end 多种签名处理：end() / end(chunk) / end(chunk, encoding) / end(callback)
-      if (chunk) {
-        if (typeof chunk === 'string') {
-          const buf = Buffer.from(chunk, typeof encodingArg === 'string' ? encodingArg : 'utf8');
-          chunks.push(buf);
-          totalSize += buf.length;
-        } else if (Buffer.isBuffer(chunk)) {
-          chunks.push(chunk);
-          totalSize += chunk.length;
-        }
-        // function 类型为 end(callback) 签名，不收集
-      }
-
-      const body = chunks.length ? Buffer.concat(chunks) : Buffer.alloc(0);
-
-      // 取 Content-Type 主类型（去掉 charset 等参数）
-      const contentType = (res.getHeader('Content-Type') || '').toString().split(';')[0].trim().toLowerCase();
-
-      // 不满足压缩条件：原样输出
-      // - 响应体小于阈值
-      // - 非可压缩类型
-      // - SSE（text/event-stream）需要实时推送，不压缩
-      if (
-        body.length < threshold ||
-        !COMPRESSIBLE_TYPES.has(contentType) ||
-        contentType === 'text/event-stream'
-      ) {
-        if (!res.headersSent) {
-          res.setHeader('Content-Length', body.length);
-        }
-        restore();
-        originalEnd(body);
-        return res;
-      }
-
-      // 执行压缩
-      try {
-        const compressed = compressBuffer(body, encoding);
-        // 移除原 Content-Length，避免与压缩后大小不匹配
-        res.removeHeader('Content-Length');
-        res.setHeader('Content-Encoding', encoding);
-        res.setHeader('Vary', 'Accept-Encoding');
-        res.setHeader('Content-Length', compressed.length);
-        restore();
-        originalEnd(compressed);
-      } catch (e) {
-        // 压缩失败：回退原样输出，避免请求中断
-        console.error('[compress] 压缩失败，回退原样输出:', e.message);
-        if (!res.headersSent) {
-          res.setHeader('Content-Length', body.length);
-        }
-        restore();
-        originalEnd(body);
-      }
-      return res;
-    };
-
-    // 响应结束后恢复，防止 res.write/res.end 拦截泄漏到后续中间件复用
-    res.on('finish', restore);
-    res.on('close', restore);
-
-    next();
-  };
-}

package/middleware/setBody.js

@@ -1,32 +0,0 @@
-import express from "express";
-
-/**
- * 请求体解析中间件配置
- * 配置请求体的解析方式
- */
-
-/**
- * 设置请求体解析中间件
- * @param {Object} app - Express 应用实例
- * @param {string} JSON_LIMIT - JSON 请求体大小限制
- * @description
- * 为 Express 应用配置请求体解析中间件
- * 支持 JSON、URL 编码和 XML 格式的请求体
- *
- * 安全改进：
- * - urlencoded 也设置 limit 和 parameterLimit，防止参数爆炸攻击
- * - extended: true 支持嵌套对象（与 qs 行为对齐）
- * @example
- * setBody(app, '10mb');
- */
-let setBody = function (app, JSON_LIMIT) {
-  app.use(express.raw({ type: "application/xml", limit: JSON_LIMIT }));
-  app.use(express.json({ limit: JSON_LIMIT }));
-  app.use(express.urlencoded({
-    extended: true,
-    limit: JSON_LIMIT,
-    parameterLimit: 100,
-  }));
-};
-
-export { setBody };

package/realtime/index.js

@@ -1,7 +0,0 @@
-/**
- * 实时通信模块 - SSE + WebSocket（零第三方依赖）
- * - sse: Server-Sent Events，单向推送
- * - websocket: 基于 Node.js v22.4.0+ 原生 WebSocket API
- */
-export { sse, SSEManager } from "./sse.js";
-export { websocket, WebSocketManager } from "./websocket.js";