@aetherframework/database 1.1.0 → 1.1.2

package/src/drivers/sqlite-driver.js

@@ -0,0 +1,67 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/database/drivers/sqlite-driver
+ */
+import sqlite3 from 'sqlite3';
+import { open } from 'sqlite';
+
+class SQLiteDriver {
+  constructor(config) {
+    this.config = config;
+    this.db = null;
+  }
+
+  async connect(config) {
+    const db = await open({
+      filename: config.database === ':memory:' ? ':memory:' : config.database,
+      driver: sqlite3.Database,
+      mode: config.mode === 'memory' ? sqlite3.OPEN_MEMORY : sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE
+    });
+    this.db = db;
+    return db;
+  }
+
+  async query(connection, sql, params = []) {
+    const rows = await connection.all(sql, params);
+    const info = await connection.run(sql, params);
+    return {
+      rows,
+      rowCount: rows.length,
+      lastID: info.lastID,
+      changes: info.changes
+    };
+  }
+
+  async execute(connection, sql, params = []) {
+    const result = await connection.run(sql, params);
+    return {
+      lastID: result.lastID,
+      changes: result.changes
+    };
+  }
+
+  async beginTransaction(connection) {
+    await connection.run('BEGIN TRANSACTION');
+  }
+
+  async commitTransaction(connection) {
+    await connection.run('COMMIT');
+  }
+
+  async rollbackTransaction(connection) {
+    await connection.run('ROLLBACK');
+  }
+
+  async close(connection) {
+    await connection.close();
+  }
+
+  async healthCheck(connection) {
+    const result = await connection.get('SELECT 1 as health');
+    return result.health === 1;
+  }
+}
+
+export default SQLiteDriver;

package/src/middleware/connection-pool.js

@@ -0,0 +1,455 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/database/middleware/connection-pool
+ */
+import { EventEmitter } from 'events';
+
+class ConnectionPoolMiddleware extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.options = {
+      maxConnections: options.maxConnections || 10,
+      minConnections: options.minConnections || 2,
+      idleTimeout: options.idleTimeout || 30000, // ms
+      acquireTimeout: options.acquireTimeout || 10000, // ms
+      evictionRunInterval: options.evictionRunInterval || 60000, // ms
+      testOnBorrow: options.testOnBorrow !== false,
+      testOnReturn: options.testOnReturn !== false,
+      ...options
+    };
+    
+    this.pool = new Map();
+    this.activeConnections = new Set();
+    this.waitingQueue = [];
+    this.stats = {
+      totalConnections: 0,
+      activeConnections: 0,
+      idleConnections: 0,
+      waitingClients: 0,
+      connectionCreations: 0,
+      connectionDestructions: 0,
+      connectionTimeouts: 0,
+      connectionErrors: 0
+    };
+    
+    this.startEvictionTimer();
+  }
+
+  /**
+   * Get a connection from pool
+   * @param {string} connectionName - Connection name
+   * @param {Function} createConnection - Function to create new connection
+   * @returns {Promise<Object>} Database connection
+   */
+  async getConnection(connectionName, createConnection) {
+    const poolKey = connectionName;
+    
+    // Check if we have idle connections
+    if (this.pool.has(poolKey) && this.pool.get(poolKey).length > 0) {
+      const connections = this.pool.get(poolKey);
+      const connection = connections.pop();
+      
+      // Test connection if enabled
+      if (this.options.testOnBorrow) {
+        try {
+          await this.testConnection(connection);
+        } catch (error) {
+          this.stats.connectionErrors++;
+          this.emit('connection-test-failed', { connectionName, error });
+          // Remove bad connection and create new one
+          this.stats.connectionDestructions++;
+          return this.createNewConnection(connectionName, createConnection);
+        }
+      }
+      
+      this.activeConnections.add(connection);
+      this.stats.activeConnections++;
+      this.stats.idleConnections--;
+      
+      this.emit('connection-acquired', { 
+        connectionName, 
+        fromPool: true,
+        activeConnections: this.stats.activeConnections,
+        idleConnections: this.stats.idleConnections
+      });
+      
+      return connection;
+    }
+    
+    // Check if we can create new connection
+    if (this.stats.totalConnections < this.options.maxConnections) {
+      const connection = await this.createNewConnection(connectionName, createConnection);
+      this.activeConnections.add(connection);
+      this.stats.activeConnections++;
+      
+      this.emit('connection-created', { 
+        connectionName, 
+        activeConnections: this.stats.activeConnections,
+        totalConnections: this.stats.totalConnections
+      });
+      
+      return connection;
+    }
+    
+    // Wait for connection to become available
+    return new Promise((resolve, reject) => {
+      const waitStartTime = Date.now();
+      const timeoutId = setTimeout(() => {
+        const index = this.waitingQueue.findIndex(item => item.resolve === resolve);
+        if (index !== -1) {
+          this.waitingQueue.splice(index, 1);
+          this.stats.waitingClients--;
+          this.stats.connectionTimeouts++;
+          
+          this.emit('connection-timeout', { 
+            connectionName, 
+            waitTime: Date.now() - waitStartTime,
+            waitingClients: this.stats.waitingClients
+          });
+          
+          reject(new Error(`Connection pool timeout after ${this.options.acquireTimeout}ms`));
+        }
+      }, this.options.acquireTimeout);
+      
+      this.waitingQueue.push({
+        connectionName,
+        resolve: async () => {
+          clearTimeout(timeoutId);
+          try {
+            const connection = await this.getConnection(connectionName, createConnection);
+            resolve(connection);
+          } catch (error) {
+            reject(error);
+          }
+        },
+        reject,
+        timestamp: Date.now()
+      });
+      
+      this.stats.waitingClients++;
+      this.emit('connection-waiting', { 
+        connectionName, 
+        waitingClients: this.stats.waitingClients 
+      });
+    });
+  }
+
+  /**
+   * Release connection back to pool
+   * @param {string} connectionName - Connection name
+   * @param {Object} connection - Database connection
+   */
+  async releaseConnection(connectionName, connection) {
+    if (!this.activeConnections.has(connection)) {
+      this.emit('connection-not-active', { connectionName });
+      return;
+    }
+    
+    // Test connection if enabled
+    if (this.options.testOnReturn) {
+      try {
+        await this.testConnection(connection);
+      } catch (error) {
+        this.stats.connectionErrors++;
+        this.emit('connection-test-failed', { connectionName, error });
+        // Destroy bad connection
+        await this.destroyConnection(connectionName, connection);
+        this.activeConnections.delete(connection);
+        this.stats.activeConnections--;
+        this.stats.totalConnections--;
+        return;
+      }
+    }
+    
+    // Add connection back to pool
+    if (!this.pool.has(connectionName)) {
+      this.pool.set(connectionName, []);
+    }
+    
+    this.pool.get(connectionName).push({
+      connection,
+      lastUsed: Date.now()
+    });
+    
+    this.activeConnections.delete(connection);
+    this.stats.activeConnections--;
+    this.stats.idleConnections++;
+    
+    // Check waiting queue
+    if (this.waitingQueue.length > 0) {
+      const nextRequest = this.waitingQueue.shift();
+      this.stats.waitingClients--;
+      nextRequest.resolve();
+    }
+    
+    this.emit('connection-released', { 
+      connectionName, 
+      activeConnections: this.stats.activeConnections,
+      idleConnections: this.stats.idleConnections,
+      waitingClients: this.stats.waitingClients
+    });
+  }
+
+  /**
+   * Create new connection
+   * @param {string} connectionName - Connection name
+   * @param {Function} createConnection - Function to create new connection
+   * @returns {Promise<Object>} New connection
+   */
+  async createNewConnection(connectionName, createConnection) {
+    try {
+      const connection = await createConnection();
+      this.stats.totalConnections++;
+      this.stats.connectionCreations++;
+      
+      this.emit('connection-created', { 
+        connectionName, 
+        activeConnections: this.stats.activeConnections,
+        totalConnections: this.stats.totalConnections
+      });
+      
+      return connection;
+    } catch (error) {
+      this.stats.connectionErrors++;
+      this.emit('connection-creation-error', { connectionName, error });
+      throw error;
+    }
+  }
+
+  /**
+   * Destroy connection
+   * @param {string} connectionName - Connection name
+   * @param {Object} connection - Database connection
+   */
+  async destroyConnection(connectionName, connection) {
+    try {
+      if (typeof connection.close === 'function') {
+        await connection.close();
+      } else if (typeof connection.end === 'function') {
+        await connection.end();
+      } else if (typeof connection.destroy === 'function') {
+        connection.destroy();
+      }
+      
+      this.stats.connectionDestructions++;
+      this.emit('connection-destroyed', { connectionName });
+    } catch (error) {
+      this.stats.connectionErrors++;
+      this.emit('connection-destruction-error', { connectionName, error });
+    }
+  }
+
+  /**
+   * Test connection health
+   * @param {Object} connection - Database connection
+   * @returns {Promise<boolean>} True if connection is healthy
+   */
+  async testConnection(connection) {
+    // Try to execute a simple query to test connection
+    if (typeof connection.query === 'function') {
+      try {
+        await connection.query('SELECT 1');
+        return true;
+      } catch (error) {
+        return false;
+      }
+    }
+    
+    // For connections without query method, assume they're healthy
+    return true;
+  }
+
+  /**
+   * Start eviction timer
+   */
+  startEvictionTimer() {
+    setInterval(() => {
+      this.evictIdleConnections();
+    }, this.options.evictionRunInterval);
+  }
+
+  /**
+   * Evict idle connections
+   */
+  async evictIdleConnections() {
+    const now = Date.now();
+    
+    for (const [connectionName, connections] of this.pool.entries()) {
+      const activeConnections = [];
+      const idleConnections = [];
+      const toDestroy = [];
+      
+      for (const connInfo of connections) {
+        const idleTime = now - connInfo.lastUsed;
+        
+        if (idleTime > this.options.idleTimeout) {
+          toDestroy.push(connInfo);
+        } else if (this.activeConnections.has(connInfo.connection)) {
+          activeConnections.push(connInfo);
+        } else {
+          idleConnections.push(connInfo);
+        }
+      }
+      
+      // Destroy idle connections that exceed idle timeout
+      for (const connInfo of toDestroy) {
+        await this.destroyConnection(connectionName, connInfo.connection);
+      }
+      
+      // Update pool with remaining connections
+      this.pool.set(connectionName, idleConnections);
+      this.stats.idleConnections = idleConnections.length;
+      this.stats.activeConnections = activeConnections.length;
+    }
+  }
+
+    /**
+   * Get pool statistics
+   * @returns {Object} Pool statistics
+   */
+  getStats() {
+    const poolStats = {};
+    for (const [connectionName, connections] of this.pool.entries()) {
+      poolStats[connectionName] = {
+        idleConnections: connections.length,
+        activeConnections: Array.from(this.activeConnections).filter(conn => 
+          this.getConnectionName(conn) === connectionName
+        ).length
+      };
+    }
+    
+    return {
+      ...this.stats,
+      poolStats,
+      waitingQueueSize: this.waitingQueue.length,
+      evictionRunInterval: this.options.evictionRunInterval,
+      idleTimeout: this.options.idleTimeout,
+      acquireTimeout: this.options.acquireTimeout,
+      maxConnections: this.options.maxConnections,
+      minConnections: this.options.minConnections,
+      testOnBorrow: this.options.testOnBorrow,
+      testOnReturn: this.options.testOnReturn,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Get connection name from connection object
+   * @param {Object} connection - Database connection
+   * @returns {string} Connection name
+   */
+  getConnectionName(connection) {
+    for (const [name, connections] of this.pool.entries()) {
+      if (connections.some(connInfo => connInfo.connection === connection)) {
+        return name;
+      }
+    }
+    return 'unknown';
+  }
+
+  /**
+   * Close all connections in pool
+   * @returns {Promise<void>}
+   */
+  async closeAll() {
+    const closePromises = [];
+    
+    // Close all idle connections
+    for (const [connectionName, connections] of this.pool.entries()) {
+      for (const connInfo of connections) {
+        closePromises.push(this.destroyConnection(connectionName, connInfo.connection));
+      }
+    }
+    
+    // Close all active connections
+    for (const connection of this.activeConnections) {
+      const connectionName = this.getConnectionName(connection);
+      closePromises.push(this.destroyConnection(connectionName, connection));
+    }
+    
+    // Clear waiting queue
+    for (const request of this.waitingQueue) {
+      request.reject(new Error('Connection pool closed'));
+    }
+    this.waitingQueue = [];
+    
+    await Promise.allSettled(closePromises);
+    
+    this.pool.clear();
+    this.activeConnections.clear();
+    this.stats = {
+      totalConnections: 0,
+      activeConnections: 0,
+      idleConnections: 0,
+      waitingClients: 0,
+      connectionCreations: 0,
+      connectionDestructions: 0,
+      connectionTimeouts: 0,
+      connectionErrors: 0
+    };
+    
+    this.emit('pool-closed');
+  }
+
+  /**
+   * Drain pool (stop accepting new connections)
+   * @returns {Promise<void>}
+   */
+  async drain() {
+    this.options.maxConnections = 0;
+    
+    // Wait for all active connections to be released
+    while (this.activeConnections.size > 0) {
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    
+    // Close all idle connections
+    await this.closeAll();
+    
+    this.emit('pool-drained');
+  }
+
+  /**
+   * Check if pool is healthy
+   * @returns {Object} Health status
+   */
+  getHealth() {
+    const stats = this.getStats();
+    const isHealthy = 
+      stats.connectionErrors < 10 && 
+      stats.connectionTimeouts < 5 &&
+      stats.waitingQueueSize < 20;
+    
+    return {
+      healthy: isHealthy,
+      status: isHealthy ? 'healthy' : 'unhealthy',
+      issues: !isHealthy ? [
+        ...(stats.connectionErrors >= 10 ? ['Too many connection errors'] : []),
+        ...(stats.connectionTimeouts >= 5 ? ['Too many connection timeouts'] : []),
+        ...(stats.waitingQueueSize >= 20 ? ['Too many waiting clients'] : [])
+      ] : [],
+      stats
+    };
+  }
+
+  /**
+   * Reset pool statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalConnections: this.stats.totalConnections,
+      activeConnections: this.stats.activeConnections,
+      idleConnections: this.stats.idleConnections,
+      waitingClients: this.stats.waitingClients,
+      connectionCreations: 0,
+      connectionDestructions: 0,
+      connectionTimeouts: 0,
+      connectionErrors: 0
+    };
+    this.emit('stats-reset');
+  }
+}
+
+export default ConnectionPoolMiddleware;