chanjs 2.1.1 → 2.3.0

package/base/Database.js

@@ -0,0 +1,314 @@
+import knex from "knex";
+
+/**
+ * 数据库管理器类
+ * 用于管理多个数据库连接和创建数据模型
+ */
+class DatabaseManager {
+  /**
+   * 构造函数
+   * 初始化数据库连接存储和默认连接名称
+   */
+  constructor() {
+    this._connections = new Map();
+    this._defaultName = "default";
+  }
+
+  /**
+   * 添加数据库连接
+   * @param {string} name - 连接名称
+   * @param {Object} config - Knex配置对象
+   * @param {Object} options - 选项
+   * @param {boolean} options.isDefault - 是否设为默认连接
+   * @returns {Object} Knex连接实例
+   */
+  add(name, config, options = {}) {
+    const { isDefault = false } = options;
+
+    const connection = knex(config);
+    this._connections.set(name, connection);
+
+    if (isDefault || this._connections.size === 1) {
+      this._defaultName = name;
+    }
+
+    return connection;
+  }
+
+  /**
+   * 获取数据库连接
+   * @param {string} name - 连接名称，默认为默认连接
+   * @returns {Object} Knex连接实例
+   * @throws {Error} 连接不存在时抛出异常
+   */
+  get(name = this._defaultName) {
+    const connection = this._connections.get(name);
+    if (!connection) {
+      throw new Error(`Database connection "${name}" not found`);
+    }
+    return connection;
+  }
+
+  /**
+   * 获取默认数据库连接
+   * @returns {Object} Knex连接实例
+   */
+  getDefault() {
+    return this.get(this._defaultName);
+  }
+
+  /**
+   * 检查连接是否存在
+   * @param {string} name - 连接名称
+   * @returns {boolean} 是否存在
+   */
+  has(name) {
+    return this._connections.has(name);
+  }
+
+  /**
+   * 移除数据库连接
+   * @param {string} name - 连接名称
+   */
+  remove(name) {
+    const connection = this._connections.get(name);
+    if (connection) {
+      connection.destroy();
+      this._connections.delete(name);
+    }
+  }
+
+  /**
+   * 关闭所有数据库连接
+   * @returns {Promise<void>}
+   */
+  async closeAll() {
+    const closePromises = [];
+    for (const [name, connection] of this._connections) {
+      closePromises.push(
+        connection.destroy().catch((err) => {
+          console.error(`Error closing database "${name}":`, err);
+        })
+      );
+    }
+    await Promise.all(closePromises);
+    this._connections.clear();
+  }
+
+  /**
+   * 获取所有连接名称
+   * @returns {Array<string>} 连接名称数组
+   */
+  getConnections() {
+    return Array.from(this._connections.keys());
+  }
+
+  /**
+   * 创建数据模型
+   * @param {string} name - 模型名称
+   * @param {string} tableName - 表名
+   * @param {string} connectionName - 连接名称
+   * @returns {Object} 模型对象
+   */
+  createModel(name, tableName, connectionName) {
+    const db = this.get(connectionName);
+    return {
+      db,
+      tableName,
+
+      /**
+       * 查询字段
+       * @param {string} fields - 字段列表，默认"*"
+       * @returns {Object} Knex查询构建器
+       */
+      select(fields = "*") {
+        return db(this.tableName).select(fields);
+      },
+
+      /**
+       * 条件查询
+       * @param {Object} conditions - 查询条件
+       * @returns {Object} Knex查询构建器
+       */
+      where(conditions) {
+        return db(this.tableName).where(conditions);
+      },
+
+      /**
+       * 查找记录
+       * @param {Object} query - 查询参数
+       * @param {Object} query.sort - 排序条件
+       * @param {Object} query.where - 查询条件
+       * @returns {Promise<Array>} 查询结果数组
+       */
+      find(query = {}) {
+        let q = db(this.tableName);
+        const { sort, ...where } = query;
+
+        if (Object.keys(where).length > 0) {
+          q = q.where(where);
+        }
+
+        if (sort && typeof sort === "object") {
+          for (const [field, dir] of Object.entries(sort)) {
+            q = q.orderBy(field, dir);
+          }
+        }
+
+        return q.select();
+      },
+
+      /**
+       * 查找单条记录
+       * @param {Object} query - 查询条件
+       * @returns {Promise<Object|null>} 查询结果或null
+       */
+      findOne(query = {}) {
+        let q = db(this.tableName);
+        if (Object.keys(query).length > 0) {
+          q = q.where(query);
+        }
+        return q.first();
+      },
+
+      /**
+       * 根据ID查找记录
+       * @param {number|string} id - 记录ID
+       * @returns {Promise<Object|null>} 查询结果或null
+       */
+      findById(id) {
+        return db(this.tableName).where({ id }).first();
+      },
+
+      /**
+       * 创建记录
+       * @param {Object} data - 要插入的数据
+       * @returns {Promise<Array>} 插入结果
+       */
+      create(data) {
+        return db(this.tableName).insert(data);
+      },
+
+      /**
+       * 批量创建记录
+       * @param {Array} records - 要插入的记录数组
+       * @returns {Promise<Array>} 插入结果
+       */
+      createMany(records) {
+        return db(this.tableName).insert(records);
+      },
+
+      /**
+       * 更新记录
+       * @param {Object} conditions - 更新条件
+       * @param {Object} data - 更新数据
+       * @returns {Promise<number>} 影响的行数
+       */
+      update(conditions, data) {
+        return db(this.tableName).where(conditions).update(data);
+      },
+
+      /**
+       * 删除记录
+       * @param {Object} conditions - 删除条件
+       * @returns {Promise<number>} 影响的行数
+       */
+      delete(conditions) {
+        return db(this.tableName).where(conditions).del();
+      },
+
+      /**
+       * 统计记录数
+       * @param {Object} query - 查询条件
+       * @returns {Promise<number>} 记录总数
+       */
+      count(query = {}) {
+        let q = db(this.tableName).count("* as total");
+        if (Object.keys(query).length > 0) {
+          q = q.where(query);
+        }
+        return q.first().then((result) => result?.total ?? 0);
+      },
+
+      /**
+       * 分页查询
+       * @param {Object} options - 查询选项
+       * @param {number} options.current - 当前页码，默认1
+       * @param {number} options.pageSize - 每页大小，默认10
+       * @param {Object} options.where - 查询条件
+       * @param {Array} options.select - 查询字段
+       * @returns {Promise<Object>} 分页结果
+       */
+      query(options = {}) {
+        const { current = 1, pageSize = 10, where = {}, select } = options;
+        const offset = (current - 1) * pageSize;
+
+        const countQuery = db(this.tableName).count("* as total");
+        const dataQuery = db(this.tableName);
+
+        if (Object.keys(where).length > 0) {
+          countQuery.where(where);
+          dataQuery.where(where);
+        }
+
+        if (select) {
+          dataQuery.select(select);
+        }
+
+        return Promise.all([
+          countQuery.first(),
+          dataQuery.offset(offset).limit(pageSize),
+        ]).then(([totalResult, list]) => ({
+          list,
+          total: totalResult?.total ?? 0,
+          current,
+          pageSize,
+        }));
+      },
+
+      /**
+       * 关联查询
+       * @param {Object} options - 查询选项
+       * @param {string} options.joinTable - 关联表名
+       * @param {string} options.localField - 本地表字段
+       * @param {string} options.foreignField - 关联表字段
+       * @param {string} options.select - 查询字段，默认"*"
+       * @param {Object} options.where - 查询条件
+       * @returns {Object} Knex查询构建器
+       */
+      join(options) {
+        const { joinTable, localField, foreignField, select = "*", where = {} } = options;
+        let q = db(this.tableName)
+          .join(joinTable, `${this.tableName}.${localField}`, "=", `${joinTable}.${foreignField}`)
+          .select(select);
+
+        if (Object.keys(where).length > 0) {
+          q = q.where(where);
+        }
+
+        return q;
+      },
+
+      /**
+       * 执行事务
+       * @param {Function} callback - 事务回调函数
+       * @returns {Promise} 事务执行结果
+       */
+      transaction(callback) {
+        return db.transaction(callback);
+      },
+
+      /**
+       * 执行原生SQL
+       * @param {string} sql - SQL语句
+       * @param {Array} bindings - 绑定参数
+       * @returns {Promise} 查询结果
+       */
+      raw(sql, bindings) {
+        return db.raw(sql, bindings);
+      },
+    };
+  }
+}
+
+export default DatabaseManager;