chanjs 2.7.3 → 2.7.5

package/base/Aop.js

@@ -1,195 +0,0 @@
-/**
- * @description: 轻量级切面类 用于注册和执行切面函数
- * @class Aop
- * @property {Map} aspects - 存储注册的切面函数
- * @property {Set} types - 切面类型集合（内置关键字）
- */
-export class Aop {
-  // 定义内置的切面类型关键字（避免和切面名称冲突）
-  static TYPES = new Set(['type', 'enabled']);
-  // 支持的切面类型（仅保留常用的3种）
-  static SUPPORTED_TYPES = new Set(['before', 'after', 'error']);
-  // 幂等标记 Symbol，避免 wrap 多次嵌套包装
-  static WRAP_FLAG = Symbol('aop.wrapped');
-
-  constructor() {
-    this.aspects = new Map();
-  }
-
-  /**
-   * 注册切面
-   * @param {string} name - 切面名称
-   * @param {Function} fn - 切面函数
-   * @returns {Aop} - 当前实例（链式调用）
-   * @throws {TypeError} - 入参类型错误时抛出
-   */
-  set(name, fn) {
-    if (typeof name !== 'string' || !name.trim()) {
-      throw new TypeError(`切面名称 ${name} 必须是非空字符串`);
-    }
-    if (typeof fn !== 'function') {
-      throw new TypeError(`切面 ${name} 必须是函数，当前类型：${typeof fn}`);
-    }
-    this.aspects.set(name.trim(), fn);
-    return this;
-  }
-
-  /**
-   * 获取已注册的切面函数
-   * @param {string} name - 切面名称
-   * @returns {Function|null} - 切面函数（不存在则返回null）
-   */
-  get(name) {
-    return this.aspects.get(name?.trim()) || null;
-  }
-
-  /**
-   * 移除指定切面
-   * @param {string} name - 切面名称
-   * @returns {Aop} - 当前实例
-   */
-  remove(name) {
-    this.aspects.delete(name?.trim());
-    return this;
-  }
-
-  /**
-   * 清空所有切面
-   * @returns {Aop} - 当前实例
-   */
-  clear() {
-    this.aspects.clear();
-    return this;
-  }
-
-  /**
-   * 绑定切面到实例方法
-   * @param {object} instance - 目标实例（如 new Controller()）
-   * @param {object} config - 切面配置 { methodName: [{ type: 'before', enabled: true, log: true }] }
-   * @returns {object} - 绑定后的实例对象
-   * @throws {TypeError} - 入参类型错误时抛出
-   * @description
-   * 幂等性：用 Symbol 标记已包装的方法，避免多次调用 wrap 导致嵌套
-   * 同一方法第二次 wrap 会跳过，防止切面函数被重复执行
-   */
-  wrap(instance, config) {
-    if (typeof instance !== 'object' || instance === null) {
-      throw new TypeError('instance 必须是非空对象');
-    }
-    if (typeof config !== 'object' || config === null) {
-      throw new TypeError('config 必须是非空对象');
-    }
-
-    Object.entries(config).forEach(([methodName, rules]) => {
-      const originalMethod = instance[methodName];
-      if (typeof originalMethod !== 'function') {
-        console.warn(`[AOP警告] 实例不存在方法 ${methodName}，跳过切面绑定`);
-        return;
-      }
-
-      // 幂等检查：已包装过的方法直接跳过，避免多次 wrap 嵌套
-      if (originalMethod[Aop.WRAP_FLAG]) {
-        console.warn(`[AOP警告] 方法 ${methodName} 已包装过切面，跳过重复绑定`);
-        return;
-      }
-
-      // 统一规则为数组 + 过滤禁用规则 + 过滤不支持的类型
-      const ruleList = Array.isArray(rules) ? rules : [rules];
-      const validRules = ruleList.filter(rule => {
-        return rule?.enabled !== false && Aop.SUPPORTED_TYPES.has(rule?.type);
-      });
-
-      // 无有效规则时直接返回原方法
-      if (validRules.length === 0) return;
-
-      // 包装原方法（仅保留 before/after/error 逻辑）
-      const wrapped = async (...args) => {
-        const ctx = instance;
-        let result;
-
-        try {
-          // 执行前置切面
-          await this._executeAspectByType(ctx, validRules, 'before', args, originalMethod);
-
-          // 执行原方法
-          result = await Reflect.apply(originalMethod, ctx, args);
-
-          // 执行后置切面（仅无异常时执行）
-          await this._executeAspectByType(ctx, validRules, 'after', args, originalMethod, result);
-        } catch (error) {
-          // 执行异常切面
-          await this._executeAspectByType(ctx, validRules, 'error', args, originalMethod, null, error);
-          throw error; // 重新抛出异常，不阻断流程
-        }
-
-        return result;
-      };
-
-      // 打幂等标记，防止重复 wrap
-      wrapped[Aop.WRAP_FLAG] = true;
-      // 保留原方法名，便于调试
-      Object.defineProperty(wrapped, 'name', { value: originalMethod.name, configurable: true });
-      instance[methodName] = wrapped;
-    });
-
-    return instance;
-  }
-
-  /**
-   * 按类型批量执行切面（私有方法）
-   * @private
-   * @param {object} ctx - 上下文
-   * @param {Array} validRules - 有效规则列表
-   * @param {string} type - 切面类型（before/after/error）
-   * @param {Array} args - 方法参数
-   * @param {Function} originalMethod - 原方法
-   * @param {*} result - 方法执行结果
-   * @param {Error} error - 方法执行错误
-   */
-  async _executeAspectByType(ctx, validRules, type, args, originalMethod, result = null, error = null) {
-    const rulesOfType = validRules.filter(rule => rule.type === type);
-    for (const rule of rulesOfType) {
-      await this._executeSingleRule(ctx, rule, args, originalMethod, result, error);
-    }
-  }
-
-  /**
-   * 执行单个切面规则（私有方法）
-   * @private
-   * @param {object} ctx - 上下文
-   * @param {object} rule - 单个切面规则
-   * @param {Array} args - 方法参数
-   * @param {Function} originalMethod - 原方法
-   * @param {*} result - 方法执行结果
-   * @param {Error} error - 方法执行错误
-   */
-  async _executeSingleRule(ctx, rule, args, originalMethod, result = null, error = null) {
-    for (const [key, value] of Object.entries(rule)) {
-      // 跳过内置关键字 + 空值
-      if (Aop.TYPES.has(key) || !value) continue;
-
-      const aspectFn = this.get(key);
-      if (!aspectFn) {
-        console.warn(`[AOP警告] 未注册切面 ${key}，跳过执行`);
-        continue;
-      }
-
-      // 构造切面入参（浅拷贝避免原数据被修改）
-      const aspectParams = {
-        ctx,
-        methodName: originalMethod.name || 'anonymous',
-        args: [...args],
-        originalMethod,
-        result,
-        error,
-        params: typeof value === 'object' && !Array.isArray(value) ? { ...value } : {}
-      };
-
-      await aspectFn(aspectParams);
-    }
-  }
-}
-
-// 全局单例
-export const aop = new Aop();
-export default Aop;

package/base/Container.js

@@ -1,161 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { Paths } from '../config/paths.js';
-import Chan from '../App.js';
-
-/**
- * 容器基类（依赖注入容器）
- *
- * ============================================================
- * 设计说明
- * ============================================================
- * 不再使用 global.Chan 全局污染。
- * 通过 import Chan 获取应用类引用，所有资源（config/db/paths 等）
- * 都通过 Chan 类的静态属性动态访问，避免构造时快照导致的不同步问题。
- *
- * 子类（Controller/Repository）可通过以下方式获取应用资源：
- * - this.app           → Chan 类本身（静态属性容器）
- * - this.app.config    → 应用配置
- * - this.app.db        → 默认数据库连接
- * - this.app.dbManager → 数据库连接管理器
- * - this.app.paths     → 路径配置（兼容 Chan.paths）
- *
- * ============================================================
- * DI 方法
- * ============================================================
- * - get(moduleName, fileName)  → 加载业务模块组件（service/controller）
- * - getResource(name)           → 获取应用级资源（config/db/dbManager/paths）
- */
-export class Container {
-  constructor(type = 'service') {
-    this.map = new Map();
-    // 组件类型，例如：'service','controller'
-    this.type = type;
-    // modules 目录路径
-    this.baseDir = Paths.modulesPath;
-    // 应用类引用（DI 核心：通过它访问 config/db 等静态资源）
-    this.app = Chan;
-  }
-
-  /**
-   * 获取应用级资源（显式 DI）
-   * @param {string} name - 资源名：'config' | 'db' | 'dbManager' | 'paths'
-   * @returns {*} 对应的资源
-   * @example
-   * const config = this.getResource('config');
-   * const db = this.getResource('db');
-   */
-  getResource(name) {
-    return Chan[name];
-  }
-
-  /**
-   * config 快捷访问（getter 动态读取，避免快照不同步）
-   */
-  get config() {
-    return Chan.config;
-  }
-
-  /**
-   * db 快捷访问（getter 动态读取）
-   */
-  get db() {
-    return Chan.db;
-  }
-
-  /**
-   * paths 快捷访问（getter 动态读取）
-   */
-  get paths() {
-    return Chan.paths || Paths;
-  }
-
-  /**
-   * 获取模块下的组件实例
-   * @param {string} moduleName - 模块名 ，例如：'web','api'
-   * @param {string} fileName - 文件名
-   * @returns {Promise<any>} - 组件实例
-   */
-  async get(moduleName, fileName) {
-    const key = `${moduleName}.${fileName}`;
-    // 如果组件实例已存在，直接返回
-    if (this.map.has(key)) {
-      return this.map.get(key);
-    }
-
-    try {
-      // 没有，加载组件实例
-      await this.loadFile(moduleName, fileName);
-      const obj = this.map.get(key);
-      if (!obj) {
-        console.log(`文件 ${fileName}.js 加载后组件实例为空`);
-      }
-      return obj;
-    } catch (err) {
-      console.error(`获取模块 ${moduleName} 下文件 ${fileName}.js 对应的组件失败：${err.message}`);
-      return null;
-    }
-  }
-
-  /**
-   * 设置模块下的组件实例
-   * @param {string} moduleName - 模块名 ，例如：'web','api'
-   * @param {string} fileName - 文件名
-   * @param {any} obj - 组件实例
-   * @returns {Container} - 当前实例
-   */
-  set(moduleName, fileName, obj) {
-    const key = `${moduleName}.${fileName}`;
-    this.map.set(key, obj);
-    return this;
-  }
-
-  /**
-   * 加载模块下的组件实例
-   * @param {string} moduleName - 模块名 ，例如：'web','api'
-   * @param {string} fileName - 文件名
-   * @returns {Promise<any>} - 组件实例
-   * @description
-   * 安全改进：
-   * - 名称白名单校验（仅允许字母开头、字母数字下划线/横线），拒绝路径注入
-   * - 解析后路径必须仍在 baseDir 内，防止路径越界
-   * - 用 fs.promises.access 替代 existsSync，避免同步 IO 阻塞事件循环
-   */
-  async loadFile(moduleName, fileName) {
-    // 模块/文件名白名单：字母开头，允许字母数字下划线横线
-    const NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
-    if (!NAME_REGEX.test(moduleName) || !NAME_REGEX.test(fileName)) {
-      throw new Error(`非法模块/文件名: ${moduleName}/${fileName}`);
-    }
-
-    const filePath = path.resolve(
-      this.baseDir,
-      moduleName,
-      this.type,
-      `${fileName}.js`
-    );
-
-    // 路径越界检查：解析后必须仍在 baseDir 内
-    const rel = path.relative(this.baseDir, filePath);
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
-      throw new Error(`路径越界: ${filePath}`);
-    }
-
-    // 异步检查文件存在性，避免同步 IO
-    try {
-      await fs.promises.access(filePath, fs.constants.R_OK);
-    } catch (e) {
-      console.log(`模块 ${moduleName} 下 ${this.type} 目录中未找到文件：${fileName}.js`);
-      return null;
-    }
-
-    const module = await import(`file://${filePath}`);
-    const obj = module.default;
-
-    const key = `${moduleName}.${fileName}`;
-    this.map.set(key, obj);
-    return obj;
-  }
-}
-
-export default Container;

package/base/Controller.js

@@ -1,65 +0,0 @@
-import { success, fail } from "../response/response.js";
-import Container from "./Container.js";
-
-/**
- * 控制器基类
- * 提供统一的响应格式和常用方法
- *
- * ============================================================
- * 响应格式（三层 code 体系）
- * ============================================================
- * 所有响应都遵循：{ success, code, msg, data }
- * - code: 0 成功 / 1xxx 业务 / 5xxx 系统 / 6xxx 数据库
- * - HTTP Status 由网关/Express 控制，与业务 code 解耦
- *
- * 使用示例：
- * this.success(data)                       // → code: 0
- * this.success({ data, msg: '创建成功' })   // → code: 0
- * this.fail({ msg: '栏目下存在文章' })     // → code: 1008 业务失败
- * this.fail({ msg: '参数缺失', code: 1007 }) // → code: 1007
- * this.fail('密码错误')                    // 字符串简写，→ code: 1008
- */
-export default class Controller extends Container {
-  constructor() {
-    // 调用父类构造函数，指定组件类型为 'controller'
-    super('controller');
-  }
-
-  /**
-   * 返回成功响应
-   * @param {Object} options - 响应选项
-   * @param {*} options.data - 响应数据
-   * @param {string} [options.msg="操作成功"] - 响应消息
-   * @returns {Object} 标准成功响应，code = 0
-   */
-  success({ data, msg = "操作成功" } = {}) {
-    return success({ data, msg });
-  }
-
-  /**
-   * 返回失败响应
-   * @param {Object|string} options - 响应选项，或失败消息字符串（简写）
-   * @param {string} [options.msg="操作失败"] - 失败消息
-   * @param {*} [options.data={}] - 响应数据
-   * @param {number} [options.code=1008] - 业务 code，默认 1008（业务处理失败）
-   * @returns {Object} 标准失败响应
-   * @description
-   * 兼容两种调用方式：
-   * - 对象：this.fail({ msg: '...', code: 1007 })
-   * - 字符串简写：this.fail('密码错误')  // 等价于 this.fail({ msg: '密码错误' })
-   *
-   * 默认 code = 1008（业务处理失败）
-   * 业务方可指定 code：
-   * - 1001 认证失败 / 1002 token 过期 / 1003 权限不足
-   * - 1004 资源不存在 / 1005 资源已存在
-   * - 1006 参数无效 / 1007 参数缺失
-   * - 1008 业务处理失败（通用兜底）
-   */
-  fail(options = {}) {
-    // 字符串简写：this.fail('错误消息') → this.fail({ msg: '错误消息' })
-    if (typeof options === 'string') {
-      return fail({ msg: options });
-    }
-    return fail(options);
-  }
-}

package/base/Database.js

@@ -1,133 +0,0 @@
-import knex from "knex";
-
-/**
- * 数据库管理器类
- * 用于管理多个数据库连接
- */
-class DatabaseManager {
-  /**
-   * 构造函数
-   * 初始化数据库连接存储和默认连接名称
-   */
-  constructor() {
-    this._connections = new Map();
-    this._defaultName = "default";
-  }
-
-  /**
-   * 添加数据库连接
-   * @param {string} name - 连接名称
-   * @param {Object} config - Knex配置对象
-   * @param {Object} options - 选项
-   * @param {boolean} options.isDefault - 是否设为默认连接
-   * @returns {Object} Knex连接实例
-   */
-  add(name, config, options = {}) {
-    const { isDefault = false } = options;
-
-    const connection = knex(config);
-    this._connections.set(name, connection);
-
-    if (isDefault || this._connections.size === 1) {
-      this._defaultName = name;
-    }
-
-    return connection;
-  }
-
-  /**
-   * 获取数据库连接
-   * @param {string} name - 连接名称，默认为默认连接
-   * @returns {Object} Knex连接实例
-   * @throws {Error} 连接不存在时抛出异常
-   */
-  get(name = this._defaultName) {
-    const connection = this._connections.get(name);
-    if (!connection) {
-      throw new Error(`Database connection "${name}" not found`);
-    }
-    return connection;
-  }
-
-  /**
-   * 获取默认数据库连接
-   * @returns {Object} Knex连接实例
-   */
-  getDefault() {
-    return this.get(this._defaultName);
-  }
-
-  /**
-   * 检查连接是否存在
-   * @param {string} name - 连接名称
-   * @returns {boolean} 是否存在
-   */
-  has(name) {
-    return this._connections.has(name);
-  }
-
-  /**
-   * 移除数据库连接
-   * @param {string} name - 连接名称
-   */
-  remove(name) {
-    const connection = this._connections.get(name);
-    if (connection) {
-      connection.destroy();
-      this._connections.delete(name);
-    }
-  }
-
-  /**
-   * 关闭所有数据库连接（优雅停机使用）
-   * 单个连接关闭失败不影响其他连接
-   * @returns {Promise<Array<{name:string, success:boolean, error?:string}>>} 每个连接的关闭结果
-   */
-  async closeAll() {
-    const results = [];
-    for (const [name, conn] of this._connections) {
-      try {
-        await conn.destroy();
-        results.push({ name, success: true });
-      } catch (err) {
-        results.push({ name, success: false, error: err.message });
-        console.error(`[Database] 关闭连接 ${name} 失败:`, err.message);
-      }
-    }
-    this._connections.clear();
-    console.log(`[Database] 已关闭所有连接（共 ${results.length} 个）`);
-    return results;
-  }
-
-  /**
-   * 心跳检查（单个连接）
-   * @param {string} [name] - 连接名称，默认检查默认连接
-   * @returns {Promise<boolean>} 是否健康
-   */
-  async ping(name = this._defaultName) {
-    const conn = this._connections.get(name);
-    if (!conn) return false;
-    try {
-      // 用最简 SELECT 1 触发一次实际查询，验证连接可用
-      await conn.raw('SELECT 1');
-      return true;
-    } catch (err) {
-      console.error(`[Database] ping ${name} 失败:`, err.message);
-      return false;
-    }
-  }
-
-  /**
-   * 获取所有连接状态（健康检查 / 监控使用）
-   * @returns {Array<{name:string, isDefault:boolean}>} 连接列表
-   */
-  getStatus() {
-    return Array.from(this._connections.keys()).map(name => ({
-      name,
-      isDefault: name === this._defaultName,
-    }));
-  }
-
-}
-
-export default DatabaseManager;

package/base/Event.js

@@ -1,61 +0,0 @@
-import { EventEmitter } from 'events';
-
-/**
- * 默认最大监听器数量上限，防止业务侧泄漏过多监听器导致内存警告
- */
-const DEFAULT_MAX_LISTENERS = 50;
-
-export class Event extends EventEmitter {
-  constructor() {
-    super();
-    // 设置最大监听器数量，避免业务侧泄漏导致 process 警告
-    this.setMaxListeners(DEFAULT_MAX_LISTENERS);
-    // 兜底 error 监听器：未注册 error 监听时 EventEmitter 默认会抛出并崩溃进程
-    // 这里注册一个仅打印日志的 error 处理器，确保 unhandled error 不会让进程退出
-    this.on('error', (err) => {
-      console.error('[Event] 未处理的 error 事件:', err?.message || err);
-    });
-  }
-
-  /**
-   * 注册事件监听器
-   * @param {string} eventName - 事件名
-   * @param {*} listener - 监听器函数
-   * @returns {Event} - 当前实例
-   */
-  on(eventName, listener) {
-    return super.on(eventName, listener);
-  }
-
-  /**
-   * 触发事件
-   * @param {string} eventName - 事件名
-   * @param {*} data - 事件数据
-   * @returns {Event} - 当前实例
-   */
-  emit(eventName, data) {
-    return super.emit(eventName, data);
-  }
-
-  /**
-   * 注销事件监听器
-   * @param {string} eventName - 事件名
-   * @param {*} listener - 监听器函数
-   * @returns {Event} - 当前实例
-   */
-  off(eventName, listener) {
-    return super.off(eventName, listener);
-  }
-
-  /**
-   * 注销所有事件监听器
-   * @param {string} eventName - 事件名
-   * @returns {Event} - 当前实例
-   */
-  removeAllListeners(eventName) {
-    return super.removeAllListeners(eventName);
-  }
-}
-
-export const event = new Event();
-export default Event;