chanjs 2.0.4 → 2.0.5

package/helper/dataparse.js

@@ -0,0 +1,24 @@
+/**
+ * 将数组转换为键值对对象
+ * @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;
+    }, {});
+  };

package/helper/db.js

@@ -0,0 +1,75 @@
+import knex from "knex";
+
+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",
+  password = "123456",
+  database = "test",
+  port = 3306,
+  debug = true,
+  charset = "utf8mb4",
+  min = 0,
+  max = 2,
+}) =>{
+  let config = {
+    client,
+    connection: {
+      host,
+      port,
+      user,
+      password,
+      database,
+      charset,
+    },
+    debug,
+    pool: {
+      //默认为{min: 2, max: 10},连接池配置
+      min,
+      max,
+    },
+    log: {
+      warn(message) {
+        console.error("[knex warn]", message);
+      },
+      error(message) {
+        console.error("[knex error]", message);
+      },
+      debug(message) {
+        console.log("[knex debug]", message);
+      },
+      deprecate(message) {
+        console.warn("[knex deprecate]", message);
+      },
+      trace(message) {
+        console.log("[knex trace]", message);
+      },
+      log(message) {
+        console.log("[knex log]", message);
+      },
+      info(message) {
+        console.log("[knex info]", message);
+      },
+    },
+  };
+  return knex(config);
+};

package/helper/file.js

@@ -0,0 +1,202 @@
+import fs from 'fs/promises';
+import { accessSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import path from 'path';
+
+/**
+ * 获取指定路径的文件树结构
+ * 
+ * @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(APP_PATH, itemPath),
+        type: itemStats.isDirectory() ? 'directory' : 'file',
+        size: itemStats.size,
+        modified: itemStats.mtime,
+        depth: itemPath.split(path.sep).length - path.resolve(APP_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)) {
+      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)) {
+      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,25 @@
+import {
+  getFileTree,
+  readFileContent,
+  saveFileContent,
+  isPathSafe,
+} from "./file.js";
+import { setToken, getToken } from "./token.js";
+import { formatDay, fromatTime } from "./time.js";
+import { buildTree } from "./tree.js";
+import { htmlDecode } from "./html.js";
+import { getIp } from "./ip.js";
+
+export default {
+  getFileTree,
+  readFileContent,
+  saveFileContent,
+  isPathSafe,
+  setToken,
+  getToken,
+  formatDay,
+  fromatTime,
+  buildTree,
+  htmlDecode,
+  getIp
+};

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/helper/loader.js

@@ -0,0 +1,65 @@
+import fs from "fs";
+import path from "path";
+import { bindClass } from "./bind.js";
+
+/**
+ *
+ * @param {*} module 模块目录
+ * @returns Array
+ * @description 将web模块放到最后加载
+ */
+export const loaderSort = (modules = []) => {
+  const index = modules.indexOf("web");
+  if (index !== -1) {
+    const web = modules.splice(index, 1);
+    modules.push(web[0]);
+  }
+  return modules;
+};
+
+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");
+  console.log("config", config);
+  return config;
+};
+
+/**
+ * 加载指定模块名下的所有控制器文件
+ * @param {string} moduleName - 模块名称
+ * @returns {Promise<Object>} - 控制器对象
+ */
+export const loadController = async function (moduleName) {
+  const 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"));
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const name = file.replace(/\.js$/i, ""); // 安全处理 .js 后缀
+
+    try {
+      const module = await importFile(filePath);
+      let obj = module.default || module;
+
+      controller[name] = obj;
+    } catch (e) {
+      console.error(`加载控制器失败: ${filePath}`, e);
+      // 可选：抛出错误或继续加载其他文件
+      // throw e;
+    }
+  }
+
+  return controller;
+};

package/helper/response.js

@@ -0,0 +1,20 @@
+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;
+  }