@aetherframework/database 1.1.1 → 1.1.2

package/src/drivers/mssql-driver.js

@@ -0,0 +1,117 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/database/drivers/mssql-driver
+ */
+import sql from 'mssql';
+
+class MSSQLDriver {
+  constructor(config) {
+    this.config = config;
+    this.pool = null;
+  }
+
+  async connect(config) {
+    const connection = await sql.connect({
+      server: config.host,
+      port: config.port,
+      user: config.user,
+      password: config.password,
+      database: config.database,
+      options: {
+        encrypt: config.options?.encrypt || false,
+        trustServerCertificate: config.options?.trustServerCertificate || false,
+        enableArithAbort: true
+      },
+      pool: {
+        max: config.pool?.max || 10,
+        min: config.pool?.min || 2,
+        idleTimeoutMillis: config.pool?.idleTimeout || 30000,
+        acquireTimeoutMillis: config.pool?.acquireTimeout || 10000
+      }
+    });
+    return connection;
+  }
+
+  async createPool(config) {
+    this.pool = new sql.ConnectionPool({
+      server: config.host,
+      port: config.port,
+      user: config.user,
+      password: config.password,
+      database: config.database,
+      options: {
+        encrypt: config.options?.encrypt || false,
+        trustServerCertificate: config.options?.trustServerCertificate || false,
+        enableArithAbort: true
+      },
+      pool: {
+        max: config.pool?.max || 10,
+        min: config.pool?.min || 2,
+        idleTimeoutMillis: config.pool?.idleTimeout || 30000,
+        acquireTimeoutMillis: config.pool?.acquireTimeout || 10000
+      }
+    });
+    await this.pool.connect();
+    return this.pool;
+  }
+
+  async query(connection, sqlText, params = []) {
+    const request = connection.request();
+    
+    // Add parameters if provided
+    params.forEach((param, index) => {
+      request.input(`param${index}`, param);
+    });
+    
+    const result = await request.query(sqlText);
+    return {
+      rows: result.recordset,
+      rowCount: result.rowsAffected,
+      recordsets: result.recordsets
+    };
+  }
+
+  async execute(connection, sqlText, params = []) {
+    return this.query(connection, sqlText, params);
+  }
+
+  async beginTransaction(connection) {
+    const transaction = new sql.Transaction(connection);
+    await transaction.begin();
+    return transaction;
+  }
+
+  async commitTransaction(transaction) {
+    await transaction.commit();
+  }
+
+  async rollbackTransaction(transaction) {
+    await transaction.rollback();
+  }
+
+  async close(connection) {
+    await connection.close();
+  }
+
+  async closePool(pool) {
+    await pool.close();
+  }
+
+  getPoolStats(pool) {
+    return {
+      size: pool.size,
+      available: pool.available,
+      pending: pool.pending,
+      borrowed: pool.borrowed
+    };
+  }
+
+  async healthCheck(connection) {
+    const result = await connection.request().query('SELECT 1 as health');
+    return result.recordset.health === 1;
+  }
+}
+
+export default MSSQLDriver;

package/src/drivers/mysql-driver.js

@@ -0,0 +1,169 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/database/drivers/mysql-driver
+ */
+import mysql from "mysql2/promise";
+
+class MySQLDriver {
+  constructor(config) {
+    this.config = config;
+    this.pool = null;
+  }
+
+  /** 创建单个连接（修正版：不要混入 pool 参数） */
+  async connect(config = this.config) {
+    const connConfig = {
+      host: config.host,
+      port: config.port || 3306,
+      user: config.user,
+      password: config.password,
+      database: config.database,
+      charset: config.charset || "utf8mb4",
+      timezone: config.timezone || "+00:00",
+      connectTimeout: config.connectTimeout || 10000,
+      // 只保留单连接需要的参数
+      supportBigNumbers: true,
+      bigNumberStrings: true,
+      dateStrings: true,
+    };
+
+    return await mysql.createConnection(connConfig);
+  }
+
+  /** 创建连接池 */
+  async createPool(config = this.config) {
+    this.pool = mysql.createPool({
+      host: config.host,
+      port: config.port || 3306,
+      user: config.user,
+      password: config.password,
+      database: config.database,
+      charset: config.charset || "utf8mb4",
+      timezone: config.timezone || "+00:00",
+      waitForConnections: true,
+      connectionLimit: config.pool?.max || 10,
+      queueLimit: config.pool?.queueLimit || 0,
+      idleTimeout: config.pool?.idleTimeout || 30000,
+      acquireTimeout: config.pool?.acquireTimeout || 10000,
+      enableKeepAlive: true,
+      keepAliveInitialDelay: 0,
+      supportBigNumbers: true,
+      bigNumberStrings: true,
+      dateStrings: true,
+    });
+    return this.pool;
+  }
+
+  /** SELECT 查询 */
+  async query(connection, sql, params = []) {
+    const validatedParams = this._validateAndPrepareParams(sql, params);
+    const [rows, fields] = await connection.execute(sql, validatedParams);
+    return {
+      rows,
+      fields,
+      rowCount: rows.length,
+      insertId: null, // SELECT 不会有 insertId
+    };
+  }
+
+  /** INSERT/UPDATE/DELETE */
+  async execute(connection, sql, params = []) {
+    const validatedParams = this._validateAndPrepareParams(sql, params);
+
+    const [result] = await connection.execute(sql, validatedParams);
+
+    return {
+      affectedRows: result.affectedRows || 0,
+      insertId: result.insertId || null,
+      changedRows: result.changedRows || 0,
+    };
+  }
+
+  // mysql-driver.js中的_validateAndPrepareParams方法
+  _validateAndPrepareParams(sql, params) {
+    // 确保参数是数组
+    if (!Array.isArray(params)) {
+      console.warn("[MySQLDriver] params 不是数组，已强制转换", params);
+      params = [];
+    }
+
+    // 过滤 undefined（mysql2 最容易出问题的点）
+    const filteredParams = params.map((p) => (p === undefined ? null : p));
+
+    // 计算SQL中的占位符数量
+    const placeholderCount = (sql.match(/\?/g) || []).length;
+
+    // 验证参数数量
+    if (filteredParams.length !== placeholderCount) {
+      console.error(
+        `[MySQLDriver] 参数数量不匹配！SQL有 ${placeholderCount} 个占位符，但提供了 ${filteredParams.length} 个参数`,
+      );
+      console.error(`[MySQLDriver] SQL: ${sql}`);
+      console.error(`[MySQLDriver] Params:`, filteredParams);
+
+      // 如果参数不足，用null填充
+      if (filteredParams.length < placeholderCount) {
+        const missingCount = placeholderCount - filteredParams.length;
+        console.warn(`[MySQLDriver] 缺少 ${missingCount} 个参数，用null填充`);
+        for (let i = 0; i < missingCount; i++) {
+          filteredParams.push(null);
+        }
+      }
+      // 如果参数过多，截断
+      else if (filteredParams.length > placeholderCount) {
+        console.warn(`[MySQLDriver] 参数过多，截断为 ${placeholderCount} 个`);
+        filteredParams.length = placeholderCount;
+      }
+    }
+
+    return filteredParams;
+  }
+
+  /** 确保 params 一定是数组（保持向后兼容） */
+  _ensureArray(params) {
+    if (!Array.isArray(params)) {
+      console.warn("[MySQLDriver] params 不是数组，已强制转换", params);
+      return [];
+    }
+    // 过滤 undefined（mysql2 最容易出问题的点）
+    return params.map((p) => (p === undefined ? null : p));
+  }
+
+  async beginTransaction(connection) {
+    await connection.beginTransaction();
+  }
+
+  async commitTransaction(connection) {
+    await connection.commit();
+  }
+
+  async rollbackTransaction(connection) {
+    await connection.rollback();
+  }
+
+  async close(connection) {
+    await connection.end();
+  }
+
+  async closePool(pool) {
+    await pool.end();
+  }
+
+  getPoolStats(pool) {
+    return {
+      totalConnections: pool._allConnections?.length || 0,
+      activeConnections: pool._acquiringConnections?.length || 0,
+      idleConnections: pool._freeConnections?.length || 0,
+      waitingClients: pool._connectionQueue?.length || 0,
+    };
+  }
+
+  async healthCheck(connection) {
+    const [rows] = await connection.execute("SELECT 1 as health");
+    return rows.health === 1;
+  }
+}
+
+export default MySQLDriver;

package/src/drivers/oracle-driver.js

@@ -0,0 +1,101 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/database/drivers/oracle-driver
+ */
+import oracledb from 'oracledb';
+
+class OracleDriver {
+  constructor(config) {
+    this.config = config;
+    this.pool = null;
+  }
+
+  async connect(config) {
+    const connection = await oracledb.getConnection({
+      user: config.user,
+      password: config.password,
+      connectString: config.connectString || `${config.host}:${config.port}/${config.serviceName}`,
+      poolMin: config.pool?.min || 2,
+      poolMax: config.pool?.max || 10,
+      poolIncrement: 1,
+      poolTimeout: config.pool?.idleTimeout || 30000,
+      queueTimeout: config.pool?.acquireTimeout || 10000
+    });
+    return connection;
+  }
+
+  async createPool(config) {
+    await oracledb.createPool({
+      user: config.user,
+      password: config.password,
+      connectString: config.connectString || `${config.host}:${config.port}/${config.serviceName}`,
+      poolMin: config.pool?.min || 2,
+      poolMax: config.pool?.max || 10,
+      poolIncrement: 1,
+      poolTimeout: config.pool?.idleTimeout || 30000,
+      queueTimeout: config.pool?.acquireTimeout || 10000
+    });
+    this.pool = oracledb.getPool();
+    return this.pool;
+  }
+
+  async query(connection, sql, params = []) {
+    const options = {
+      outFormat: oracledb.OUT_FORMAT_OBJECT
+    };
+    
+    const result = await connection.execute(sql, params, options);
+    return {
+      rows: result.rows,
+      rowCount: result.rows?.length || 0,
+      metaData: result.metaData,
+      outBinds: result.outBinds
+    };
+  }
+
+  async execute(connection, sql, params = []) {
+    const result = await connection.execute(sql, params, { autoCommit: false });
+    return {
+      rowsAffected: result.rowsAffected,
+      lastRowid: result.lastRowid,
+      outBinds: result.outBinds
+    };
+  }
+
+  async beginTransaction(connection) {
+    // Oracle automatically starts a transaction when DML is executed
+    return connection;
+  }
+
+  async commitTransaction(connection) {
+    await connection.commit();
+  }
+
+  async rollbackTransaction(connection) {
+    await connection.rollback();
+  }
+
+  async close(connection) {
+    await connection.close();
+  }
+
+  async closePool(pool) {
+    await pool.close();
+  }
+
+  getPoolStats(pool) {
+    return {
+      connectionsInUse: pool.connectionsInUse,
+      connectionsOpen: pool.connectionsOpen
+    };
+  }
+
+  async healthCheck(connection) {
+    const result = await connection.execute('SELECT 1 as health FROM DUAL');
+    return result.rows.HEALTH === 1;
+  }
+}
+
+export default OracleDriver;

package/src/drivers/postgres-driver.js

@@ -0,0 +1,234 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/database/drivers/postgres-driver
+ */
+import pg from 'pg';
+
+/**
+ * PostgreSQL Driver (also supports CockroachDB)
+ * CockroachDB is PostgreSQL compatible, so we can reuse this driver
+ */
+class PostgreSQLDriver {
+  constructor(config) {
+    this.config = config;
+    this.pool = null;
+  }
+
+  /**
+   * Create a single connection
+   * @param {Object} config - Connection configuration
+   * @returns {Promise<Object>} PostgreSQL client
+   */
+  async connect(config) {
+    // Check if this is a CockroachDB connection
+    const isCockroachDB = config.type === 'cockroachdb' || config.type === 'cockroach';
+    
+    // For CockroachDB, we need to enable specific options
+    const connectionConfig = {
+      host: config.host,
+      port: config.port,
+      user: config.user,
+      password: config.password,
+      database: config.database,
+      ssl: config.ssl ? { rejectUnauthorized: false } : false
+    };
+
+    // Add CockroachDB specific options if needed
+    if (isCockroachDB) {
+      // CockroachDB specific connection options
+      connectionConfig.application_name = 'cockroachdb-driver';
+      // CockroachDB often requires SSL
+      if (!config.ssl && process.env.NODE_ENV === 'production') {
+        console.warn('⚠️ CockroachDB in production should use SSL. Set ssl: true in config.');
+      }
+    }
+
+    const client = new pg.Client(connectionConfig);
+    await client.connect();
+    return client;
+  }
+
+  /**
+   * Create connection pool
+   * @param {Object} config - Pool configuration
+   * @returns {Promise<Object>} PostgreSQL pool
+   */
+  async createPool(config) {
+    // Check if this is a CockroachDB connection
+    const isCockroachDB = config.type === 'cockroachdb' || config.type === 'cockroach';
+    
+    const poolConfig = {
+      host: config.host,
+      port: config.port,
+      user: config.user,
+      password: config.password,
+      database: config.database,
+      ssl: config.ssl ? { rejectUnauthorized: false } : false,
+      max: config.pool?.max || 10,
+      min: config.pool?.min || 2,
+      idleTimeoutMillis: config.pool?.idleTimeout || 30000,
+      connectionTimeoutMillis: config.pool?.acquireTimeout || 10000
+    };
+
+    // Add CockroachDB specific pool options
+    if (isCockroachDB) {
+      poolConfig.application_name = 'cockroachdb-pool';
+      // CockroachDB may need different pool settings
+      poolConfig.max = config.pool?.max || 20; // Higher max connections for CockroachDB
+    }
+
+    this.pool = new pg.Pool(poolConfig);
+    return this.pool;
+  }
+
+  /**
+   * Execute SELECT query
+   * @param {Object} connection - PostgreSQL client or pool client
+   * @param {string} sql - SQL query
+   * @param {Array} params - Query parameters
+   * @returns {Promise<Object>} Query result
+   */
+  async query(connection, sql, params = []) {
+    // Check if this is a CockroachDB connection
+    const isCockroachDB = this.config.type === 'cockroachdb' || this.config.type === 'cockroach';
+    
+    // For CockroachDB, we might need to adjust some queries
+    if (isCockroachDB) {
+      // CockroachDB doesn't support some PostgreSQL features
+      // We can add compatibility adjustments here if needed
+      // For example, CockroachDB uses different serial types
+      sql = this.adaptSQLForCockroachDB(sql);
+    }
+
+    const result = await connection.query(sql, params);
+    return {
+      rows: result.rows,
+      rowCount: result.rowCount,
+      fields: result.fields,
+      command: result.command
+    };
+  }
+
+  /**
+   * Execute INSERT/UPDATE/DELETE operation
+   * @param {Object} connection - PostgreSQL client or pool client
+   * @param {string} sql - SQL statement
+   * @param {Array} params - Query parameters
+   * @returns {Promise<Object>} Execution result
+   */
+  async execute(connection, sql, params = []) {
+    // Check if this is a CockroachDB connection
+    const isCockroachDB = this.config.type === 'cockroachdb' || this.config.type === 'cockroach';
+    
+    if (isCockroachDB) {
+      sql = this.adaptSQLForCockroachDB(sql);
+    }
+
+    const result = await connection.query(sql, params);
+    return {
+      rowCount: result.rowCount,
+      rows: result.rows
+    };
+  }
+
+  /**
+   * Adapt SQL for CockroachDB compatibility
+   * @param {string} sql - Original SQL
+   * @returns {string} Adapted SQL
+   * @private
+   */
+  adaptSQLForCockroachDB(sql) {
+    let adaptedSql = sql;
+    
+    // CockroachDB uses different syntax for some features
+    // Add adaptations as needed
+    
+    // Example: Replace SERIAL with INT DEFAULT unique_rowid()
+    // This is just an example - actual adaptations depend on your use case
+    if (sql.includes('SERIAL')) {
+      console.warn('⚠️ CockroachDB: SERIAL type is not supported. Consider using INT DEFAULT unique_rowid()');
+    }
+    
+    return adaptedSql;
+  }
+
+  /**
+   * Begin transaction
+   * @param {Object} connection - PostgreSQL client
+   */
+  async beginTransaction(connection) {
+    await connection.query('BEGIN');
+  }
+
+  /**
+   * Commit transaction
+   * @param {Object} connection - PostgreSQL client
+   */
+  async commitTransaction(connection) {
+    await connection.query('COMMIT');
+  }
+
+  /**
+   * Rollback transaction
+   * @param {Object} connection - PostgreSQL client
+   */
+  async rollbackTransaction(connection) {
+    await connection.query('ROLLBACK');
+  }
+
+  /**
+   * Close connection
+   * @param {Object} connection - PostgreSQL client
+   */
+  async close(connection) {
+    await connection.end();
+  }
+
+  /**
+   * Close connection pool
+   * @param {Object} pool - PostgreSQL pool
+   */
+  async closePool(pool) {
+    await pool.end();
+  }
+
+  /**
+   * Get pool statistics
+   * @param {Object} pool - PostgreSQL pool
+   * @returns {Object} Pool statistics
+   */
+  getPoolStats(pool) {
+    return {
+      totalCount: pool.totalCount,
+      idleCount: pool.idleCount,
+      waitingCount: pool.waitingCount
+    };
+  }
+
+  /**
+   * Health check
+   * @param {Object} connection - PostgreSQL client
+   * @returns {Promise<boolean>} Health status
+   */
+  async healthCheck(connection) {
+    try {
+      const result = await connection.query('SELECT 1 as health');
+      return result.rows.health === 1;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get dialect name
+   * @returns {string} Dialect name
+   */
+  getDialect() {
+    const isCockroachDB = this.config.type === 'cockroachdb' || this.config.type === 'cockroach';
+    return isCockroachDB ? 'cockroachdb' : 'postgresql';
+  }
+}
+
+export default PostgreSQLDriver;

package/src/drivers/redis-driver.js

@@ -0,0 +1,52 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/database/drivers/redis-driver
+ */
+import redis from 'redis';
+
+class RedisDriver {
+  constructor(config) {
+    this.config = config;
+    this.client = null;
+  }
+
+  async connect(config) {
+    this.client = redis.createClient({
+      socket: {
+        host: config.host,
+        port: config.port
+      },
+      password: config.password,
+      database: config.db || 0
+    });
+    
+    await this.client.connect();
+    return this.client;
+  }
+
+  async query(connection, command, ...args) {
+    const result = await connection.sendCommand([command, ...args]);
+    return { result };
+  }
+
+  async execute(connection, command, ...args) {
+    return this.query(connection, command, ...args);
+  }
+
+  async close(connection) {
+    await connection.quit();
+  }
+
+  async healthCheck(connection) {
+    try {
+      const result = await connection.ping();
+      return result === 'PONG';
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+export default RedisDriver;