chanjs 2.1.1 → 2.3.0

package/core/service.js

@@ -1,307 +0,0 @@
-import { success, fail, error } from "../utils/response.js";
-import { CODE } from "../config/code.js";
-
-/**
- * 数据库服务类
- */
-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 = Chan.config?.PAGE_SIZE || 20;
-    this.limit = Chan.config?.LIMIT_MAX || 300;
-  }
-
-
-
-  /**
-   * 查询表所有记录（慎用）
-   * @param {Object} query - 查询条件
-   * @returns {Promise} 查询结果
-   */
-  async all(query = {}) {
-    try {
-      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 findOne(query = {}) {
-    try {
-      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 - 返回字段
-   */
-  async findById({ query, field = [] }) {
-    try {
-      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 - 要插入的数据
-   * @returns {Promise} 操作结果
-   */
-  async insert(data = {}) {
-    try {
-      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 - 数据数组
-   * @returns {Promise} 操作结果
-   */
-  async insertMany(records = []) {
-    try {
-      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 - 查询条件
-   * @returns {Promise} 操作结果
-   */
-  async delete(query = {}) {
-    try {
-      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 - 更新数据
-   * @returns {Promise} 操作结果
-   */
-  async update({ query, params } = {}) {
-    try {
-      if (!query || !params || !Object.keys(query).length) {
-        return fail(CODE[2001], { code: 2001 });
-      }
-      const result = await this.db(this.tableName).where(query).update(params);
-      return success(!!result);
-    } catch (err) {
-      return error(err);
-    }
-  }
-
-  /**
-   * 批量更新多条记录（事务）
-   * @param {Array} updates - [{ query, params }, ...]
-   * @returns {Promise} 操作结果
-   */
-  async updateMany(updates = []) {
-    if (!Array.isArray(updates) || !updates.length) {
-      return fail(CODE[2002], { code: 2002 });
-    }
-
-    const trx = await this.db.transaction();
-    try {
-      for (const { query, params } of updates) {
-        // 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)}`);
-        }
-      }
-      await trx.commit();
-      return success(true);
-    } catch (err) {
-      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 {Object} options.sort     - 排序条件 { field: 'asc|desc' }
-   * @returns {Promise} 查询结果
-   */
-  async query({ current = 1, pageSize = 10, query = {}, field = [], sort = {} }) {
-    try {
-      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 && field.length) dataQuery = dataQuery.select(field);
-
-      // 应用排序（仅支持对象模式）
-      if (sort && typeof sort === 'object' && Object.keys(sort).length) {
-        for (const [field, dir] of Object.entries(sort)) {
-          const direction = ['asc', 'desc'].includes(dir.toLowerCase()) 
-            ? dir.toLowerCase() 
-            : 'asc';
-          dataQuery = dataQuery.orderBy(field, direction);
-        }
-      }
-
-      const [totalResult, list] = await Promise.all([
-        countQuery.first(),
-        dataQuery.offset(offset).limit(size),
-      ]);
-
-      // FIX-1 显式转数字，防止字符串 "0"
-      const total = Number(totalResult?.total ?? 0);
-      return success({ list, total, current, pageSize: size });
-    } catch (err) {
-      return error(err);
-    }
-  }
-
-  /**
-   * 计数查询
-   * @param {Object} query - 查询条件
-   * @returns {Promise} 查询结果
-   */
-  async count(query = {}) {
-    try {
-      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));
-    } catch (err) {
-      return error(err);
-    }
-  }
-
-  /**
-   * 多表关联查询
-   * @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);
-    }
-  }
-}
-
-export default Service;

package/middleware/log.js

@@ -1,21 +0,0 @@
-import morgan from "morgan";
-import { getIp } from "../helper/ip.js";
-morgan.token("ip", (req, res) => {
-  return getIp(req);
-});
-// 自定义 morgan 格式：IP Method URL Status Length - Response-Time ms
-morgan.format("chancms", (tokens, req, res) => {
-  return [
-    tokens.ip(req, res), // 客户端 IP
-    tokens.method(req, res), // GET/POST
-    tokens.url(req, res), // 完整 URL（含 query）
-    tokens.status(req, res), // 状态码（如 403）
-    tokens.res(req, res, "content-length") || "-", // 响应体大小
-    "-", // 占位符（原日志中的 '-'）
-    tokens["response-time"](req, res),
-    "ms", // 响应时间
-  ].join(" ");
-});
-export const log = (app, logger) => {
-  app.use(morgan(logger.level));
-};