@aetherframework/database 1.0.9 → 1.1.0

package/src/drivers/mssql-driver.js

@@ -1,117 +0,0 @@
-/**
- * @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

@@ -1,169 +0,0 @@
-/**
- * @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

@@ -1,101 +0,0 @@
-/**
- * @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

@@ -1,234 +0,0 @@
-/**
- * @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

@@ -1,52 +0,0 @@
-/**
- * @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;