chanjs 2.5.9 → 2.6.1

package/App.js

@@ -3,17 +3,14 @@ import fs from "fs";
 import path from "path";
 
 // 引入基础组件
-import Controller from "./base/Controller.js";
-import Service from "./base/Service.js";
 import DatabaseManager from "./base/Database.js";
 
 // 引入配置和工具
 import { Paths } from "./config/index.js";
-import { getChildrenId, filterBody, filterImgFromStr, CODE as commonCode, sendMail, genRegEmailHtml, genResetPasswordEmail, pages, getHtmlFilesSync } from "./common/index.js";
-import { loadConfig, loadController, loaderSort, formatDateFields, request, delImg, getIp, setToken, getToken, verifyToken, generateToken, getFileTree, readFileContent, saveFileContent, isPathSafe, getFolders, arrToObj, htmlDecode } from "./helper/index.js";
+import { loadConfig, loaderSort, loadController } from "./helper/index.js";
 import { Cors, setBody, setCookie, setFavicon, setHeader, setStatic, setTemplate, waf, log } from "./middleware/index.js";
-import { errorResponse, notFoundResponse, parseDatabaseError, error as responseError, fail, success, checkKeywords } from "./utils/index.js";
-import { importFile, importjs } from "./global/import.js";
+import { notFoundResponse, parseDatabaseError, error as responseError } from "./utils/index.js";
+import { importFile } from "./global/import.js";
 
 import "./global/index.js";
 
@@ -27,62 +24,6 @@ import "./global/index.js";
  */
 class Chan {
 
-  // 静态属性：提供全局访问的辅助函数和工具
-  static helper = {
-    loadController,
-    loaderSort,
-    loadConfig,
-    formatDateFields,
-    request,
-    delImg,
-    getIp,
-    setToken,
-    getToken,
-    verifyToken,
-    generateToken,
-    getFileTree,
-    readFileContent,
-    saveFileContent,
-    isPathSafe,
-    getFolders,
-    arrToObj,
-    htmlDecode,
-  };
-
-  // 静态属性：提供全局访问的常用业务函数和工具
-  static common = {
-    success,
-    fail,
-    error: responseError,
-    getChildrenId,
-    CODE: commonCode,
-    sendMail,
-    genRegEmailHtml,
-    genResetPasswordEmail,
-    pages,
-    getHtmlFilesSync,
-    filterBody,
-    filterImgFromStr,
-  };
-
-  // 静态属性：提供全局访问的配置
-  static config = {};
-  // 静态属性：提供全局访问的数据库
-  static db = {};
-  // 静态属性：提供全局访问的服务类
-  static Service = Service;
-  // 静态属性：提供全局访问的控制器类
-  static Controller = Controller;
-  // 静态属性：提供全局访问的路径配置
-  static paths = Paths;
-  // 静态属性：提供全局访问的导入函数
-  static importFile = importFile;
-  static importjs = importjs;
-  // 静态属性：提供全局访问的工具函数
-  static utils = {
-    checkKeywords,
-  };
-
   /**
    * 构造函数
    * @constructor
@@ -106,6 +47,7 @@ class Chan {
   async start() {
     //加载配置
     await this.config();
+    
     //加载数据库
     await this.loadDB();
     //加载扩展方法
@@ -130,9 +72,7 @@ class Chan {
    */
   async config() {
     let config = await loadConfig();
-    console.log('[App.config] 开始加载配置，config keys:', Object.keys(config));
     Chan.config = config;
-    console.log('[App.config] 配置加载完成，Chan.config.modules:', Chan.config.modules);
   }
 
   /**
@@ -143,26 +83,24 @@ class Chan {
    */
   async loadDB() {
     const dbList = Chan.config?.db || [];
-
     for (const [index, item] of dbList.entries()) {
       const key = item.key || String(index);
       try {
         const dbConfig = item;
-        if (!dbConfig) throw new Error("未找到配置");
-
+        if (!dbConfig) {
+          console.error(`[DB] 数据库 ${key} 未找到数据库配置`);
+          return;
+        };
         const connection = this.dbManager.add(key, dbConfig, { isDefault: index === 0 });
-
         if (index === 0) {
-          Chan.db = connection;
+          Chan.db = this.dbManager.get();
         }
       } catch (error) {
         console.error(`[DB] 数据库 ${key} 初始化失败: ${error.message}`);
       }
     }
 
-    console.log(
-      `[DB] 初始化完成，已加载 ${dbList.length} 个数据库`,
-    );
+    console.log(`[DB] 初始化完成，已加载 ${dbList.length} 个数据库`);
   }
 
   /**
@@ -181,6 +119,11 @@ class Chan {
     for (const { _path, key } of extensions) {
       await this.loadFn(_path, key);
     }
+
+    if (!Chan.helper) {
+      Chan.helper = {};
+    }
+    Chan.helper.loadController = loadController;
   }
 
   /**
@@ -196,7 +139,10 @@ class Chan {
       const files = fs.readdirSync(_path).filter((file) => file.endsWith(".js"));
       for (const file of files) {
         const filePath = path.join(_path, file);
-        let helperModule = await Chan.importFile(filePath);
+        let helperModule = await importFile(filePath);
+        if (!Chan[key]) {
+          Chan[key] = {};
+        }
         Object.assign(Chan[key], helperModule);
       }
     }
@@ -292,7 +238,7 @@ class Chan {
 
       const parsedError = parseDatabaseError(err);
       console.error(`[Global Error Details] Database Error - ${parsedError.msg}`);
-      res.status(parsedError.statusCode).json(errorResponse(err, req));
+      res.status(parsedError.statusCode).json(responseError(err, req));
     });
   }
 
@@ -350,8 +296,11 @@ class Chan {
     if (fs.existsSync(configPath)) {
       const dirs = loaderSort(Chan.config.modules);
       for (const item of dirs) {
-        let router = await Chan.importFile(`app/modules/${item}/router.js`);
-        router(this.app, this.router, Chan.config);
+        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);
       }
     }
   }
@@ -363,7 +312,7 @@ class Chan {
    * @description 加载 app/router.js 中的公共路由
    */
   async loadCommonRouter() {
-    let router = await Chan.importFile("app/router.js");
+    let router = await importFile(path.join(Paths.appPath, "router.js"));
     if (router) {
       router(this.app, this.router, Chan.config);
     }

package/README.md

@@ -1,104 +1,348 @@
-
 # Chanjs
 
-Chanjs 是一个基于 Express5+ 构建的轻量级 MVC 框架，完全使用 JavaScript 开发。它体现了函数式编程的概念，提供了卓越的性能、清晰的代码和易于遵循的过程，确保了高可维护性。
+Chanjs 是一个基于 Express 5+ 构建的轻量级 MVC 框架，完全使用 JavaScript 开发。它体现了函数式编程的概念，提供了卓越的性能、清晰的代码和易于遵循的过程，确保了高可维护性。
 
 ## 特点
 
-- 基于 Express 构建
-- 支持 ES6 语法
-- 模块化设计
-  - 多模块化路由
-  - 模块化 views
-  - 模块化 controllers
-  - 模块化 services
-- 插件式架构
-- 轻量级（核心代码在300行以内）
-- 缓存支持
+- **核心架构**
+  - 基于 Express 5+ 构建
+  - 支持 ES6+ 语法
+  - 轻量级设计（核心代码精简高效）
+  
+- **模块化设计**
+  - 多模块化路由（支持模块独立路由）
+  - 模块化 views（模板文件模块化）
+  - 模块化 controllers（控制器模块化）
+  - 模块化 services（服务层模块化）
+  - 模块化 middleware（模块级中间件）
+  
+- **插件式架构**
+  - 支持插件扩展
+  - 插件独立 MVC 结构
+  - 热插拔式插件管理
+  
+- **数据库支持**
+  - 多数据库支持（PostgreSQL、MySQL/MariaDB、SQLite3、Oracle、MSSQL）
+  - 数据库连接池管理
+  - Knex 查询构建器
+  - 事务支持
+  - 日期字段自动格式化
+  
+- **安全防护**
+  - WAF（Web应用防火墙）
+  - XSS 防护
+  - 关键词过滤
+  - 访问限流（Rate Limiting）
+  - 路径白名单
+  - Cookie 安全处理
+  
+- **中间件生态**
+  - CORS 跨域配置
+  - 请求体解析
+  - Cookie 处理
+  - 静态资源管理
+  - 日志记录
+  - 模板引擎（Art-template）
+  
+- **高级特性**
+  - 依赖注入（DI，基于 Map 实现）
+  - 面向切面编程（AOP，支持 before/after/error 切面）
+  - 事件系统（基于 EventEmitter）
+  - 自动控制器加载（loadController）
+  
+- **开发体验**
+  - 缓存支持（内存缓存）
+  - 统一响应格式
+  - 全局错误处理（404/500）
+  - 分页查询封装
+  - 配置文件管理
+  - 环境变量支持（.env.dev/.env.prd）
+  
+- **工具函数**
+  - 时间格式化
+  - 文件操作
+  - 路径处理
+  - 树形结构转换
+  - 代码生成
+  - 过滤器
 
 ## 约定优于配置
 
 ```code
 |- app
-    |- module 
+    |- common
+    |- helper
+    |- middleware
+    |- modules 
         |- module1 
             |- controller 
             |- service 
-            |- view 
+            |- middleware
             |- router.js 
         |- module2 
             |- controller 
             |- service 
-            |- view 
             |- router.js
-    |- extend 
-    |- middleware 
-    |- plugin 
-        |- plus-module1 
-            |- controller 
-            |- service 
-            |- view 
-            |- router.js 
-        |- module2 
-            |- controller 
-            |- service 
-            |- view 
+    |- plugins
+        |- plugin1
+            |- controller
             |- router.js
+    |- router.js
 |- config 
+|- data
+|- doc
 |- public
-|- index.js
+|- view
+|- app.js
 |-.env.dev
 |-.env.prd
+|- pm2.json
+|- package.json
+```
+
+## 初始化过程
 
+```mermaid
+graph TD
+    A[初始化] --> B[加载配置]
+    B --> C[加载数据库]
+    C --> D[加载扩展]
+    D --> E[加载中间件]
+    E --> F[设置应用配置]
+    F --> G[加载模块路由]
+    G --> H[加载公共路由]
+    H --> I[应用路由]
+    I --> J[设置错误处理]
+    J --> K[beforeStart钩子]
+    K --> L[run启动服务器]
+    
+    G --> G1[加载服务]
+    G --> G2[加载控制器]
+    G --> G3[加载路由]
+    
+    D --> D1[加载common]
+    D --> D2[加载helper]
+    D --> D3[加载extend]
 ```
 
-### 初始化过程
-
-- 初始化
-- 加载配置
-- 加载模块
-  - 加载服务
-  - 加载控制器
-  - 加载路由
-- 加载扩展
-- 加载插件
-  - 加载服务
-  - 加载控制器
-  - 加载路由
-- `beforeStart()` 钩子用于将数据库中的配置合并到配置中
-- `run()` 启动服务器
-
-### 官方网站
-
-使用 Chanjs 开发的 CMS 系统  
-网站：[https://www.chancms.top](https://www.chancms.top)
+## 核心功能
+
+### 1. 依赖注入（DI）
+
+Chanjs 提供了轻量级的依赖注入容器，支持 Service 和 Controller 的自动加载。
+
+#### 使用方式
+
+```javascript
+import { Service, Controller } from "chanjs";
+
+class UserService extends Service {
+  constructor() {
+    super("user");
+  }
   
-### 功能亮点
+  async getUserWithArticles(userId) {
+    const user = await this.findById(userId);
+    // 从依赖注入容器中获取 ArticleService 实例
+    const articleService = await this.get("article", "Article");
+    const articles = await articleService.findByUserId(userId);
+    
+    return { user, articles };
+  }
+}
+
+class UserController extends Controller {
+  constructor() {
+    super();
+  }
+  
+  async getUser(req, res, next) {
+    try {
+      const { id } = req.params;
+      // 从依赖注入容器中获取 UserService 实例
+      const userService = await this.get("user", "User");
+      const result = await userService.findById(id);
+      res.json(this.success({ data: result.data }));
+    } catch (err) {
+      next(err);
+    }
+  }
+}
+```
+
+### 2. 面向切面编程（AOP）
+
+Chanjs 提供了 AOP（面向切面编程）支持，可以在方法执行前后添加切面逻辑。
+
+#### 支持的切面类型
+
+- `before` - 方法执行前
+- `after` - 方法执行后
+- `error` - 方法执行异常时
+
+#### 使用方式
+
+```javascript
+import { aop } from "chanjs";
+
+// 注册切面函数
+aop.set("logBefore", async ({ ctx, methodName, args }) => {
+  console.log(`[Before] ${methodName} 被调用，参数:`, args);
+});
+
+aop.set("logAfter", async ({ ctx, methodName, result }) => {
+  console.log(`[After] ${methodName} 执行完成，结果:`, result);
+});
+
+aop.set("logError", async ({ ctx, methodName, error }) => {
+  console.error(`[Error] ${methodName} 执行失败:`, error);
+});
+
+// 绑定切面到实例方法
+const controller = new UserController();
+aop.wrap(controller, {
+  getUser: [
+    { type: "before", logBefore: true },
+    { type: "after", logAfter: true },
+    { type: "error", logError: true }
+  ]
+});
+
+// 调用方法时会自动执行切面
+await controller.getUser(1);
+```
+
+#### 切面配置选项
+
+```javascript
+aop.wrap(instance, {
+  methodName: [
+    { type: "before", enabled: true, customParam: "value" },
+    { type: "after", enabled: true },
+    { type: "error", enabled: false }
+  ]
+});
+```
+
+- `type` - 切面类型（before/after/error）
+- `enabled` - 是否启用该切面（默认 true）
+- 其他自定义参数会传递给切面函数
+
+### 3. 事件系统
+
+Chanjs 提供了基于 Node.js EventEmitter 的事件系统，支持应用内的事件发布订阅。
+
+#### 使用方式
+
+```javascript
+import { event } from "chanjs";
+
+// 监听事件
+event.on("user.login", (data) => {
+  console.log("用户登录:", data);
+});
+
+event.on("user.logout", (data) => {
+  console.log("用户退出:", data);
+});
+
+// 触发事件
+event.emit("user.login", { userId: 1, username: "admin" });
+
+// 移除监听器
+event.off("user.login", listener);
+
+// 移除所有监听器
+event.removeAllListeners("user.login");
+```
+
+### 4. 自动加载控制器
+
+Chanjs 提供了 `loadController` 辅助函数，可以自动加载指定模块下的所有控制器。
+
+#### 使用方式
+
+```javascript
+import { helper } from "chanjs";
+
+// 加载 member 模块下的所有控制器
+const controller = await helper.loadController("member");
+
+// 使用控制器
+controller.Member.getUser();
+controller.Comment.getComments();
+controller.Favorite.getFavorites();
+```
+
+#### 目录结构
+
+```
+member/
+  controller/
+    Member.js
+    Comment.js
+    Favorite.js
+  service/
+    Member.js
+    Comment.js
+    Favorite.js
+  router.js
+```
+
+`loadController("member")` 会自动加载 `member/controller/` 目录下的所有文件，并返回一个对象：
 
-- 配置文件
-- 多模块 MVC 结构
-- 插件 MVC 支持
-- CORS 跨域配置支持
-- 多数据库支持 （PostgreSQL、MySQL / MariaDB、SQLite3、Oracle Database、MSSQL）
-- 路由控制
-- Art-template 模板引擎
-- 静态资源管理
-- Cookie 处理
-- 日志功能
+```javascript
+{
+  Member: MemberController实例,
+  Comment: CommentController实例,
+  Favorite: FavoriteController实例
+}
+```
 
-### 运行
+## 运行
 
 ```javascript
 import Chanjs from "chanjs";
 const chan = new Chanjs();
+
 // 前置钩子
 chan.beforeStart(fn);
+
 // 开始加载
 await chan.start();
+
+// 启动服务器
 chan.run((port) => {
   console.log(`ChanCMS is running on ${port}`);
 });
+```
 
+## 完整示例
+
+```javascript
+import Chanjs from "chanjs";
+import { aop, event } from "chanjs";
+
+const app = new Chanjs();
+
+// 注册切面
+aop.set("logBefore", async ({ ctx, methodName, args }) => {
+  console.log(`[Before] ${methodName} 被调用`);
+});
+
+// 监听事件
+event.on("app.start", () => {
+  console.log("应用启动");
+});
+
+// 启动应用
+await app.start();
+
+// 运行
+app.run((port) => {
+  event.emit("app.start", { port });
+  console.log(`Server running on port ${port}`);
+});
 ```
 
 该框架专为寻求简单与功能之间平衡的开发者设计，为构建 Web 应用程序提供了一个强大的基础。