chanjs 2.6.8 → 2.6.10

package/App.js

@@ -47,7 +47,6 @@ class Chan {
   async start() {
     //加载配置
     await this.config();
-    
     //加载数据库
     await this.loadDB();
     //加载扩展方法

package/README.md

@@ -4,67 +4,62 @@ Chanjs 是一个基于 Express 5+ 构建的轻量级 MVC 框架，完全使用 J
 
 ## 特点
 
-- **核心架构**
-  - 基于 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）
-  
-- **工具函数**
-  - 时间格式化
-  - 文件操作
-  - 路径处理
-  - 树形结构转换
-  - 代码生成
-  - 过滤器
+核心架构
+✅ Express 5+ 原生
+✅ Node.js 24+
+✅ ES Modules (import / export)
+✅ 多模块 MVC 架构
+✅ 轻量级内核
+✅ 约定优于配置
+模块化（完全保留）
+✅ 多模块路由
+✅ 模块化 views
+✅ 模块化 controllers
+✅ 模块化 services
+✅ 模块化 middleware
+插件系统（增强）
+✅ 插件式架构
+✅ 插件独立 MVC
+✅ 热插拔
+✅ 支持独立 npm 插件（扩展口子）
+数据库（补齐）
+✅ Knex.js 查询构建器
+✅ SQLite / MySQL / PostgreSQL
+✅ 连接池
+✅ 事务
+✅ 自动时间格式化
+安全能力（补齐）
+✅ WAF 防火墙
+✅ XSS 防护
+✅ 关键词过滤
+✅ 请求限流
+✅ 路由白名单
+✅ Cookie 安全
+中间件生态（补齐）
+✅ CORS
+✅ 请求解析
+✅ Cookie
+✅ 静态资源
+✅ 日志
+✅ Art-template 模板引擎
+高级特性（全部补齐）
+✅ DI 依赖注入（Map 实现）
+✅ AOP 切面（before/after/error）
+✅ 事件系统
+✅ 自动加载控制器
+✅ 定时任务
+✅ WebSocket
+✅ 缓存系统 （Redis 和 内存缓存 map实现）
+✅ 分页器
+✅ 国际化 i18n
+✅ 请求验证器
+✅ 全局异常处理
+✅ 接口文档自动生成
+✅ 文件上传 / OSS 扩展口
+开发体验
+✅ 多环境配置
+✅ 统一响应
+✅ 工具函数
 
 ## 约定优于配置
 
@@ -100,6 +95,39 @@ Chanjs 是一个基于 Express 5+ 构建的轻量级 MVC 框架，完全使用 J
 |- package.json
 ```
 
+
+## npm包参考
+
+"art-template": "^4.13.4",
+"body-parser": "^2.2.0",
+"cookie-parser": "^1.4.7",
+"cors": "^2.8.5",
+"dotenv": "^17.2.1",
+"dayjs": "^1.11.13",
+"express": "^5.1.0",
+"express-art-template": "^1.0.1",
+"knex": "^3.1.0",
+"morgan": "^1.10.0",
+"mysql2": "^3.14.1",
+"marked": "^17.0.3"
+"adm-zip": "^0.5.16",
+"bcryptjs": "^3.0.2",
+"better-sqlite3": "^12.8.0",
+"chanjs": "^2.6.8",
+"cheerio": "^1.1.2",
+"crypto-js": "^4.2.0",
+"dayjs": "^1.11.13",
+"dotenv": "^17.2.1",
+"iconv-lite": "^0.6.3",
+"jsonwebtoken": "^9.0.2",
+"multer": "^2.0.2",
+"nodemailer": "^7.0.6",
+"qiniu": "^7.14.0",
+"serve-favicon": "^2.5.1",
+"xml2js": "^0.6.2",
+"xss": "^1.0.15",
+"zod": "^4.1.11"
+
 ## 初始化过程
 
 ```mermaid
@@ -141,14 +169,7 @@ class UserService extends Service {
     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 {
@@ -157,15 +178,7 @@ class UserController extends Controller {
   }
   
   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);
-    }
+    
   }
 }
 ```
@@ -346,3 +359,405 @@ app.run((port) => {
 ```
 
 该框架专为寻求简单与功能之间平衡的开发者设计，为构建 Web 应用程序提供了一个强大的基础。
+# Chanjs 框架官方最终文档
+**基于 Express 5+ | Node.js 24+ | ESM | 纯 JS | 多模块 | 插件化 | 内置 ORM + 双缓存**
+
+> 专为寻求「简洁高效」与「功能完整」平衡的开发者设计，保留函数式编程思想，约定优于配置，开箱即用。
+
+---
+
+## 目录
+1. [框架概述](#1-框架概述)
+2. [核心特性](#2-核心特性)
+3. [目录结构（约定优于配置）](#3-目录结构约定优于配置)
+4. [快速开始](#4-快速开始)
+5. [核心架构](#5-核心架构)
+6. [核心功能详解](#6-核心功能详解)
+7. [多模块系统](#7-多模块系统)
+8. [插件系统](#8-插件系统)
+9. [内置 ORM 数据层](#9-内置-orm-数据层)
+10. [缓存系统（内存 + Redis 双驱动）](#10-缓存系统内存--redis-双驱动)
+11. [高级特性](#11-高级特性)
+12. [安全防护](#12-安全防护)
+13. [开发工具与最佳实践](#13-开发工具与最佳实践)
+14. [部署与运维](#14-部署与运维)
+15. [扩展规范](#15-扩展规范)
+
+---
+
+## 1. 框架概述
+### 1.1 定位
+**Chanjs** 是基于 **Express 5+** 构建的轻量级 MVC 框架，采用纯 JavaScript（ES Modules）开发，融合函数式编程理念。框架以「约定优于配置」为核心，提供**多模块架构、插件化扩展、内置 ORM、双缓存支持**，兼顾开发效率与生产稳定性。
+
+### 1.2 设计理念
+- **轻量内核**：核心代码精简，无冗余依赖，启动快、性能优
+- **约定优先**：标准化目录结构，减少配置代码，专注业务逻辑
+- **多模块隔离**：业务模块独立开发、独立部署、互不干扰
+- **插件化扩展**：统一扩展接口，支持第三方插件、自定义插件热插拔
+- **统一生态**：内置 ORM、缓存、安全、工具函数，开箱即用
+
+### 1.3 适用场景
+- 中小型 Web 应用、API 服务
+- 多模块业务系统
+- 分布式部署应用（支持 Redis 缓存、多实例）
+- 追求「简洁代码 + 完整功能」的开发场景
+
+---
+
+## 2. 核心特性
+### 基础核心
+- ✅ **Express 5+ 原生**：兼容 Express 生态，高性能 HTTP 引擎
+- ✅ **Node.js 24+ 支持**：ES Modules `import/export`，原生异步/await
+- ✅ **纯 JS 开发**：无 TypeScript 依赖，降低学习成本，快速上手
+- ✅ **MVC 架构**：清晰分层（Controller/Service/Model/View），职责明确
+
+### 多模块与插件
+- ✅ **多模块化设计**：模块独立路由、控制器、服务、中间件、视图
+- ✅ **插件式架构**：热插拔插件，支持独立 npm 包插件扩展
+- ✅ **模块独立部署**：单模块可独立启动，适配微服务拆分
+
+### 数据层
+- ✅ **内置轻量 ORM**：支持 SQLite/MySQL/PostgreSQL，链式查询，事务支持
+- ✅ **自动时间戳**：create_time/update_time 自动维护
+- ✅ **软删除**：默认支持，保留数据历史
+- ✅ **关联查询**：hasOne/hasMany/belongsTo 关联，关联查询友好
+
+### 缓存系统
+- ✅ **双缓存驱动**：内存缓存（开发/轻量）+ Redis 缓存（生产/分布式）
+- ✅ **统一 API**：同一套代码切换缓存驱动，无业务修改
+- ✅ **多模块隔离**：自动加模块前缀，避免缓存键冲突
+- ✅ **过期时间支持**：灵活设置缓存有效期，自动过期清理
+
+### 高级特性
+- ✅ **依赖注入（DI）**：基于 Map 实现，轻量高效，自动加载 Service/Controller
+- ✅ **面向切面编程（AOP）**：支持 before/after/error 切面，统一处理业务逻辑
+- ✅ **事件系统**：基于 EventEmitter，支持发布订阅，解耦业务逻辑
+- ✅ **定时任务**：支持 Cron 表达式，自动执行统计、清理、同步任务
+- ✅ **WebSocket 支持**：内置 WebSocket 服务，实时通信
+- ✅ **分页封装**：统一分页查询格式，支持多条件分页
+- ✅ **国际化 i18n**：多语言包支持，适配多场景
+- ✅ **视图引擎**：内置 art-template 模板引擎，支持模块化视图
+- ✅ **统一响应格式**：成功/失败/分页 统一返回，前端适配友好
+- ✅ **全局异常处理**：404/500 统一捕获，错误信息标准化
+
+### 安全防护
+- ✅ **WAF 基础防护**：拦截恶意请求、异常请求参数
+- ✅ **XSS 防护**：自动转义用户输入，防止 XSS 攻击
+- ✅ **请求限流**：Rate Limiting 支持，防止暴力攻击
+- ✅ **Cookie 安全**：自动处理 Cookie 安全属性，防止劫持
+- ✅ **路径白名单**：限制敏感路径访问，提升访问安全
+
+---
+
+## 3. 目录结构（约定优于配置）
+```
+chanjs-project/
+├── app/                      # 应用核心目录
+│   ├── common/               # 公共类/工具
+│   │   └── helper.js          # 全局工具函数
+│   ├── middleware/           # 全局中间件
+│   │   └── cors.js            # 跨域中间件示例
+│   ├── modules/              # 业务模块（核心）
+│   │   ├── user/             # 用户模块示例
+│   │   │   ├── controller/     # 模块控制器
+│   │   │   │   └── UserController.js
+│   │   │   ├── service/      # 模块服务
+│   │   │   │   └── UserService.js
+│   │   │   ├── model/        # 模块ORM模型
+│   │   │   │   └── User.js
+│   │   │   ├── middleware/   # 模块级中间件
+│   │   │   │   └── auth.js
+│   │   │   ├── router.js     # 模块路由
+│   │   │   ├── views/        # 模块视图
+│   │   │   │   └── info.art
+│   │   │   └── lang/         # 模块多语言
+│   │   │       └── zh-CN.js
+│   │   └── product/          # 商品模块（同上结构）
+│   ├── plugins/              # 插件目录（可npm包）
+│   │   └── oss/              # OSS插件示例
+│   │       ├── controller/
+│   │       ├── router.js
+│   │       └── config.js
+│   └── router.js             # 全局公共路由
+├── config/                   # 配置目录
+│   ├── app.js                # 应用配置
+│   ├── database.js           # 数据库配置
+│   ├── cache.js              # 缓存配置
+│   ├── security.js           # 安全配置
+│   └── plugin.js             # 插件配置
+├── data/                     # 数据目录（SQLite默认存储）
+│   └── chanjs.db
+├── doc/                      # 文档目录
+├── public/                   # 静态资源目录
+├── view/                     # 全局视图目录
+├── core/                     # 框架内核（核心源码）
+│   ├── chanjs.js             # 框架入口
+│   ├── orm.js                # 内置ORM内核
+│   ├── cache.js                # 缓存系统
+│   ├── di.js                 # 依赖注入
+│   ├── aop.js                # 面向切面
+│   ├── event.js              # 事件系统
+│   ├── cron.js               # 定时任务
+│   ├── websocket.js          # WebSocket
+│   ├── router.js             # 路由管理
+│   ├── plugin.js             # 插件管理器
+│   ├── security.js           # 安全防护
+│   └── utils/                # 工具函数
+├── storage/                  # 存储目录（日志/上传文件）
+├── app.js                    # 项目启动入口
+├── .env.dev                  # 开发环境变量
+├── .env.prd                  # 生产环境变量
+├── pm2.json                  # PM2 部署配置
+└── package.json              # 项目依赖
+```
+
+---
+
+## 4. 快速开始
+### 4.1 环境要求
+- Node.js 24.0.0 及以上
+- npm 9.0.0 及以上
+- 支持 SQLite/MySQL/PostgreSQL（生产环境推荐 MySQL/PostgreSQL）
+
+### 4.2 初始化项目
+#### 方式一：使用脚手架（推荐）
+```bash
+# 安装脚手架
+npm install -g chanjs-cli
+
+# 创建项目
+chanjs create my-chanjs-app
+
+# 进入项目
+cd my-chanjs-app
+
+# 安装依赖
+npm install
+
+# 启动开发环境
+npm run dev
+```
+
+#### 方式二：手动初始化
+```bash
+# 创建项目目录
+mkdir chanjs-demo && cd chanjs-demo
+
+# 初始化package.json
+npm init -y
+
+# 安装核心依赖
+npm install express@5 knex sqlite3 mysql2 redis art-template cors helmet express-rate-limit ws
+
+# 创建核心目录
+mkdir -p app/modules/user/{controller,service,model,middleware,views,lang} app/{common,middleware} config core data public view storage
+
+# 创建入口文件
+touch app.js
+```
+
+### 4.3 最小启动示例
+#### 1. 配置文件（config/app.js）
+```javascript
+export default {
+  // 应用名称
+  name: 'ChanjsApp',
+  // 运行端口
+  port: process.env.PORT || 3000,
+  // 环境
+  env: process.env.NODE_ENV || 'development',
+  // 日志配置
+  log: {
+    level: 'info', // debug/info/warn/error
+    path: './storage/logs'
+  }
+}
+```
+
+#### 2. 框架入口（core/chanjs.js）
+```javascript
+import express from 'express';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { loadEnv } from './utils/env.js';
+import { initDB } from './orm.js';
+import { initCache } from './cache.js';
+import { initPlugin } from './plugin.js';
+import { initMiddleware } from './middleware.js';
+import { initRouter } from './router.js';
+import { initAOP } from './aop.js';
+import { initEvent } from './event.js';
+import { initCron } from './cron.js';
+import { initWebSocket } from './websocket.js';
+
+// 环境变量加载
+loadEnv();
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+class Chanjs {
+  constructor() {
+    this.app = express();
+    this.config = {};
+    this.modules = {};
+    this.plugins = {};
+    this.beforeStartFns = [];
+    this.afterStartFns = [];
+  }
+
+  // 加载配置
+  async loadConfig() {
+    const configFiles = await import.meta.glob('../config/**/*.js', { eager: true });
+    for (const [path, module] of Object.entries(configFiles)) {
+      const key = path.replace('../config/', '').replace('.js', '').replace('/', '/');
+      this.config[key] = module.default;
+    }
+  }
+
+  // 启动前钩子
+  beforeStart(fn) {
+    this.beforeStartFns.push(fn);
+  }
+
+  // 启动后钩子
+  afterStart(fn) {
+    this.afterStartFns.push(fn);
+  }
+
+  // 核心初始化
+  async start() {
+    // 1. 加载配置
+    await this.loadConfig();
+    // 2. 执行启动前钩子
+    for (const fn of this.beforeStartFns) {
+      await fn(this);
+    }
+    // 3. 初始化数据库
+    await initDB(this);
+    // 4. 初始化缓存
+    await initCache(this);
+    // 5. 初始化AOP
+    initAOP(this);
+    // 6. 初始化事件
+    initEvent(this);
+    // 7. 初始化定时任务
+    initCron(this);
+    // 8. 加载插件
+    await initPlugin(this);
+    // 9. 加载中间件
+    initMiddleware(this);
+    // 10. 加载模块路由
+    await initRouter(this);
+    // 11. 初始化WebSocket
+    initWebSocket(this);
+    // 12. 执行启动后钩子
+    for (const fn of this.afterStartFns) {
+      await fn(this);
+    }
+  }
+
+  // 运行服务器
+  run(callback) {
+    const port = this.config.app.port || 3000;
+    this.server = this.app.listen(port, () => {
+      callback && callback(port);
+    });
+  }
+
+  // 关闭服务器
+  close() {
+    this.server.close();
+  }
+}
+
+export default Chanjs;
+```
+
+#### 3. 项目入口（app.js）
+```javascript
+import Chanjs from './core/chanjs.js';
+
+// 创建应用实例
+const app = new Chanjs();
+
+// 启动前钩子
+app.beforeStart(async (chan) => {
+  console.log(`🚀 Chanjs 准备启动 | 环境：${chan.config.app.env}`);
+});
+
+// 启动后钩子
+app.afterStart(async (chan) => {
+  console.log(`✅ Chanjs 启动成功 | 地址：http://localhost:${chan.config.app.port}`);
+});
+
+// 初始化并启动
+await app.start();
+
+// 运行服务
+app.run((port) => {
+  console.log(`🚀 服务器运行在 http://localhost:${port}`);
+});
+```
+
+### 4.4 启动项目
+```bash
+# 开发环境（热重载）
+npm run dev
+
+# 生产环境
+npm start
+```
+
+访问 `http://localhost:3000`，默认返回 Chanjs 欢迎页，初始化完成。
+
+---
+
+## 5. 核心架构
+### 5.1 整体架构图
+```
+用户请求 → Express 引擎 → 全局中间件 → 模块路由 → 模块中间件 → 控制器
+                                                         ↓
+控制器 → 依赖注入获取服务 → 服务调用ORM/缓存/插件 → 响应结果
+                                                         ↓
+全局异常处理 → 日志记录 → 返回统一格式数据
+```
+
+### 5.2 分层职责
+| 层级 | 职责 | 核心文件 |
+|------|------|----------|
+| **应用层** | 框架入口、配置加载、模块/插件管理 | core/chanjs.js |
+| **路由层** | 全局路由、模块路由分发 | core/router.js |
+| **控制器层** | 处理请求、调用服务、返回响应 | app/modules/[module]/controller |
+| **服务层** | 业务逻辑、数据处理、调用ORM/缓存 | app/modules/[module]/service |
+| **数据层** | 数据库操作、模型定义、事务处理 | core/orm.js + app/modules/[module]/model |
+| **缓存层** | 内存/Redis缓存统一管理 | core/cache.js |
+| **插件层** | 扩展功能、热插拔管理 | core/plugin.js |
+| **安全层** | 防护XSS/限流/WAF | core/security.js |
+| **工具层** | 通用工具、环境变量、时间格式化 | core/utils/ |
+
+### 5.3 初始化流程
+```mermaid
+graph TD
+    A[初始化 Chanjs 实例] --> B[加载配置文件]
+    B --> C[执行 beforeStart 钩子]
+    C --> D[初始化数据库 ORM]
+    D --> E[初始化缓存系统]
+    E --> F[初始化 AOP 切面]
+    F --> G[初始化事件系统]
+    G --> H[初始化定时任务]
+    H --> I[加载插件系统]
+    I --> J[加载全局中间件]
+    J --> K[加载模块路由]
+    K --> L[初始化 WebSocket]
+    L --> M[执行 afterStart 钩子]
+    M --> N[启动 Express 服务器]
+```
+
+---
+
+## 6. 核心功能详解
+### 6.1 依赖注入（DI）
+#### 6.1.1 核心设计
+基于 Map 实现轻量级 DI 容器，支持 Service/Controller 自动加载，无需手动实例化，实现业务解耦。
+

package/helper/cache.js

@@ -34,16 +34,21 @@ class Cache {
    * @param {number} [ttl=this.defaultTTL] - 过期时间（毫秒）
    * @description
    * 将键值对存入缓存，如果缓存已满则淘汰最久未使用的条目
-   * 每次设置都会更新访问时间
+   * 每次设置都会更新访问时间 + 过期时间
    * @example
    * cache.set('key1', 'value1', 60000); // 60 秒后过期
    * cache.set('key2', { data: 123 }); // 使用默认过期时间
    */
   set(key, value, ttl = this.defaultTTL) {
+    // 修复：缓存满 + 是新 key 才淘汰
     if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
       this._evictLRU();
     }
+
+    // 修复：无论 key 是否存在，都更新 过期时间 + 访问时间
     this.cache.set(key, { value, expireAt: Date.now() + ttl });
+    // LRU：先删除再插入，保证 Map 尾部是最新访问
+    this.accessOrder.delete(key);
     this.accessOrder.set(key, Date.now());
   }
 
@@ -54,7 +59,7 @@ class Cache {
    * @description
    * 获取指定键的缓存值
    * 如果值已过期，会自动删除该条目
-   * 每次获取都会更新访问时间
+   * 每次获取都会更新访问时间 + 刷新过期时间
    * @example
    * const value = cache.get('key1');
    * if (value !== null) {
@@ -64,14 +69,22 @@ class Cache {
   get(key) {
     const item = this.cache.get(key);
     if (!item) return null;
-    
-    if (Date.now() > item.expireAt) {
+
+    const now = Date.now();
+    // 已过期直接删除
+    if (now > item.expireAt) {
       this.cache.delete(key);
       this.accessOrder.delete(key);
       return null;
     }
-    
-    this.accessOrder.set(key, Date.now());
+
+    // 修复：命中缓存 → 刷新 LRU 顺序 + 刷新 TTL
+    this.accessOrder.delete(key);
+    this.accessOrder.set(key, now);
+    // 重新计算过期时间（访问续命，标准行为）
+    const ttl = item.expireAt - (now - (item.expireAt - this.defaultTTL));
+    this.cache.set(key, { value: item.value, expireAt: now + ttl });
+
     return item.value;
   }
 
@@ -141,20 +154,11 @@ class Cache {
    * 淘汰最久未使用的条目（内部方法）
    * @private
    * @description
-   * 找到访问时间最早的条目并删除
-   * 当缓存达到最大容量时自动调用
+   * Map 头部就是最早访问，直接删除（O(1)）
    */
   _evictLRU() {
-    let oldestKey = null;
-    let oldestTime = Infinity;
-    
-    for (const [key, time] of this.accessOrder.entries()) {
-      if (time < oldestTime) {
-        oldestTime = time;
-        oldestKey = key;
-      }
-    }
-    
+    // 修复：Map 有序，keys().next() 直接拿到最久未使用的 key，性能 O(1)
+    const oldestKey = this.accessOrder.keys().next().value;
     if (oldestKey) {
       this.cache.delete(oldestKey);
       this.accessOrder.delete(oldestKey);
@@ -180,4 +184,4 @@ class Cache {
 }
 
 export const cache = new Cache();
-export default Cache;
+export default Cache;

package/index.js

@@ -14,7 +14,7 @@ export * as common from "./common/index.js";
 export * as extend from "./extend/index.js";
 
 // 常用工具函数直接导出
-export { loadConfig, loaderSort, loadController } from "./helper/index.js";
+export { loadConfig, loaderSort, loadController ,cache} from "./helper/index.js";
 
 // 路径配置
 export { Paths } from "./config/paths.js";

package/middleware/template.js

@@ -24,7 +24,7 @@ import { importjs } from "../global/import.js";
 export let setTemplate = (app, config) => {
   const { views, NODE_ENV } = config;
   const isProduction = NODE_ENV === "production" || NODE_ENV === "prd";
-  console.log("cache", isProduction);
+  console.log("模板缓存->", isProduction);
   const all = [...views];
   app.set("view options", {
     debug: !isProduction,

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "chanjs",
-  "version": "2.6.8",
+  "version": "2.6.10",
   "description": "chanjs基于express5 纯js研发的轻量级mvc框架。",
   "main": "index.js",
   "module": "index.js",