chanjs 2.1.1 → 2.3.0

package/helper/data-parse.js

@@ -1,18 +1,55 @@
 /**
- * 将数组转换为键值对对象
- * @param {Array} arr - 包含键值对的数组
- * @param {string} keyField - 作为键的字段名
- * @param {string} valueField - 作为值的字段名
+ * 解析 JSON 字符串或返回原始值
+ * @param {string} str - 要解析的字符串
+ * @returns {Object|string} 解析后的对象或原始字符串
+ * @description
+ * 尝试将字符串解析为 JSON 对象
+ * 如果解析失败或结果不是对象，则返回原始字符串
+ * @example
+ * const obj = dataParse('{"name":"张三","age":25}');
+ * console.log(obj); // { name: '张三', age: 25 }
+ * 
+ * const str = dataParse('hello');
+ * console.log(str); // 'hello'
+ */
+export function dataParse(str) {
+  try {
+    const data = JSON.parse(str);
+    if (typeof data === 'object' && data !== null) {
+      return data;
+    }
+  } catch (e) {
+    return str;
+  }
+  return str;
+}
+
+/**
+ * 将数组转换为对象
+ * @param {Array<Object>} arr - 要转换的数组
+ * @param {string} [keyField="config_key"] - 作为对象键的字段名
+ * @param {string} [valueField="config_value"] - 作为对象值的字段名
  * @returns {Object} 转换后的对象
+ * @description
+ * 将数组中的每个元素转换为一个键值对
+ * 键由 keyField 指定，值由 valueField 指定
+ * @example
+ * const arr = [
+ *   { config_key: 'app.name', config_value: 'MyApp' },
+ *   { config_key: 'app.port', config_value: '3000' }
+ * ];
+ * const obj = arrToObj(arr);
+ * console.log(obj);
+ * // { 'app.name': 'MyApp', 'app.port': '3000' }
  */
 export const arrToObj = (
   arr,
   keyField = "config_key",
   valueField = "config_value"
 ) => {
-  // 输入验证
   if (!Array.isArray(arr)) {
-    throw new Error("arrToObj 期望接收数组作为第一个参数");
+    console.error("[arrToObj] 输入必须是数组");
+    return {};
   }
 
   return arr.reduce((result, item) => {
@@ -28,16 +65,27 @@ export const arrToObj = (
 };
 
 /**
- * @description 将字符串中的 JSON 字符串转换为对象
- * @param {*} obj - 包含 JSON 字符串的对象
- * @returns
+ * 解析对象中的 JSON 字符串字段
+ * @param {Object} obj - 要处理的对象
+ * @returns {Object} 处理后的对象
+ * @description
+ * 遍历对象的所有属性，将 JSON 字符串格式的值解析为对象
+ * 只解析以 '{' 或 '[' 开头的字符串值
+ * @example
+ * const obj = {
+ *   name: '张三',
+ *   settings: '{"theme":"dark","lang":"zh"}',
+ *   tags: '["a","b","c"]'
+ * };
+ * const result = parseJsonFields(obj);
+ * console.log(result);
+ * // { name: '张三', settings: { theme: 'dark', lang: 'zh' }, tags: ['a', 'b', 'c'] }
  */
 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("["))
@@ -45,8 +93,8 @@ export function parseJsonFields(obj) {
       try {
         result[key] = JSON.parse(value);
       } catch (e) {
-        console.warn(`JSON parse failed for field: ${key}`, e);
-        result[key] = value; // 保留原始值
+        console.error(`JSON parse failed for field: ${key}`, e);
+        result[key] = value;
       }
     } else {
       result[key] = value;
@@ -57,12 +105,35 @@ export function parseJsonFields(obj) {
 }
 
 /**
- * @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} 树形结构数组
+ * 构建树形结构
+ * @param {Array<Object>} arr - 扁平化的数据数组
+ * @param {number|string} [pid=0] - 根节点的父 ID
+ * @param {string} [idKey="id"] - ID 字段名
+ * @param {string} [pidKey="pid"] - 父 ID 字段名
+ * @param {string} [childrenKey="children"] - 子节点字段名
+ * @returns {Array<Object>} 树形结构数组
+ * @description
+ * 将扁平化的数组转换为树形结构
+ * 支持自定义 ID 和父 ID 字段名
+ * 自动检测并跳过循环引用
+ * 自动清理空的 children 数组
+ * @example
+ * const arr = [
+ *   { id: 1, pid: 0, name: '根节点' },
+ *   { id: 2, pid: 1, name: '子节点1' },
+ *   { id: 3, pid: 1, name: '子节点2' },
+ *   { id: 4, pid: 2, name: '孙节点' }
+ * ];
+ * const tree = buildTree(arr);
+ * console.log(tree);
+ * // [
+ * //   { id: 1, pid: 0, name: '根节点', children: [
+ * //     { id: 2, pid: 1, name: '子节点1', children: [
+ * //       { id: 4, pid: 2, name: '孙节点' }
+ * //     ]},
+ * //     { id: 3, pid: 1, name: '子节点2' }
+ * //   ]}
+ * // ]
  */
 export function buildTree(
   arr,
@@ -71,32 +142,45 @@ export function buildTree(
   pidKey = "pid",
   childrenKey = "children"
 ) {
-  // 基础参数校验
-  if (!Array.isArray(arr)) return [];
+  if (!Array.isArray(arr) || arr.length === 0) return [];
 
+  const nodeMap = new Map();
   const tree = [];
+  const visited = new Set();
 
-  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
-      );
+  for (const item of arr) {
+    if (item && typeof item === 'object') {
+      nodeMap.set(item[idKey], { ...item, [childrenKey]: [] });
+    }
+  }
 
-      // 有子节点则添加，避免空数组
-      if (children.length) {
-        item[childrenKey] = children;
+  for (const node of nodeMap.values()) {
+    const parentId = node[pidKey];
+    if (parentId === pid || parentId == null) {
+      tree.push(node);
+    } else {
+      const parent = nodeMap.get(parentId);
+      if (parent) {
+        if (visited.has(node[idKey])) {
+          console.error(`[buildTree] 检测到循环引用: ${node[idKey]}`);
+          continue;
+        }
+        visited.add(node[idKey]);
+        parent[childrenKey].push(node);
       }
-
-      tree.push(item);
     }
   }
 
+  const cleanEmptyChildren = (nodes) => {
+    for (const node of nodes) {
+      if (node[childrenKey].length === 0) {
+        delete node[childrenKey];
+      } else {
+        cleanEmptyChildren(node[childrenKey]);
+      }
+    }
+  };
+  cleanEmptyChildren(tree);
+
   return tree;
 }

package/helper/db.js

@@ -1,91 +1,79 @@
 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 "数据库权限不足，请检查配置。";
+/**
+ * 创建 Knex 数据库连接实例
+ * @param {Object} config - 数据库配置对象
+ * @param {string} config.client - 数据库客户端类型（如 mysql2, pg, sqlite3）
+ * @param {Object} config.connection - 数据库连接配置
+ * @param {Object} [config.pool] - 连接池配置
+ * @returns {Knex} Knex 实例
+ * @example
+ * const db = db({
+ *   client: 'mysql2',
+ *   connection: {
+ *     host: 'localhost',
+ *     user: 'root',
+ *     password: 'password',
+ *     database: 'mydb'
+ *   }
+ * });
+ */
+export function db(config) {
+  return knex(config);
+}
+
+/**
+ * 根据前缀从环境变量中获取数据库配置
+ * @param {string} prefix - 配置前缀（如 primary, secondary, redis）
+ * @returns {Object|null} 解析后的配置对象，如果配置不存在或解析失败则返回 null
+ * @description
+ * 支持的前缀映射：
+ * - primary -> DB_PRIMARY
+ * - secondary -> DB_SECONDARY
+ * - redis -> REDIS
+ * - 其他 -> DB_{PREFIX.toUpperCase()}
+ * 
+ * 配置格式为 JSON 字符串，存储在环境变量中
+ * @example
+ * // 环境变量: DB_PRIMARY='{"client":"mysql2","connection":{"host":"localhost"}}'
+ * const config = prefixDbConfig('primary');
+ * // 返回: { client: 'mysql2', connection: { host: 'localhost' } }
+ */
+export function prefixDbConfig(prefix) {
+  const prefixMap = {
+    primary: "DB_PRIMARY",
+    secondary: "DB_SECONDARY",
+    redis: "REDIS",
+  };
+  const envKey = prefixMap[prefix] || `DB_${prefix.toUpperCase()}`;
+  const configStr = process.env[envKey];
+
+  if (configStr) {
+    try {
+      return JSON.parse(configStr);
+    } catch (e) {
+      console.error(`[DB] 配置解析失败: ${envKey}`);
+      return null;
+    }
   }
-  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,
-  filename = "",
-}) => {
-  let config = {
+
+  const client = process.env.DB_CLIENT || "mysql2";
+  if (client !== "mysql2") {
+    return null;
+  }
+
+  return {
     client,
     connection: {
-      host,
-      port,
-      user,
-      password,
-      database,
-      charset,
+      host: process.env.DB_HOST || "localhost",
+      port: parseInt(process.env.DB_PORT || "3306"),
+      user: process.env.DB_USER || "root",
+      password: process.env.DB_PASS || "123456",
+      database: process.env.DB_DATABASE || "chancms"
     },
-    debug,
     pool: {
-      //默认为{min: 2, max: 10},连接池配置
-      min,
-      max,
-      // 添加连接池错误处理
-      afterCreate: (conn, done) => {
-        conn.on("error", (error) => {
-          console.error(
-            `[连接池错误] 连接出错: ${getDefaultErrorMessage(error)}`,
-            error
-          );
-        });
-        done(null, conn);
-      },
-    },
-    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);
-      },
-    },
+      min: parseInt(process.env.DB_POOL_MIN || "2"),
+      max: parseInt(process.env.DB_POOL_MAX || "10")
+    }
   };
-
-  if (client === "sqlite3" || client === "better-sqlite3") {
-    config.connection.filename = filename;
-  }
-
-  return knex(config);
-};
+}