chanjs 2.1.0 → 2.3.0

package/base/Service.js

@@ -0,0 +1,539 @@
+/**
+ * 数据库服务基类
+ * 提供常用的数据库操作方法，包括增删改查、分页查询、事务等
+ */
+import { formatTime, formatDateFields } from "../helper/time.js";
+
+class Service {
+  /**
+   * 构造函数
+   * @param {Object} knex - Knex数据库实例
+   * @param {string} tableName - 表名
+   */
+  constructor(knex = null, tableName = null) {
+    if (knex && tableName) {
+      this.db = knex;
+      this.tableName = tableName;
+      this._config = Chan.config || {};
+    } else if (global.appContext) {
+      this.context = global.appContext;
+    } else {
+      this.context = { get: () => null, set: () => null };
+    }
+
+    this._dateFields = ['created_at', 'updated_at', 'deleted_at', 'publish_time', 'start_time', 'end_time', 'login_time', 'created_date', 'updated_date', 'createdAt', 'updatedAt', 'deletedAt', 'publishTime', 'startTime', 'endTime', 'loginTime', 'createdDate', 'updatedDate'];
+  }
+
+  /**
+   * 获取每页大小配置
+   * @returns {number} 每页记录数，默认20
+   */
+  get pageSize() {
+    return this._config.PAGE_SIZE || 20;
+  }
+
+  /**
+   * 获取最大限制配置
+   * @returns {number} 最大记录数，默认300
+   */
+  get limit() {
+    return this._config.LIMIT_MAX || 300;
+  }
+
+  /**
+   * 获取模型实例
+   * @param {string} name - 模型名称
+   * @returns {Object} 模型实例
+   */
+  getModel(name) {
+    return this.context.getModel(name);
+  }
+
+  /**
+   * 获取数据库连接
+   * @param {string} name - 数据库名称
+   * @returns {Object} 数据库实例
+   */
+  getDB(name) {
+    return this.context.get(`db:${name}`);
+  }
+
+  /**
+   * 执行事务
+   * @param {Function} callback - 事务回调函数
+   * @returns {Promise} 事务执行结果
+   */
+  async withTransaction(callback) {
+    const db = this.getDB("default") || Chan.db;
+    return db.transaction(callback);
+  }
+
+  /**
+   * 检查数据库连接是否可用
+   * @private
+   * @throws {Error} 数据库连接不可用时抛出异常
+   */
+  _checkDB() {
+    if (!this.db) {
+      throw new Error("Database connection not available");
+    }
+  }
+
+  /**
+   * 格式化日期字段
+   * @private
+   * @param {Object} data - 要格式化的数据对象
+   * @returns {Object} 格式化后的数据
+   * @description 自动将日期字符串转换为数据库可识别的格式
+   */
+  _formatDateFields(data) {
+    if (!data || typeof data !== 'object') return data;
+    
+    const result = { ...data };
+    for (const field of this._dateFields) {
+      if (result[field] && typeof result[field] === 'string') {
+        try {
+          const date = new Date(result[field]);
+          if (!isNaN(date.getTime())) {
+            result[field] = date;
+          }
+        } catch (error) {
+          console.error(`[Service._formatDateFields] 日期字段 ${field} 格式化失败:`, {
+            value: result[field],
+            error: error.message
+          });
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * 构建基础查询
+   * @private
+   * @param {Object} options - 查询选项
+   * @param {Object} options.query - 查询条件
+   * @param {Object} options.sort - 排序条件
+   * @param {Array} options.fields - 查询字段
+   * @returns {Object} Knex查询构建器
+   */
+  _buildBaseQuery({ query = {}, sort = {}, fields = [] } = {}) {
+    this._checkDB();
+    
+    let dbQuery = this.db(this.tableName);
+    
+    if (Object.keys(query).length) dbQuery = dbQuery.where(query);
+    if (fields.length) dbQuery = dbQuery.select(fields);
+    
+    if (sort && typeof sort === 'object') {
+      for (const [field, dir] of Object.entries(sort)) {
+        const direction = ['asc', 'desc'].includes(dir.toLowerCase()) ? dir.toLowerCase() : 'asc';
+        dbQuery = dbQuery.orderBy(field, direction);
+      }
+    }
+    
+    return dbQuery;
+  }
+
+  /**
+   * 查询所有记录
+   * @param {Object} options - 查询选项
+   * @param {Object} options.query - 查询条件
+   * @param {Object} options.sort - 排序条件
+   * @param {Array} options.fields - 查询字段
+   * @returns {Promise<Array>} 查询结果数组
+   */
+  async all({ query = {}, sort = {}, fields = [] } = {}) {
+    const _query = this._buildBaseQuery({ query, sort, fields });
+    const res = await _query.select();
+    return formatDateFields(res, this._dateFields);
+  }
+
+  /**
+   * 分页查询记录
+   * @param {Object} options - 查询选项
+   * @param {Object} options.query - 查询条件
+   * @param {Object} options.sort - 排序条件
+   * @param {Array} options.fields - 查询字段
+   * @param {number} options.limit - 限制条数
+   * @param {number} options.offset - 偏移量
+   * @returns {Promise<Object>} 查询结果，包含data字段
+   */
+  async find({ query = {}, sort = {}, fields = [], limit, offset } = {}) {
+    let _query = this._buildBaseQuery({ query, sort, fields });
+
+    if (typeof offset === 'number') {
+      _query = _query.offset(offset);
+    }
+    if (typeof limit === 'number') {
+      _query = _query.limit(limit);
+    }
+
+    const res = await _query.select();
+    return { success: true, code: 200, msg: '查询成功', data: formatDateFields(res, this._dateFields) };
+  }
+
+  /**
+   * 查询单条记录
+   * @param {Object} options - 查询选项
+   * @param {Object} options.query - 查询条件
+   * @param {Array} options.fields - 查询字段
+   * @returns {Promise<Object>} 查询结果，包含data字段
+   */
+  async findOne({ query = {}, fields = [] } = {}) {
+    this._checkDB();
+    
+    let dbQuery = this.db(this.tableName);
+    if (Object.keys(query).length) dbQuery = dbQuery.where(query);
+    if (fields.length) dbQuery = dbQuery.select(fields);
+    const res = await dbQuery.first();
+    
+    if (!res) {
+      return { success: false, code: 404, msg: '记录不存在', data: null };
+    }
+    
+    return { success: true, code: 200, msg: '查询成功', data: formatDateFields(res, this._dateFields) };
+  }
+
+  /**
+   * 根据ID查询单条记录
+   * @param {number|string} id - 记录ID
+   * @param {Object} options - 查询选项
+   * @param {Array} options.fields - 查询字段
+   * @returns {Promise<Object>} 查询结果，包含data字段
+   */
+  async findById(id, { fields = [] } = {}) {
+    this._checkDB();
+    
+    let _query = this.db(this.tableName).where({ id });
+    if (fields.length) _query = _query.select(fields);
+    const res = await _query.first();
+    
+    if (!res) {
+      return { success: false, code: 404, msg: '记录不存在', data: null };
+    }
+    
+    return { success: true, code: 200, msg: '查询成功', data: formatDateFields(res, this._dateFields) };
+  }
+
+  /**
+   * 插入单条记录
+   * @param {Object} data - 要插入的数据
+   * @returns {Promise<Object>} 插入结果，包含insertId和affectedRows
+   */
+  async insert(data = {}) {
+    this._checkDB();
+    
+    if (!Object.keys(data).length) return { success: false, code: 400, msg: '参数缺失', data: {} };
+    const formattedData = this._formatDateFields(data);
+    const result = await this.db(this.tableName).insert(formattedData);
+    return { success: true, code: 200, msg: '插入成功', data: { insertId: result[0], affectedRows: result.length } };
+  }
+
+  /**
+   * 批量插入记录
+   * @param {Array} records - 要插入的记录数组
+   * @returns {Promise<Object>} 插入结果，包含insertIds和affectedRows
+   */
+  async insertMany(records = []) {
+    this._checkDB();
+    
+    if (!records.length) return { success: false, code: 400, msg: '参数缺失', data: {} };
+    const formattedRecords = records.map(record => this._formatDateFields(record));
+    const result = await this.db(this.tableName).insert(formattedRecords);
+    return { success: true, code: 200, msg: '批量插入成功', data: { insertIds: result, affectedRows: result.length } };
+  }
+
+  /**
+   * 根据条件删除记录
+   * @param {Object} query - 删除条件
+   * @returns {Promise<Object>} 删除结果，包含affectedRows
+   */
+  async delete(query = {}) {
+    this._checkDB();
+    
+    if (!Object.keys(query).length) return { success: false, code: 400, msg: '参数缺失', data: {} };
+    const affectedRows = await this.db(this.tableName).where(query).del();
+    return { success: true, code: 200, msg: '删除成功', data: { affectedRows } };
+  }
+
+  /**
+   * 根据ID删除记录
+   * @param {number|string} id - 记录ID
+   * @returns {Promise<Object>} 删除结果，包含affectedRows
+   */
+  async deleteById(id) {
+    this._checkDB();
+    
+    if (!id) return { success: false, code: 400, msg: '参数缺失', data: {} };
+    const affectedRows = await this.db(this.tableName).where({ id }).del();
+    return { success: true, code: 200, msg: '删除成功', data: { affectedRows } };
+  }
+
+  /**
+   * 根据条件更新记录
+   * @param {Object} options - 更新选项
+   * @param {Object} options.query - 更新条件
+   * @param {Object} options.data - 更新数据
+   * @returns {Promise<Object>} 更新结果，包含affectedRows
+   */
+  async updateByQuery({ query, data } = {}) {
+    this._checkDB();
+    
+    if (!query || !data || !Object.keys(query).length || !Object.keys(data).length) {
+      return { success: false, code: 400, msg: '参数无效', data: {} };
+    }
+    const formattedData = this._formatDateFields(data);
+    const affectedRows = await this.db(this.tableName).where(query).update(formattedData);
+    return { success: true, code: 200, msg: '更新成功', data: { affectedRows } };
+  }
+
+  /**
+   * 根据ID更新记录
+   * @param {number|string} id - 记录ID
+   * @param {Object} data - 更新数据
+   * @returns {Promise<Object>} 更新结果，包含affectedRows
+   */
+  async updateById(id, data = {}) {
+    this._checkDB();
+    
+    if (!id || !Object.keys(data).length) {
+      return { success: false, code: 400, msg: '参数无效', data: {} };
+    }
+    const formattedData = this._formatDateFields(data);
+    const affectedRows = await this.db(this.tableName).where({ id }).update(formattedData);
+    const updatedRecord = await this.findById(id);
+    return { success: true, code: 200, msg: '更新成功', data: updatedRecord.data };
+  }
+
+  /**
+   * 批量更新记录（事务）
+   * @param {Array} updates - 更新数组，每项包含query和data
+   * @returns {Promise<Object>} 更新结果，包含affectedRows
+   */
+  async updateMany(updates = []) {
+    this._checkDB();
+    
+    if (!Array.isArray(updates) || !updates.length) {
+      return { success: false, code: 400, msg: '参数缺失', data: {} };
+    }
+
+    const trx = await this.db.transaction();
+    let totalAffected = 0;
+    for (const { query, data } of updates) {
+      if (!query || !Object.keys(query).length) {
+        await trx.rollback().catch(rollbackErr => {
+          console.error('[updateMany] 回滚失败:', rollbackErr.message);
+        });
+        return { success: false, code: 400, msg: '参数无效：批量更新不允许空条件', data: {} };
+      }
+      const result = await trx(this.tableName).where(query).update(data);
+      if (result === 0) {
+        console.log('[updateMany] 未匹配到行, query=%j', query);
+      }
+      totalAffected += result;
+    }
+    await trx.commit();
+    return { success: true, code: 200, msg: '批量更新成功', data: { affectedRows: totalAffected } };
+  }
+
+  /**
+   * 分页查询
+   * @param {Object} options - 查询选项
+   * @param {number} options.current - 当前页码，默认1
+   * @param {number} options.pageSize - 每页大小，默认10
+   * @param {Object} options.query - 查询条件
+   * @param {Object} options.sort - 排序条件
+   * @param {Array} options.field - 查询字段
+   * @returns {Promise<Object>} 分页结果，包含list、total、current、pageSize、totalPages
+   */
+  async query({ current = 1, pageSize = 10, query = {}, sort = {}, field = [] }) {
+    this._checkDB();
+    
+    const size = Math.min(Math.max(pageSize, 1), this.limit);
+    const offset = (current - 1) * size;
+
+    let countQuery = this.db(this.tableName).count("* as total");
+    let dataQuery = this._buildBaseQuery({ query, sort, fields: field });
+
+    const [totalResult, list] = await Promise.all([
+      countQuery.first(),
+      dataQuery.offset(offset).limit(size),
+    ]);
+
+    const total = Number(totalResult?.total ?? 0);
+    const totalPages = Math.ceil(total / size);
+
+    return { success: true, code: 200, msg: '查询成功', data: { list: formatDateFields(list, this._dateFields), total, current, pageSize: size, totalPages } };
+  }
+
+  /**
+   * 统计记录数
+   * @param {Object} query - 查询条件
+   * @returns {Promise<Object>} 统计结果，包含count
+   */
+  async count(query = {}) {
+    this._checkDB();
+    
+    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: true, code: 200, msg: '统计成功', data: { count: Number(result?.total ?? 0) } };
+  }
+
+  /**
+   * 检查记录是否存在
+   * @param {Object} query - 查询条件
+   * @returns {Promise<Object>} 存在性结果，包含exists布尔值
+   */
+  async exists(query = {}) {
+    this._checkDB();
+    
+    let dataQuery = this.db(this.tableName);
+    if (Object.keys(query).length) dataQuery = dataQuery.where(query);
+    const result = await dataQuery.first();
+    return { success: true, code: 200, msg: '检查成功', data: { exists: !!result } };
+  }
+
+  /**
+   * 关联查询
+   * @param {Object} options - 查询选项
+   * @param {string} options.joinTable - 关联表名
+   * @param {string} options.localField - 本地表字段
+   * @param {string} options.foreignField - 关联表字段
+   * @param {Array} options.fields - 查询字段，默认["*"]
+   * @param {Object} options.query - 查询条件
+   * @param {Object} options.sort - 排序条件
+   * @returns {Promise<Array>} 查询结果数组
+   */
+  async join({ joinTable, localField, foreignField, fields = ["*"], query = {}, sort = {} }) {
+    this._checkDB();
+    
+    let _query = this.db(this.tableName)
+      .join(
+        joinTable,
+        `${this.tableName}.${localField}`,
+        "=",
+        `${joinTable}.${foreignField}`
+      )
+      .select(fields);
+
+    if (Object.keys(query).length) _query = _query.where(query);
+    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;
+    return { success: true, code: 200, msg: '查询成功', data: formatDateFields(res, this._dateFields) };
+  }
+
+  /**
+   * 批量删除记录（根据ID数组）
+   * @param {Array} ids - ID数组
+   * @returns {Promise<Object>} 删除结果，包含affectedRows
+   */
+  async deleteMany(ids = []) {
+    this._checkDB();
+    
+    if (!ids.length) return { success: false, code: 400, msg: '参数缺失', data: {} };
+    const affectedRows = await this.db(this.tableName).whereIn('id', ids).del();
+    return { success: true, code: 200, msg: '删除成功', data: { affectedRows } };
+  }
+
+  /**
+   * 软删除（设置deleted_at字段）
+   * @param {number|string} id - 记录ID
+   * @returns {Promise<Object>} 删除结果，包含affectedRows
+   */
+  async softDelete(id) {
+    this._checkDB();
+    
+    if (!id) return { msg: '参数缺失' };
+    const affectedRows = await this.db(this.tableName)
+      .where({ id })
+      .update({ deleted_at: new Date() });
+    return { affectedRows };
+  }
+
+  /**
+   * 恢复软删除的记录
+   * @param {number|string} id - 记录ID
+   * @returns {Promise<Object>} 恢复结果，包含affectedRows
+   */
+  async restore(id) {
+    this._checkDB();
+    
+    if (!id) return { msg: '参数缺失' };
+    const affectedRows = await this.db(this.tableName)
+      .where({ id })
+      .update({ deleted_at: null });
+    return { affectedRows };
+  }
+
+  /**
+   * 查询已软删除的记录
+   * @param {Object} options - 查询选项
+   * @param {Object} options.query - 查询条件
+   * @param {Array} options.fields - 查询字段
+   * @param {number} options.limit - 限制条数，默认20
+   * @param {number} options.offset - 偏移量，默认0
+   * @returns {Promise<Array>} 查询结果数组
+   */
+  async findTrashed({ query = {}, fields = [], limit = 20, offset = 0 } = {}) {
+    this._checkDB();
+    
+    let _query = this.db(this.tableName).whereNotNull('deleted_at');
+    
+    if (Object.keys(query).length) _query = _query.where(query);
+    if (fields.length) _query = _query.select(fields);
+    
+    const res = await _query.limit(limit).offset(offset).orderBy('deleted_at', 'desc');
+    return res;
+  }
+
+  /**
+   * 强制删除指定天数前的软删除记录
+   * @param {number} days - 天数，默认30天
+   * @returns {Promise<Object>} 删除结果，包含affectedRows
+   */
+  async forceDelete(days = 30) {
+    this._checkDB();
+    
+    const date = new Date();
+    date.setDate(date.getDate() - days);
+    
+    const affectedRows = await this.db(this.tableName)
+      .whereNotNull('deleted_at')
+      .where('deleted_at', '<', date)
+      .del();
+    
+    return { affectedRows };
+  }
+
+  /**
+   * 统计数据（总数和今日新增）
+   * @returns {Promise<Object>} 统计结果，包含total和today
+   */
+  async stats() {
+    this._checkDB();
+    
+    const total = await this.db(this.tableName).count('* as count').first();
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    
+    const todayCount = await this.db(this.tableName)
+      .where('created_at', '>=', today)
+      .count('* as count')
+      .first();
+    
+    return {
+      total: Number(total?.count || 0),
+      today: Number(todayCount?.count || 0)
+    };
+  }
+}
+
+export default Service;

package/common/api.js

@@ -0,0 +1,25 @@
+/**
+ * API响应常量定义
+ * 提供统一的响应状态码和消息
+ */
+
+export const success = {
+  code: 200,
+  msg: "success",
+};
+
+export const fail = {
+  code: 201,
+  msg: "error",
+};
+
+export const error = {
+  code: 500,
+  msg: "error",
+};
+
+export default {
+  success,
+  fail,
+  error,
+};

package/common/category.js

@@ -0,0 +1,22 @@
+/**
+ * 分类工具函数
+ * 提供分类相关的辅助方法
+ */
+
+/**
+ * 根据拼音或ID获取分类信息
+ * @param {string|number} py - 拼音或ID
+ * @param {Array} source - 分类数据源
+ * @returns {Object} 包含分类对象和ID的对象
+ */
+export function getChildrenId(py, source) {
+  let cate = {};
+  let id = "";
+  source.forEach((item) => {
+    if (item.pinyin == py || item.id == py) {
+      cate = item;
+      id = item.id;
+    }
+  });
+  return { cate, id };
+}

package/common/code.js

@@ -0,0 +1,42 @@
+/**
+ * 响应状态码常量定义
+ * 提供标准的状态码和对应消息
+ */
+
+export const CODE = {
+  /**
+   * 操作成功
+   */
+  SUCCESS: {
+    code: 200,
+    message: "操作成功",
+  },
+  /**
+   * 操作失败
+   */
+  FAIL: {
+    code: 201,
+    message: "操作失败",
+  },
+  /**
+   * 服务器错误
+   */
+  ERROR: {
+    code: 500,
+    message: "服务器错误",
+  },
+  /**
+   * 未授权
+   */
+  UNAUTHORIZED: {
+    code: 401,
+    message: "未授权",
+  },
+  /**
+   * 禁止访问
+   */
+  FORBIDDEN: {
+    code: 403,
+    message: "禁止访问",
+  },
+};