chanjs 2.0.4 → 2.0.6

package/global/env.js

@@ -0,0 +1,5 @@
+import dotenv from "dotenv";
+import path from "path";
+//加载环境变量
+const envFile = process.env.ENV_FILE || ".env.prd";
+dotenv.config({ path: path.join(ROOT_PATH, envFile) });

package/global/global.js

@@ -0,0 +1,23 @@
+import { pathToFileURL, fileURLToPath } from "url";
+import path from "path";
+const ROOT_PATH = process.cwd();
+const APP_PATH = path.join(ROOT_PATH, "app");
+const globals = {
+  ROOT_PATH,
+  APP_PATH,
+  CONFIG_PATH: path.join(ROOT_PATH, "config"),
+  EXTEND_PATH: path.join(APP_PATH, "extend"),
+  PUBLIC_PATH: path.join(ROOT_PATH, "public"),
+  MODULES_PATH: path.join(APP_PATH, "modules"),
+  COMMON_PATH: path.join(APP_PATH, "common"),
+  HELPER_PATH: path.join(APP_PATH, "helper"),
+};
+
+for (const [key, value] of Object.entries(globals)) {
+  Object.defineProperty(global, key, {
+    value,
+    writable: false, // 禁止修改
+    configurable: false, //  禁止删除或重新定义
+    enumerable: true, //  可枚举（调试时可见）
+  });
+}

package/global/import.js

@@ -0,0 +1,40 @@
+
+import fs from "fs/promises";
+import { pathToFileURL } from "url";
+import { createRequire } from "module";
+
+/**
+ * @description 安全导入ES模块文件
+ * @param {string} filepath - 文件路径
+ * @returns {Promise<object|null>} 模块对象或null
+ */
+const importFile = async (filepath) => {
+  if (!filepath || typeof filepath !== 'string') {
+    console.error('错误: 文件路径必须是有效的字符串');
+    return null;
+  }
+
+  try {
+    await fs.access(filepath);
+    const fileUrl = pathToFileURL(filepath).href;
+    const module = await import(fileUrl);
+    return module.default || module;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.error(`文件不存在: ${filepath}`);
+    } else if (error.code === 'EACCES') {
+      console.error(`没有权限访问文件: ${filepath}`);
+    } else {
+      console.error(`导入文件时出错 [${filepath}]:`, error.message);
+    }
+    return null;
+  }
+};
+
+/**
+ * @description: 兼容低版本 Node 的 CommonJS 模块加载
+ */
+export const importjs = createRequire(import.meta.url);
+
+global.requirejs = importjs;
+global.importFile = importFile;

package/global/index.js

@@ -0,0 +1,3 @@
+import './global.js'
+import './import.js'
+import './env.js'

package/helper/data-parse.js

@@ -0,0 +1,85 @@
+/**
+ * 将数组转换为键值对对象
+ * @param {Array} arr - 包含键值对的数组
+ * @param {string} keyField - 作为键的字段名
+ * @param {string} valueField - 作为值的字段名
+ * @returns {Object} 转换后的对象
+ */
+export const arrToObj = (arr, keyField = 'config_key', valueField = 'config_value') => {
+    // 输入验证
+    if (!Array.isArray(arr)) {
+      throw new Error('arrToObj 期望接收数组作为第一个参数');
+    }
+    
+    return arr.reduce((result, item) => {
+      if (item && typeof item === 'object') {
+        const key = item[keyField];
+        const value = item[valueField];
+        if (key !== undefined && value !== undefined) {
+          result[key] = value;
+        }
+      }
+      return result;
+    }, {});
+  };
+
+
+  /**
+   * @description 将字符串中的 JSON 字符串转换为对象
+   * @param {*} obj - 包含 JSON 字符串的对象
+   * @returns 
+   */
+  export function parseJsonFields(obj) {
+    const result = {};
+    for (const key in obj) {
+      if (!obj.hasOwnProperty(key)) continue;
+      const value = obj[key];
+      // 如果是字符串，并且看起来像 JSON（以 { 或 [ 开头）
+      if (typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
+        try {
+          result[key] = JSON.parse(value);
+        } catch (e) {
+          console.warn(`JSON parse failed for field: ${key}`, e);
+          result[key] = value; // 保留原始值
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  
+    return result;
+  }
+
+
+  /**
+ * @param {Array} arr - 原始数据数组
+ * @param {number|string} [pid=0] - 根节点父ID
+ * @param {string} [idKey='id'] - ID字段名
+ * @param {string} [pidKey='pid'] - 父ID字段名
+ * @param {string} [childrenKey='children'] - 子节点字段名
+ * @returns {Array} 树形结构数组
+ */
+export function buildTree(arr, pid = 0, idKey = 'id', pidKey = 'pid', childrenKey = 'children') {
+  // 基础参数校验
+  if (!Array.isArray(arr)) return [];
+  
+  const tree = [];
+  
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    // 找到当前层级的节点
+    if (item[pidKey] === pid) {
+      // 递归查找子节点（通过slice创建子数组，避免重复遍历已处理项）
+      const children = buildTree(arr.slice(i + 1), item[idKey], idKey, pidKey, childrenKey);
+      
+      // 有子节点则添加，避免空数组
+      if (children.length) {
+        item[childrenKey] = children;
+      }
+      
+      tree.push(item);
+    }
+  }
+  
+  return tree;
+}

package/{utils → helper}/db.js

@@ -1,5 +1,25 @@
 import knex from "knex";
-export const db = function ({
+
+const errCode = {
+  ECONNREFUSED: "数据库连接被拒绝，请检查数据库服务是否正常运行。",
+  ER_ACCESS_DENIED_ERROR: "无权限访问，账号或密码错误。",
+  ER_ROW_IS_REFERENCED_2: "无法删除或更新记录，存在关联数据。",
+  ER_BAD_FIELD_ERROR: "SQL语句中包含无效字段，请检查查询条件或列名。",
+  ER_DUP_ENTRY: "插入失败：数据重复，违反唯一性约束。",
+  ER_NO_SUCH_TABLE: "操作失败：目标表不存在。",
+  ETIMEOUT: "数据库操作超时，请稍后再试。",
+};
+const getDefaultErrorMessage = (error) => {
+  if (error.message.includes("syntax") || error.message.includes("SQL")) {
+    return "数据库语法错误，请检查您的查询语句。";
+  } else if (error.message.includes("Connection closed")) {
+    return "数据库连接已关闭，请重试。";
+  } else if (error.message.includes("permission")) {
+    return "数据库权限不足，请检查配置。";
+  }
+  return "数据库发生未知错误，请稍后重试。";
+};
+export const db =({
   client = "mysql2",
   host = "127.0.0.1",
   user = "root",
@@ -10,7 +30,7 @@ export const db = function ({
   charset = "utf8mb4",
   min = 0,
   max = 2,
-}) {
+}) =>{
   let config = {
     client,
     connection: {
@@ -53,23 +73,3 @@ export const db = function ({
   };
   return knex(config);
 };
-
-const errCode = {
-  ECONNREFUSED: "数据库连接被拒绝，请检查数据库服务是否正常运行。",
-  ER_ACCESS_DENIED_ERROR: "无权限访问，账号或密码错误。",
-  ER_ROW_IS_REFERENCED_2: "无法删除或更新记录，存在关联数据。",
-  ER_BAD_FIELD_ERROR: "SQL语句中包含无效字段，请检查查询条件或列名。",
-  ER_DUP_ENTRY: "插入失败：数据重复，违反唯一性约束。",
-  ER_NO_SUCH_TABLE: "操作失败：目标表不存在。",
-  ETIMEOUT: "数据库操作超时，请稍后再试。",
-};
-const getDefaultErrorMessage = (error) => {
-  if (error.message.includes("syntax") || error.message.includes("SQL")) {
-    return "数据库语法错误，请检查您的查询语句。";
-  } else if (error.message.includes("Connection closed")) {
-    return "数据库连接已关闭，请重试。";
-  } else if (error.message.includes("permission")) {
-    return "数据库权限不足，请检查配置。";
-  }
-  return "数据库发生未知错误，请稍后重试。";
-};

package/helper/file.js

@@ -0,0 +1,208 @@
+import fs from 'fs/promises';
+import { accessSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+export const dirname = (url) =>{
+  const __filename = fileURLToPath(url);
+  return path.dirname(__filename);
+}
+
+
+/**
+ * 获取指定路径的文件树结构
+ * 
+ * @param {string} basePath - 要扫描的基础路径
+ * @param {boolean} [deep=true] - 是否深度遍历子目录
+ * @returns {Promise<Array<Object>>} 文件树数组，每个元素包含文件/目录信息
+ * @returns {string} return[].name - 名称
+ * @returns {string} return[].path - 完整路径
+ * @returns {string} return[].relativePath - 相对于APP_PATH的路径
+ * @returns {'directory'|'file'} return[].type - 类型（目录或文件）
+ * @returns {number} return[].size - 大小（字节）
+ * @returns {Date} return[].modified - 最后修改时间
+ * @returns {number} return[].depth - 深度
+ * @returns {Array<Object>} [return[].children] - 子目录内容（仅目录有）
+ * @throws {Error} 当路径不存在或没有访问权限时抛出错误
+ */
+export const getFileTree = async (basePath, deep = true) => {
+  try {
+    const stats = await fs.stat(basePath);
+    if (!stats.isDirectory()) {
+      return [];
+    }
+
+    const items = await fs.readdir(basePath);
+    const tree = [];
+
+    for (const item of items) {
+      const itemPath = path.join(basePath, item);
+      const itemStats = await fs.stat(itemPath);
+
+      const treeItem = {
+        name: item,
+        path: itemPath,
+        relativePath: path.relative(ROOT_PATH, itemPath),
+        type: itemStats.isDirectory() ? 'directory' : 'file',
+        size: itemStats.size,
+        modified: itemStats.mtime,
+        depth: itemPath.split(path.sep).length - path.resolve(ROOT_PATH).split(path.sep).length
+      };
+
+      if (treeItem.type === 'directory' && deep) {
+        treeItem.children = await getFileTree(itemPath, deep);
+      }
+
+      tree.push(treeItem);
+    }
+
+    // 排序：文件夹在前，文件在后，名称按字母顺序排列
+    return tree.sort((a, b) => {
+      if (a.type === b.type) {
+        return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
+      }
+      return a.type === 'directory' ? -1 : 1;
+    });
+  } catch (error) {
+    console.error(`获取文件树失败: ${basePath}`, error);
+    throw error;
+  }
+};
+
+/**
+ * 读取文件内容（UTF-8编码）
+ * 
+ * @param {string} filePath - 要读取的文件路径
+ * @returns {Promise<string>} 文件内容字符串
+ * @throws {Error} 当文件不存在、无法读取或不是文件时抛出错误
+ */
+export const readFileContent = async (filePath) => {
+  try {
+    // 先检查路径是否安全
+    if (!isPathSafe(filePath,APP_PATH)  && !isPathSafe(filePath,ROOT_PATH)) {
+      throw new Error(`路径不安全: ${filePath}`);
+    }
+    
+    // 检查是否为文件
+    const stats = await fs.stat(filePath);
+    if (!stats.isFile()) {
+      throw new Error(`不是文件: ${filePath}`);
+    }
+    
+    return await fs.readFile(filePath, 'utf8');
+  } catch (error) {
+    console.error(`读取文件失败: ${filePath}`, error);
+    throw error;
+  }
+};
+
+/**
+ * 保存内容到文件（UTF-8编码）
+ * 
+ * @param {string} filePath - 要保存的文件路径
+ * @param {string} content - 要写入的内容
+ * @returns {Promise<void>} 无返回值
+ * @throws {Error} 当路径不安全、无法写入或发生其他错误时抛出错误
+ */
+export const saveFileContent = async (filePath, content) => {
+  try {
+    // 先检查路径是否安全
+    if (!isPathSafe(filePath,APP_PATH)  && !isPathSafe(filePath,ROOT_PATH)) {
+      throw new Error(`路径不安全: ${filePath}`);
+    }
+    
+    // 确保目录存在
+    const dirname = path.dirname(filePath);
+    await fs.mkdir(dirname, { recursive: true });
+    
+    // 写入文件
+    await fs.writeFile(filePath, content, 'utf8');
+  } catch (error) {
+    console.error(`保存文件失败: ${filePath}`, error);
+    throw error;
+  }
+};
+
+/**
+ * 验证路径是否在基础路径范围内（防止路径遍历攻击）
+ * 
+ * @param {string} requestedPath - 要验证的路径
+ * @param {string} basePath - 基础路径，requestedPath必须在此路径下
+ * @returns {boolean} 如果路径安全则返回true，否则返回false
+ */
+export const isPathSafe = (requestedPath, basePath) => {
+  const resolvedRequestedPath = path.resolve(requestedPath);
+  const resolvedBasePath = path.resolve(basePath);
+  // 检查请求的路径是否以基础路径为前缀
+  return resolvedRequestedPath.startsWith(resolvedBasePath);
+};
+
+/**
+ * 删除指定路径的图片文件
+ * 
+ * @param {string} link - 图片文件的路径
+ * @returns {boolean} 成功删除返回true，否则返回false
+ * @description 同步操作，会检查文件是否存在后再删除
+ */
+export function delImg(link) {
+  try {
+    // 先检查路径是否安全
+    if (!isPathSafe(link, APP_PATH)) {
+      console.error(`路径不安全: ${link}`);
+      return false;
+    }
+    
+    // 检查文件是否存在
+    accessSync(link);
+    
+    // 删除文件
+    unlinkSync(link);
+    return true;
+  } catch (err) {
+    console.error(`删除图片失败: ${link}`, err);
+    return false;
+  }
+}
+
+/**
+ * 递归创建目录（同步操作）
+ * 
+ * @param {string} dirname - 要创建的目录路径
+ * @returns {boolean} 成功创建或目录已存在返回true，否则返回false
+ * @description 类似于mkdir -p命令，会创建所有不存在的父目录
+ */
+export function mkdirsSync(dirname) {
+  try {
+    // 先检查路径是否安全
+    if (!isPathSafe(dirname, APP_PATH)) {
+      console.error(`路径不安全: ${dirname}`);
+      return false;
+    }
+    
+    if (existsSync(dirname)) {
+      return true;
+    }
+    
+    // 递归创建父目录
+    const parentDir = path.dirname(dirname);
+    if (mkdirsSync(parentDir)) {
+      mkdirSync(dirname);
+      return true;
+    }
+    
+    return false;
+  } catch (err) {
+    console.error(`创建目录失败: ${dirname}`, err);
+    return false;
+  }
+}
+
+
+export default {
+  mkdirsSync,
+  delImg,
+  isPathSafe,
+  saveFileContent,
+  readFileContent,
+  getFileTree,
+}

package/helper/html.js

@@ -0,0 +1,19 @@
+/**
+ * 处理最常用的HTML特殊字符实体
+ * @param {string} str - 需要解码的字符串
+ * @returns {string} 解码后的字符串
+ */
+export const htmlDecode = (str) => {
+  // 非字符串直接返回，避免报错
+  if (typeof str !== 'string') return str;
+  
+  // 一次性替换所有常见实体，减少函数调用
+  return str.replace(/&|<|>| |'|"/g, match => ({
+    '&': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&nbsp;': ' ',
+    '&#39;': "'",
+    '&quot;': '"'
+  }[match]));
+}

package/helper/index.js

@@ -0,0 +1,9 @@
+
+import { db } from './db.js'
+import { loaderSort, loadConfig } from './loader.js'
+
+export {
+  db,
+  loaderSort,
+  loadConfig,
+}

package/helper/ip.js

@@ -0,0 +1,36 @@
+/**
+ * 获取用户登录IP地址
+ * @param {Object} req - Express请求对象
+ * @returns {string} 格式化后的IP地址，默认返回空字符串
+ */
+export const getIp = (req) =>{
+  
+  // 优先级从高到低获取可能的IP来源
+  const ipSources = [
+    req.headers['x-forwarded-for'],  // 代理场景下的真实IP（可能多个，逗号分隔）
+    req.headers['x-real-ip'],       // 部分代理服务器使用
+    req.ip,                         // Express内置的IP获取（已处理代理）
+    req.connection?.remoteAddress,  // 底层连接的远程地址
+    req.socket?.remoteAddress,      // 套接字的远程地址
+    req.connection?.socket?.remoteAddress  // 连接套接字的远程地址
+  ];
+
+  // 从来源中找到第一个有效IP字符串
+  let ip = ipSources.find(source => typeof source === 'string' && source.trim() !== '');
+  
+  // 若未找到有效IP，直接返回空
+  if (!ip) return '';
+
+  // 处理多IP情况（取第一个）
+  ip = ip.split(',').shift().trim();
+
+  // IPv6转IPv4处理
+  if (ip === '::1') {
+    return '127.0.0.1';  // 本地环回地址
+  }
+  if (ip.startsWith('::ffff:')) {
+    return ip.slice(7);  // 去除IPv6映射的IPv4前缀
+  }
+
+  return ip;
+}

package/helper/jwt.js

@@ -0,0 +1,41 @@
+import jwt from "jsonwebtoken";
+
+
+/**
+ * 
+ * @param {Object} data - 要存储在令牌中的数据（不建议存放敏感信息）
+ * @param {string} secretKey - 用于签名的密钥
+ * @param {string} time - 令牌过期时间,如 '1h'、'7d' 或秒数
+ * @returns {string} 生成的JWT令牌
+ */
+export function setToken(data={}, secretKey='chancms', time='7d') {
+  try {
+    return jwt.sign(data, secretKey, {
+      expiresIn: time,
+      algorithm: 'HS256',
+    });
+  } catch (error) {
+    console.error('令牌生成失败:', error.message);
+    throw new Error(`生成令牌失败: ${error.message}`);
+  }
+}
+
+// 获取token
+export async function getToken(token, secretKey='chancms') {
+  return new Promise((resolve, reject) => {
+    jwt.verify(token, secretKey,(err, decode) => {
+      if (err) {
+       let errorMessage = '令牌验证失败';
+       if (err.name === 'TokenExpiredError') {
+         errorMessage = '令牌已过期';
+       } else if (err.name === 'JsonWebTokenError') {
+         errorMessage = '无效的令牌';
+       }
+       console.error(errorMessage, '令牌异常信息:', err.message);
+       return reject(new Error(errorMessage));
+      } else {
+        resolve(decode);
+      }
+    });
+  });
+}

package/{utils → helper}/loader.js

@@ -1,32 +1,30 @@
-import fs from 'fs';
-import path from 'path';
-import { bindClass } from './bind.js';
+import fs from "fs";
+import path from "path";
 
 /**
- * 
+ *
  * @param {*} module 模块目录
- * @returns Array 
+ * @returns Array
  * @description 将web模块放到最后加载
  */
-export const loaderSort = (modules=[])=>{
-  const index = modules.indexOf('web');
+export const loaderSort = (modules = []) => {
+  const index = modules.indexOf("web");
   if (index !== -1) {
-      const web = modules.splice(index, 1);
-      modules.push(web[0]);
+    const web = modules.splice(index, 1);
+    modules.push(web[0]);
   }
   return modules;
-}
+};
 
-export const getPackage = async function(){
-  let pkg = await importFile('package.json')
+export const getPackage = async function () {
+  let pkg = await importFile("package.json");
   return pkg;
-}
+};
 
-export const loadConfig = async function(){
-  let config = await importFile('config/index.js')
+export const loadConfig = async function () {
+  let config = await importFile("config/index.js");
   return config;
-}
-
+};
 
 /**
  * 加载指定模块名下的所有控制器文件
@@ -36,22 +34,24 @@ export const loadConfig = async function(){
 export const loadController = async function (moduleName) {
   const controller = {};
 
-  const dir = path.join(MODULES_PATH, moduleName,'controller');
+  const dir = path.join(MODULES_PATH, moduleName, "controller");
 
   if (!fs.existsSync(dir)) {
     console.warn(`模块路径不存在，跳过加载控制器: ${dir}`);
     return controller;
   }
 
-  const files = fs.readdirSync(dir).filter(file => file.endsWith('.js'));
+  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, ''); // 安全处理 .js 后缀
+    const name = file.replace(/\.js$/i, ""); // 安全处理 .js 后缀
 
     try {
       const module = await importFile(filePath);
-      controller[name] = { ...module};
+      let obj = module.default || module;
+
+      controller[name] = obj;
     } catch (e) {
       console.error(`加载控制器失败: ${filePath}`, e);
       // 可选：抛出错误或继续加载其他文件
@@ -61,6 +61,3 @@ export const loadController = async function (moduleName) {
 
   return controller;
 };
-
-
- 

package/helper/time.js

@@ -0,0 +1,28 @@
+import dayjs from "dayjs";
+import "dayjs/locale/zh-cn.js";
+import relativeTime from "dayjs/plugin/relativeTime.js";
+
+dayjs.extend(relativeTime);
+dayjs.locale("zh-cn");
+
+/**
+ * @description 格式化时间
+ * @param {Array} data 数组
+ * @param {Boolean} time 是否开启具体时间
+ * @param {String} format YYYY-MM-DD HH:mm:ss
+ * @returns 返回处理过的数组
+ */
+export const formatDay = (data, time = true, format = "YYYY-MM-DD") => {
+  data.forEach((item) => {
+    if (item.createdAt) {
+      item.createdAt = time
+        ? dayjs(item.createdAt).format(format)
+        : dayjs(item.createdAt).fromNow().replace(" ", "");
+    }
+  });
+  return data;
+}
+
+export const formatTime = (data, format = "YYYY-MM-DD HH:mm:ss") => {
+  return dayjs(data).format("YYYY-MM-DD HH:mm:ss");
+}

package/helper/validate.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export { z };

package/index.js

@@ -1,15 +1,8 @@
-import "./common/global.js";
+import "./global/index.js";
 import path from "path";
 import fs from "fs";
-import {
-  bindClass,
-  db,
-  loaderSort,
-  getPackage,
-  loadConfig,
-  loadController,
-} from "./utils/index.js";
-import { express, z } from "./extend/import.js";
+import express from "express";
+
 import { Controller, Service } from "./core/index.js";
 import {
   log,
@@ -21,17 +14,16 @@ import {
   setTemplate,
   Cors,
   validator,
+  waf,
 } from "./middleware/index.js";
+import { db, loaderSort, loadConfig } from "./helper/index.js";
+import {dirname} from "./helper/file.js";
 
 class Chan {
-  static helper = {
-    bindClass,
-    getPackage,
-    loadController,
-    db,
-    z,
-    validator,
-  }; 
+  //版本号
+  #version = "0.0.0";
+  static helper = {};
+  static common = {}; //公共方法
   static config = {}; //配置
   static Service = Service; //服务
   static Controller = Controller; //控制器
@@ -78,10 +70,12 @@ class Chan {
     setFavicon(this.app);
     setCookie(this.app, cookieKey);
     setBody(this.app, BODY_LIMIT);
+    waf(this.app);
     setTemplate(this.app, { views, env });
     setStatic(this.app, statics);
     Cors(this.app, cors);
     setHeader(this.app, { APP_NAME, APP_VERSION });
+   
   }
 
   //数据库操作
@@ -102,7 +96,7 @@ class Chan {
     if (fs.existsSync(configPath)) {
       const dirs = loaderSort(Chan.config.modules);
       for (const item of dirs) {
-        let router = await importRootFile(`app/modules/${item}/router.js`);
+        let router = await importFile(`app/modules/${item}/router.js`);
         router(this.app, this.router, Chan.config);
       }
     }
@@ -111,7 +105,7 @@ class Chan {
   //通用路由，加载错误处理和500路由和爬虫处理
   async loadCommonRouter() {
     try {
-      let router = await importRootFile("app/router.js");
+      let router = await importFile("app/router.js");
       router(this.app, this.router, Chan.config);
     } catch (error) {
       console.log(error);
@@ -119,14 +113,34 @@ class Chan {
   }
 
   async loadExtend() {
-    if (fs.existsSync(EXTEND_PATH)) {
-      const files = fs
-        .readdirSync(EXTEND_PATH)
-        .filter((file) => file.endsWith(".js"));
+    let arr = [
+      {
+        _path: COMMON_PATH,
+        key: "common",
+      },
+      {
+        _path: HELPER_PATH,
+        key: "helper",
+      },
+      {
+        _path: path.join(dirname(import.meta.url), "helper"),
+        key: "helper",
+      },
+    ];
+    for (let item of arr) {
+      await this.loadFn(item._path, item.key);
+    }
+  }
+
+  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(EXTEND_PATH, file);
+        const filePath = path.join(_path, file);
         let helperModule = await importFile(filePath);
-        Chan.helper[file.replace(".js", "")] = helperModule;
+        // Chan.common[file.replace(".js", "")] = helperModule;
+        // 将模块导出的所有方法/属性，直接混入到 Chan.common 上
+        Object.assign(Chan[key], helperModule);
       }
     }
   }

package/middleware/index.js

@@ -7,6 +7,7 @@ import {setHeader} from "./header.js";
 import {setTemplate} from "./template.js";
 import {validator} from "./validator.js";
 import {Cors} from "./cors.js";
+import {waf} from "./waf.js";
 
 export {
     log,
@@ -17,5 +18,6 @@ export {
     setHeader,
     setTemplate,
     Cors,
-    validator
+    validator,
+    waf
 }

package/middleware/waf.js

@@ -0,0 +1,195 @@
+import url from "url";
+import {getIp} from "../helper/ip.js";
+
+// 原始关键词列表（保持不变）
+const keywords = [
+  ".aspx",
+  ".php",
+  ".pl",
+  ".jsa",
+  ".jsp",
+  ".asp",
+  ".go",
+  ".jhtml",
+  ".shtml",
+  ".cfm",
+  ".cgi",
+  ".svn",
+  ".env",
+  ".keys",
+  ".cache",
+  ".hidden",
+  ".bod",
+  ".ll",
+  ".backup",
+  ".json",
+  ".xml",
+  ".bak",
+  ".aws",
+  ".database",
+  // ".cookie",
+  ".location",
+  ".dump",
+  ".ftp",
+  ".idea",
+  ".s3",
+  ".sh",
+  ".old",
+  ".tf",
+  ".sql",
+  ".vscode",
+  ".docker",
+  ".map",
+  "1+1",
+  ".save",
+  ".gz",
+  ".yml",
+  ".tar",
+  ".rar",
+  ".7z",
+  ".zip",
+  ".git",
+  ".log",
+  ".local",
+  "../",
+  "db_",
+  "smtp",
+  "meta",
+  "debug",
+  "secret",
+  "/xampp/",
+  "/metadata/",
+  "/internal/",
+  "/aws/",
+  "/debug/",
+  "/configs/",
+  "/cgi-bin/",
+  "/tmp/",
+  "/staging/",
+  "/mail/",
+  "/docker/",
+  "/.secure/",
+  "/php-cgi/",
+  "/wp-",
+  "/backup/",
+  "redirect",
+  "/phpMyAdmin/",
+  "/setup/",
+  "concat(",
+  "version(",
+  "sleep(",
+  "benchmark(",
+  "0x7e",
+  "extractvalue(",
+  "(select",
+  "a%",
+  "union",
+  "drop",
+  "alter",
+  "truncate",
+  "exec",
+];
+
+// 预处理：合并字符串关键词和正则关键词为两个单一正则（核心优化）
+const { combinedStrRegex, combinedRegRegex } = (() => {
+  const regexSpecialChars = /[.*+?^${}()|[\]\\]/g;
+  const strKwParts = []; // 存储无特殊字符的关键词（用于合并正则）
+  const regKwParts = []; // 存储转义后的正则关键词（用于合并正则）
+
+  keywords.forEach((keyword) => {
+    if (regexSpecialChars.test(keyword)) {
+      // 含正则特殊字符：转义后加入正则关键词部分
+      const escaped = keyword.replace(regexSpecialChars, "\\$&");
+      regKwParts.push(escaped);
+    } else {
+      // 无特殊字符：直接加入字符串关键词部分
+      strKwParts.push(keyword);
+    }
+  });
+
+  // 构建合并后的正则（空数组时返回匹配失败的正则，避免报错）
+  const buildCombinedRegex = (parts) => {
+    return parts.length
+      ? new RegExp(`(?:${parts.join("|")})`, "i") // 非捕获组+不区分大小写
+      : new RegExp("^$"); // 匹配空字符串（永远不命中）
+  };
+
+  return {
+    combinedStrRegex: buildCombinedRegex(strKwParts),
+    combinedRegRegex: buildCombinedRegex(regKwParts),
+  };
+})();
+
+const safe = (req, res, next) => {
+    try {
+      // 1. 设置安全头（保持不变）
+      // res.setHeader("X-Frame-Options", "SAMEORIGIN");
+      // res.setHeader("X-Content-Type-Options", "nosniff");
+      // res.setHeader("Referrer-Policy", "no-referrer-when-downgrade");
+      // res.removeHeader("Server");
+
+      // 2. 构建检查文本：req.path（仅路径）+ query（非空才加）（优化冗余）
+      let checkText = req.path || "";
+      if (req.query && Object.keys(req.query).length > 0) {
+         const queryStr = Object.entries(req.query)
+          .map(([k, v]) => `${k}=${v}`)
+          .join(' ');
+        checkText += ` ${queryStr}`;
+      }
+
+      // 3. 处理请求体（优化序列化逻辑）
+      let bodyText = "";
+      const contentType = req.headers["content-type"] || "";
+      const isMultipart = contentType.includes("multipart/form-data");
+
+      if (!isMultipart && req.body) {
+        try {
+          // 若已是字符串直接用，否则序列化（避免重复序列化）
+          const bodyStr =
+            typeof req.body === "string" ? req.body : JSON.stringify(req.body);
+
+          // 限制大小（保持原逻辑，避免大文本开销）
+          if (bodyStr.length < 10000) {
+            bodyText = ` ${bodyStr}`;
+          }
+        } catch (e) {
+          // 忽略序列化错误
+        }
+      }
+
+      // 合并完整文本（无需 toLowerCase）
+      const fullText = checkText + bodyText;
+
+     
+
+      // 4. 高效匹配：两次正则 test 替代 N 次循环（核心优化）
+      let foundMatch = false;
+      // 先检查字符串关键词合并正则（更快，因为无复杂正则逻辑）
+      if (combinedStrRegex.test(fullText)) {
+        foundMatch = true;
+      }
+      // 再检查正则关键词合并正则（仅当字符串匹配未命中时）
+      else if (combinedRegRegex.test(fullText)) {
+        foundMatch = true;
+      }
+
+      if (foundMatch) {
+        console.error("[安全拦截] 疑似恶意请求:", {
+          url: req.url,
+          ip: getIp(req),
+          userAgent: req.get("User-Agent") || "",
+        });
+     
+        return res.status(403).send("非法风险请求，已拦截");
+      }
+
+      next();
+    } catch (error) {
+      console.error("[安全中间件异常]", error);
+      res.status(500).send("服务器内部错误");
+    }
+  };
+
+export const waf = (app) => {
+  app.use(safe);
+};

package/package.json

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

package/common/global.js

@@ -1,61 +0,0 @@
-
-import path from "path";
-import fs from "fs";
-import { pathToFileURL } from 'url';  // 新增顶部导入
-import dotenv from "dotenv";
-
-const ROOT_PATH = process.cwd();
-const APP_PATH = path.join(ROOT_PATH, "app");
-const CONFIG_PATH = path.join(APP_PATH, "config");
-const EXTEND_PATH = path.join(APP_PATH, "extend");
-const PUBLIC_PATH = path.join(APP_PATH, "public");
-const MODULES_PATH = path.join(APP_PATH, "modules");
-// 兼容低版本node common包
-import { createRequire } from "module";
-const requirejs = createRequire(import.meta.url);
-
-//let user = getFilePath('app/controller/user.js')
-
-//实现dirname
-global.__dirname = path.dirname(new URL(import.meta.url).pathname);
-//实现__filename
-global.__filename = new URL(import.meta.url).pathname;
-
-//加载环境变量
-const envFile = process.env.ENV_FILE || '.env.prd'
-dotenv.config({ path: path.join(ROOT_PATH, envFile) })
-
-// app
-global.APP_PATH = APP_PATH;
-// config
-global.CONFIG_PATH = CONFIG_PATH;
-// run root path
-global.ROOT_PATH = ROOT_PATH;
-// extend
-global.EXTEND_PATH = EXTEND_PATH;
-// public
-global.PUBLIC_PATH = PUBLIC_PATH;
-// modules
-global.MODULES_PATH = MODULES_PATH;
-// require 兼容低版本node common包
-global.requirejs = requirejs;
-//解决多重...问题
-const importRootFile = async (str) => {
-  let filepath = path.join(global.ROOT_PATH, str);
-  if (fs.existsSync(filepath)) {
-    const fileUrl = pathToFileURL(filepath).href; // 新增转换
-    const module = await import(fileUrl);
-    return module.default || module;
-  }
-};
-
-const importFile = async (filepath) => {
-  if (fs.existsSync(filepath)) {
-    const fileUrl = pathToFileURL(filepath).href; // 新增转换
-    const module = await import(fileUrl);
-    return module.default || module;
-  }
-};
-
-global.importFile = importFile;
-global.importRootFile = importRootFile;

package/extend/import.js

@@ -1,6 +0,0 @@
-import express from "express";
-
-import { z } from 'zod';
-
-
-export { express,  z };

package/utils/bind.js

@@ -1,21 +0,0 @@
-
-/**
- * @description 实例化一个类，并将该类的所有方法绑定到一个新的对象上。
- * @param {Function} className - 需要实例化的类。
- *@returns {Object} 包含绑定方法的对象。
- */
- export const bindClass = function(className) {
-  let obj = {};
-  const cls = new className();
-  Object.getOwnPropertyNames(cls.constructor.prototype).forEach(
-    (methodName) => {
-      if (
-        methodName !== "constructor" &&
-        typeof cls[methodName] === "function"
-      ) {
-        obj[methodName] = cls[methodName].bind(cls);
-      }
-    }
-  );
-  return obj;
-}

package/utils/index.js

@@ -1,12 +0,0 @@
-import {bindClass} from './bind.js'
-import {db} from './db.js'
-import {loaderSort,getPackage,loadConfig,loadController} from './loader.js'
-
-export {
-    bindClass,
-    db,
-    loaderSort,
-    getPackage,
-    loadConfig,
-    loadController
-}

package/utils/response.js

@@ -1,20 +0,0 @@
-export function parseJsonFields(obj) {
-    const result = {};
-    for (const key in obj) {
-      if (!obj.hasOwnProperty(key)) continue;
-      const value = obj[key];
-      // 如果是字符串，并且看起来像 JSON（以 { 或 [ 开头）
-      if (typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
-        try {
-          result[key] = JSON.parse(value);
-        } catch (e) {
-          console.warn(`JSON parse failed for field: ${key}`, e);
-          result[key] = value; // 保留原始值
-        }
-      } else {
-        result[key] = value;
-      }
-    }
-  
-    return result;
-  }