chanjs 2.0.17 → 2.0.19

package/config/code.js

@@ -1,4 +1,6 @@
-// 简化的状态码定义（数字作为键）
+/**
+ * @description 状态码定义
+ */
 export const CODE = {
   200: "操作成功", // 成功
   201: "操作失败", // 通用失败
@@ -36,7 +38,9 @@ export const CODE = {
   6009: "数据库连接已关闭，请重试", // 连接已关闭
 };
 
-// 数据库错误码映射（仅映射状态码）
+/**
+ * @description 数据库错误码定义
+ */
 export const DB_ERROR = {
   ECONNREFUSED: 6001,
   ER_ACCESS_DENIED_ERROR: 6002,

package/core/controller.js

@@ -1,6 +1,10 @@
+
+import {formatTime} from "../helper/time.js";
+
 export default class Controller {
   constructor() {}
-  success(data) {
+
+  success(data){
     return {
       success: true,
       msg: "操作成功",

package/core/service.js

@@ -1,7 +1,27 @@
 import { success, fail, error } from "../utils/response.js";
 import { CODE } from "../config/code.js";
-// ====================== 共享数据库方法 ======================
-const databaseMethods = {
+
+/**
+ * 数据库服务类
+ */
+class Service {
+  /**
+   * 构造函数
+   * @param {Object} knex - Knex实例
+   * @param {string} tableName - 表名
+   */
+  constructor(knex, tableName) {
+    if (!knex || !tableName) {
+      throw new Error("Service: knex instance and tableName are required");
+    }
+
+    this.db = knex;
+    this.tableName = tableName;
+    this.pageSize = 100;
+  }
+
+
+
   /**
    * 查询表所有记录（慎用）
    * @param {Object} query - 查询条件
@@ -9,112 +29,130 @@ const databaseMethods = {
    */
   async all(query = {}) {
     try {
-      let dbQuery = this.knex(this.model);
-      if (Object.keys(query).length > 0) {
-        dbQuery = dbQuery.where(query);
-      }
-      const res = await dbQuery.select();
+      let _query = this.db(this.tableName);
+      if (Object.keys(query).length) _query = _query.where(query);
+      const res = await _query.select();
       return success(res);
     } catch (err) {
       return error(err);
     }
-  },
+  }
+
+ /**
+ * 查询所有文档（仅支持对象模式排序）
+ * @param {Object} query - 查询条件，可包含 sort: { field: 'asc|desc' }
+ * @returns {Promise} 查询结果
+ */
+async find(query = {}) {
+  try {
+    let _query = this.db(this.tableName);
+
+    // 解构出排序参数，剩余作为 where 条件
+    const { sort, ...whereConditions } = query;
+
+    // 应用 where 条件
+    if (Object.keys(whereConditions).length > 0) {
+      _query = _query.where(whereConditions);
+    }
+
+    // 应用排序（仅支持对象模式）
+    if (sort && typeof sort === 'object') {
+      for (const [field, dir] of Object.entries(sort)) {
+        const direction = ['asc', 'desc'].includes(dir.toLowerCase()) 
+          ? dir.toLowerCase() 
+          : 'asc'; // 默认升序
+        _query = _query.orderBy(field, direction);
+      }
+    }
+
+    const res = await _query.select();
+    return success(res);
+  } catch (err) {
+    return error(err);
+  }
+}
 
   /**
    * 获取单个记录
    * @param {Object} query - 查询条件
    * @returns {Promise} 查询结果
    */
-  async one(query = {}) {
+  async findOne(query = {}) {
     try {
-      let dbQuery = this.knex(this.model);
-      if (Object.keys(query).length > 0) {
-        dbQuery = dbQuery.where(query);
-      }
+      let dbQuery = this.db(this.tableName);
+      if (Object.keys(query).length) dbQuery = dbQuery.where(query);
       const res = await dbQuery.first();
       return success(res);
     } catch (err) {
       return error(err);
     }
-  },
+  }
 
   /**
    * 根据ID查询记录
    * @param {Object} options - 查询选项
    * @param {Object} options.query - 查询条件
-   * @param {Array} options.field - 返回字段
-   * @param {number} options.len - 返回数量
+   * @param {Array}  options.field - 返回字段
    */
-  async findById({ query, field = [], len = 1 }) {
+  async findById({ query, field = [] }) {
     try {
-      let dataQuery = this.knex(this.model).where(query);
-      if (field.length > 0) dataQuery = dataQuery.select(field);
-      if (len === 1) dataQuery = dataQuery.first();
-      else if (len > 1) dataQuery = dataQuery.limit(len);
-      
-      const res = await dataQuery;
-      return success(res || (len === 1 ? {} : []));
+      let _query = this.db(this.tableName).where(query);
+      if (field.length) _query = _query.select(field);
+      const res = await _query.first();
+      return success(res);
     } catch (err) {
       return error(err);
     }
-  },
+  }
 
+ 
   /**
    * 创建新记录
-   * @param {Object} data - 包含要插入的数据对象
+   * @param {Object} data - 要插入的数据
    * @returns {Promise} 操作结果
    */
   async insert(data = {}) {
     try {
-      console.log('data--->',data)
-      if (Object.keys(data).length === 0) {
-        return fail(CODE[2002], { code: 2002 });
-      }
-
-      console.log('this.model--->',this.model)
-      const result = await this.knex(this.model).insert(data);
-      return success(result?.length > 0 || !!result);
+      if (!Object.keys(data).length) return fail(CODE[2002], { code: 2002 });
+      const result = await this.db(this.tableName).insert(data);
+      return success(result);
     } catch (err) {
       return error(err);
     }
-  },
+  }
 
   /**
    * 插入多条记录
-   * @param {Array} records - 包含要插入的数据对象数组
+   * @param {Array} records - 数据数组
    * @returns {Promise} 操作结果
    */
   async insertMany(records = []) {
     try {
-      if (records.length === 0) {
-        return fail(CODE[2002], { code: 2002 });
-      }
-      const result = await this.knex(this.model).insert(records);
+      if (!records.length) return fail(CODE[2002], { code: 2002 });
+      const result = await this.db(this.tableName).insert(records);
       return success(result);
     } catch (err) {
       return error(err);
     }
-  },
+  }
 
   /**
-   * 根据指定条件删除记录
-   * @param {Object} query - 包含查询条件的对象
+   * 根据条件删除记录
+   * @param {Object} query - 查询条件
    * @returns {Promise} 操作结果
    */
   async delete(query = {}) {
     try {
-      if (Object.keys(query).length === 0) {
-        return fail(CODE[2002], { code: 2002 });
-      }
-      const affectedRows = await this.knex(this.model).where(query).del();
+      if (!Object.keys(query).length) return fail(CODE[2002], { code: 2002 });
+      const affectedRows = await this.db(this.tableName).where(query).del();
       return success(affectedRows > 0);
     } catch (err) {
       return error(err);
     }
-  },
+  }
 
   /**
-   * 根据指定条件更新记录
+   * 根据条件更新记录
    * @param {Object} options - 更新选项
    * @param {Object} options.query - 查询条件
    * @param {Object} options.params - 更新数据
@@ -122,37 +160,38 @@ const databaseMethods = {
    */
   async update({ query, params } = {}) {
     try {
-      if (!query || !params || Object.keys(query).length === 0) {
+      if (!query || !params || !Object.keys(query).length) {
         return fail(CODE[2001], { code: 2001 });
       }
-      console.log('query--->',query)
-      console.log('this.model--->',this.model)
-
-      console.log('params---->',params)
-      const result = await this.knex(this.model).where(query).update(params);
-      console.log('result--->',result)
+      const result = await this.db(this.tableName).where(query).update(params);
       return success(!!result);
     } catch (err) {
       return error(err);
     }
-  },
+  }
 
   /**
-   * 批量更新多条记录
-   * @param {Array} updates - 更新操作数组
+   * 批量更新多条记录（事务）
+   * @param {Array} updates - [{ query, params }, ...]
    * @returns {Promise} 操作结果
    */
   async updateMany(updates = []) {
-    if (!Array.isArray(updates) || updates.length === 0) {
+    if (!Array.isArray(updates) || !updates.length) {
       return fail(CODE[2002], { code: 2002 });
     }
-    
-    const trx = await this.knex.transaction();
+
+    const trx = await this.db.transaction();
     try {
       for (const { query, params } of updates) {
-        const result = await trx(this.model).where(query).update(params);
+        // FIX-4 防止空条件全表更新
+        if (!query || !Object.keys(query).length) {
+          await trx.rollback();
+          return fail('批量更新不允许空条件');
+        }
+        const result = await trx(this.tableName).where(query).update(params);
         if (result === 0) {
           await trx.rollback();
+          console.warn('[updateMany] 未匹配到行, query=%j', query); // FIX-3 日志
           return fail(`更新失败: ${JSON.stringify(query)}`);
         }
       }
@@ -162,91 +201,95 @@ const databaseMethods = {
       await trx.rollback();
       return error(err);
     }
-  },
+  }
+
 
   /**
    * 分页查询
    * @param {Object} options - 查询选项
-   * @param {number} options.current - 当前页码
-   * @param {number} options.pageSize - 每页大小
-   * @param {Object} options.query - 查询条件
-   * @param {Array} options.field - 返回字段
+   * @param {number} options.current  - 当前页
+   * @param {number} options.pageSize - 每页条数
+   * @param {Object} options.query    - 查询条件
+   * @param {Array}  options.field    - 返回字段
    * @returns {Promise} 查询结果
    */
   async query({ current = 1, pageSize = 10, query = {}, field = [] }) {
     try {
-      const offset = (current - 1) * pageSize;
-      let countQuery = this.knex(this.model).count("* as total");
-      let dataQuery = this.knex(this.model);
-      
-      if (Object.keys(query).length > 0) {
-        Object.entries(query).forEach(([key, value]) => {
-          countQuery = countQuery.where(key, value);
-          dataQuery = dataQuery.where(key, value);
+      const size = pageSize; // 如需要可再做非空校验
+      const offset = (current - 1) * size;
+
+      let countQuery = this.db(this.tableName).count("* as total");
+      let dataQuery  = this.db(this.tableName);
+
+      if (Object.keys(query).length) {
+        Object.entries(query).forEach(([k, v]) => {
+          countQuery = countQuery.where(k, v);
+          dataQuery  = dataQuery.where(k, v);
         });
       }
 
-      if (field.length > 0) dataQuery = dataQuery.select(field);
+      if (field && field.length) dataQuery = dataQuery.select(field);
 
       const [totalResult, list] = await Promise.all([
         countQuery.first(),
-        dataQuery.offset(offset).limit(pageSize)
+        dataQuery.offset(offset).limit(size),
       ]);
 
-      const total = totalResult?.total || 0;
-      return success({ list, total, current, pageSize });
+      // FIX-1 显式转数字，防止字符串 "0"
+      const total = Number(totalResult?.total ?? 0);
+      return success({ list, total, current, pageSize: size });
     } catch (err) {
       return error(err);
     }
-  },
+  }
 
   /**
    * 计数查询
-   * @param {Array} query - 查询条件数组
+   * @param {Object} query - 查询条件
    * @returns {Promise} 查询结果
    */
-  async count(query = []) {
+  async count(query = {}) {
     try {
-      let dataQuery = this.knex(this.model);
-      if (query.length > 0) {
-        query.forEach(condition => dataQuery = dataQuery.where(condition));
-      }
+      let dataQuery = this.db(this.tableName);
+      if (Object.keys(query).length) dataQuery = dataQuery.where(query);
       const result = await dataQuery.count("* as total").first();
-      return success(Number(result?.total) || 0);
+      return success(Number(result?.total ?? 0));
     } catch (err) {
       return error(err);
     }
   }
-};
 
-// ====================== 工厂函数 ======================
-/**
- * 创建数据库服务实例
- * @param {Object} knex - Knex实例
- * @param {string} model - 表名/模型名
- * @returns {Object} 数据库服务实例
- */
-export default function Service(knex, model) {
-  if (!knex || !model) {
-    throw new Error('Service: knex instance and model name are required');
-  }
-  
-  // 创建继承数据库方法的轻量对象
-  const service = Object.create(databaseMethods);
-  
-  // 设置实例专属状态（不可写）
-  Object.defineProperties(service, {
-    knex: {
-      value: knex,
-      writable: false,
-      enumerable: true
-    },
-    model: {
-      value: model,
-      writable: false,
-      enumerable: true
+  /**
+   * 多表关联查询
+   * @param {Object} query - 关联配置
+   * @returns {Promise} 查询结果
+   */
+  async join(query) {
+    try {
+      const {
+        joinTable,
+        localField,
+        foreignField,
+        select = "*",
+        where = {},
+      } = query;
+
+      let _query = this.db(this.tableName)
+        .join(
+          joinTable,
+          `${this.tableName}.${localField}`,
+          "=",
+          `${joinTable}.${foreignField}`
+        )
+        .select(select);
+
+      if (Object.keys(where).length) _query = _query.where(where);
+      const res = await _query;
+      return success(res);
+    } catch (err) {
+      return error(err);
     }
-  });
-  
-  return service;
+  }
 }
+
+export default Service;

package/extend/art-template.js

@@ -1,5 +1,5 @@
 const template = requirejs("art-template");
-import dayjs from 'dayjs';
+import dayjs from "dayjs";
 // 注册 dateFormat 函数
 template.defaults.imports.dateFormat = function (date, format) {
   if (!date) {

package/global/import.js

@@ -1,4 +1,3 @@
-
 import fs from "fs/promises";
 import { pathToFileURL } from "url";
 import { createRequire } from "module";
@@ -9,8 +8,8 @@ import { createRequire } from "module";
  * @returns {Promise<object|null>} 模块对象或null
  */
 const importFile = async (filepath) => {
-  if (!filepath || typeof filepath !== 'string') {
-    console.error('错误: 文件路径必须是有效的字符串');
+  if (!filepath || typeof filepath !== "string") {
+    console.error("错误: 文件路径必须是有效的字符串");
     return null;
   }
 
@@ -20,9 +19,9 @@ const importFile = async (filepath) => {
     const module = await import(fileUrl);
     return module.default || module;
   } catch (error) {
-    if (error.code === 'ENOENT') {
+    if (error.code === "ENOENT") {
       console.error(`文件不存在: ${filepath}`);
-    } else if (error.code === 'EACCES') {
+    } else if (error.code === "EACCES") {
       console.error(`没有权限访问文件: ${filepath}`);
     } else {
       console.error(`导入文件时出错 [${filepath}]:`, error.message);
@@ -37,4 +36,4 @@ const importFile = async (filepath) => {
 export const importjs = createRequire(import.meta.url);
 
 global.requirejs = importjs;
-global.importFile = importFile;
+global.importFile = importFile;

package/helper/data-parse.js

@@ -5,53 +5,58 @@
  * @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;
-    }, {});
-  };
-
+export const arrToObj = (
+  arr,
+  keyField = "config_key",
+  valueField = "config_value"
+) => {
+  // 输入验证
+  if (!Array.isArray(arr)) {
+    throw new Error("arrToObj 期望接收数组作为第一个参数");
+  }
 
-  /**
-   * @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 {
+  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字段名
@@ -59,27 +64,39 @@ export const arrToObj = (arr, keyField = 'config_key', valueField = 'config_valu
  * @param {string} [childrenKey='children'] - 子节点字段名
  * @returns {Array} 树形结构数组
  */
-export function buildTree(arr, pid = 0, idKey = 'id', pidKey = 'pid', childrenKey = 'children') {
+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);
-      
+      const children = buildTree(
+        arr.slice(i + 1),
+        item[idKey],
+        idKey,
+        pidKey,
+        childrenKey
+      );
+
       // 有子节点则添加，避免空数组
       if (children.length) {
         item[childrenKey] = children;
       }
-      
+
       tree.push(item);
     }
   }
-  
+
   return tree;
 }