@coherent.js/database 1.0.0-beta.5 → 1.0.0-beta.6

package/dist/index.js

@@ -1158,431 +1158,6 @@ init_migration();
 
 // src/connection-manager.js
 import { EventEmitter } from "events";
-var DatabaseManager = class extends EventEmitter {
-  constructor(config) {
-    super();
-    this.config = this.validateConfig(config);
-    this.adapter = null;
-    this.pool = null;
-    this.isConnected = false;
-    this.connectionAttempts = 0;
-    this.maxRetries = 3;
-    this.healthCheckInterval = null;
-    this.healthCheckFrequency = 3e4;
-    this.stats = {
-      totalConnections: 0,
-      activeConnections: 0,
-      failedConnections: 0,
-      queriesExecuted: 0,
-      averageQueryTime: 0,
-      lastHealthCheck: null
-    };
-  }
-  /**
-   * Validate database configuration
-   * 
-   * @private
-   * @param {Object} config - Configuration to validate
-   * @returns {Object} Validated configuration
-   * @throws {Error} If configuration is invalid
-   */
-  validateConfig(config) {
-    if (!config || typeof config !== "object") {
-      throw new Error("Database configuration is required");
-    }
-    if (config.adapter) {
-      if (typeof config.adapter !== "object" || typeof config.adapter.createPool !== "function") {
-        throw new Error("Invalid adapter provided. Adapter must be an object with a createPool method");
-      }
-      if (!config.store) {
-        config.store = { name: "default" };
-      } else if (typeof config.store === "string") {
-        config.store = { name: config.store };
-      }
-      return config;
-    }
-    const { type, database } = config;
-    if (!type) {
-      throw new Error("Either database type or adapter is required");
-    }
-    const supportedTypes = ["postgresql", "mysql", "sqlite", "mongodb"];
-    if (!supportedTypes.includes(type)) {
-      throw new Error(`Unsupported database type: ${type}. Supported types: ${supportedTypes.join(", ")}`);
-    }
-    if (!database) {
-      throw new Error("Database name is required for type-based configuration");
-    }
-    const defaultPorts = {
-      postgresql: 5432,
-      mysql: 3306,
-      mongodb: 27017,
-      sqlite: null
-    };
-    return {
-      host: config.host || "localhost",
-      port: config.port || defaultPorts[type],
-      ...config,
-      pool: {
-        min: 2,
-        max: 10,
-        acquireTimeoutMillis: 3e4,
-        createTimeoutMillis: 3e4,
-        destroyTimeoutMillis: 5e3,
-        idleTimeoutMillis: 3e4,
-        reapIntervalMillis: 1e3,
-        createRetryIntervalMillis: 200,
-        ...config.pool
-      }
-    };
-  }
-  /**
-   * Connect to the database
-   * 
-   * @returns {Promise<void>}
-   * @throws {Error} If connection fails after retries
-   * 
-   * @example
-   * await db.connect();
-   * console.log('Database connected successfully');
-   */
-  async connect() {
-    if (this.isConnected) {
-      return;
-    }
-    try {
-      this.adapter = await this.loadAdapter(this.config.type);
-      this.pool = await this.adapter.createPool(this.config);
-      await this.testConnection();
-      this.isConnected = true;
-      this.connectionAttempts = 0;
-      if (this.adapter.startHealthChecks) {
-        this.startHealthChecks();
-      }
-      return this;
-    } catch (_error) {
-      this.connectionAttempts++;
-      this.stats.failedConnections++;
-      this.emit("_error", _error);
-      if (this.connectionAttempts < this.maxRetries) {
-        console.warn(`Connection attempt ${this.connectionAttempts} failed. Retrying in 2 seconds...`);
-        await new Promise((resolve) => setTimeout(resolve, 2e3));
-        return this.connect();
-      }
-      throw new Error(`Failed to connect to database after ${this.connectionAttempts} attempts: ${_error.message}`);
-    }
-  }
-  /**
-   * Load database adapter
-   * 
-   * @private
-   * @param {string} type - Database type
-   * @returns {Object} Database adapter
-   */
-  loadAdapter(type) {
-    if (this.config.adapter) {
-      return this.config.adapter;
-    }
-    const adapterMap = {
-      postgresql: "./adapters/postgresql.js",
-      mysql: "./adapters/mysql.js",
-      sqlite: "./adapters/sqlite.js",
-      mongodb: "./adapters/mongodb.js",
-      memory: "./adapters/memory.js"
-    };
-    const adapterPath = adapterMap[type];
-    if (!adapterPath) {
-      throw new Error(`No adapter found for database type: ${type}`);
-    }
-    return import(adapterPath).then((adapterModule) => {
-      if (adapterModule.default) {
-        return new adapterModule.default();
-      }
-      const AdapterClass = adapterModule[`${type.charAt(0).toUpperCase() + type.slice(1)}Adapter`];
-      if (AdapterClass) {
-        return new AdapterClass();
-      }
-      throw new Error(`No valid adapter found in ${adapterPath}`);
-    }).catch((_error) => {
-      throw new Error(`Failed to load ${type} adapter: ${_error.message}`);
-    });
-  }
-  /**
-   * Test database connection
-   * 
-   * @private
-   * @returns {Promise<void>}
-   */
-  async testConnection() {
-    const startTime = Date.now();
-    try {
-      if (typeof this.adapter.testConnection === "function") {
-        await this.adapter.testConnection();
-      } else if (this.adapter.ping) {
-        await this.adapter.ping();
-      }
-      const duration = Date.now() - startTime;
-      this.stats.lastHealthCheck = /* @__PURE__ */ new Date();
-      this.emit("connect:test", { duration });
-    } catch (_error) {
-      this.emit("_error", _error);
-      throw new Error(`Database connection test failed: ${_error.message}`);
-    }
-  }
-  /**
-   * Execute a database query
-   * 
-   * @param {string} sql - SQL query string
-   * @param {Array} [params=[]] - Query parameters
-   * @param {Object} [options={}] - Query options
-   * @returns {Promise<Object>} Query result
-   * 
-   * @example
-   * const users = await db.query('SELECT * FROM users WHERE age > ?', [18]);
-   * const user = await db.query('SELECT * FROM users WHERE id = ?', [123], { single: true });
-   */
-  async query(operation, params = {}) {
-    if (!this.isConnected) {
-      throw new Error("Database not connected. Call connect() first.");
-    }
-    const startTime = Date.now();
-    try {
-      let result;
-      if (typeof this.pool.query === "function") {
-        result = await this.pool.query(operation, params);
-      } else if (typeof this.adapter.query === "function") {
-        result = await this.adapter.query(this.pool, operation, params);
-      } else {
-        throw new Error("No valid query method found on adapter or pool");
-      }
-      const duration = Date.now() - startTime;
-      this.stats.queriesExecuted++;
-      this.stats.averageQueryTime = (this.stats.averageQueryTime * (this.stats.queriesExecuted - 1) + duration) / this.stats.queriesExecuted;
-      if (this.config.debug) {
-        console.log(`Query executed in ${duration}ms: ${operation}`, params);
-      }
-      this.emit("query", { operation, params, duration });
-      return result;
-    } catch (_error) {
-      const duration = Date.now() - startTime;
-      this.emit("queryError", { operation, params, duration, _error: _error.message });
-      throw new Error(`Query failed: ${_error.message}`);
-    }
-  }
-  /**
-   * Start a database transaction
-   * 
-   * @returns {Promise<Object>} Transaction object
-   * 
-   * @example
-   * const tx = await db.transaction();
-   * try {
-   *   await tx.query('INSERT INTO users (name) VALUES (?)', ['John']);
-   *   await tx.query('INSERT INTO profiles (user_id) VALUES (?)', [userId]);
-   *   await tx.commit();
-   * } catch (_error) {
-   *   await tx.rollback();
-   *   throw _error;
-   * }
-   */
-  async transaction() {
-    if (!this.isConnected) {
-      throw new Error("Database not connected. Call connect() first.");
-    }
-    return await this.adapter.transaction(this.pool);
-  }
-  /**
-   * Start health check monitoring
-   * 
-   * @private
-   */
-  startHealthCheck() {
-    if (this.healthCheckInterval) {
-      return;
-    }
-    this.healthCheckInterval = setInterval(async () => {
-      try {
-        await this.testConnection();
-        this.emit("healthCheck", { status: "healthy", timestamp: /* @__PURE__ */ new Date() });
-      } catch (_error) {
-        this.emit("healthCheck", { status: "unhealthy", _error: _error.message, timestamp: /* @__PURE__ */ new Date() });
-        if (this.config.debug) {
-          console.error("Database health check failed:", _error.message);
-        }
-      }
-    }, this.healthCheckFrequency);
-  }
-  /**
-   * Get connection statistics
-   * 
-   * @returns {Object} Connection statistics
-   */
-  getStats() {
-    return {
-      ...this.stats,
-      isConnected: this.isConnected,
-      poolStats: this.pool ? this.adapter.getPoolStats(this.pool) : null
-    };
-  }
-  /**
-   * Close database connection
-   * 
-   * @returns {Promise<void>}
-   */
-  async close() {
-    if (!this.isConnected) {
-      return;
-    }
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval);
-      this.healthCheckInterval = null;
-    }
-    if (this.pool && this.adapter) {
-      await this.adapter.closePool(this.pool);
-    }
-    this.isConnected = false;
-    this.pool = null;
-    this.adapter = null;
-    this.emit("disconnected");
-    if (this.config.debug) {
-      console.log("Database connection closed");
-    }
-  }
-};
-function createDatabaseManager(config) {
-  return new DatabaseManager(config);
-}
-
-// src/middleware.js
-function withDatabase(db, options = {}) {
-  const config = {
-    autoConnect: true,
-    attachModels: true,
-    transactionKey: "tx",
-    ...options
-  };
-  return async (req, res, next) => {
-    try {
-      if (config.autoConnect && !db.isConnected) {
-        await db.connect();
-      }
-      req.db = db;
-      req.dbQuery = async (sql, params, queryOptions) => {
-        return await db.query(sql, params, queryOptions);
-      };
-      req.transaction = async (callback) => {
-        const tx = await db.transaction();
-        try {
-          const result = await callback(tx);
-          await tx.commit();
-          return result;
-        } catch (_error) {
-          await tx.rollback();
-          throw _error;
-        }
-      };
-      if (config.attachModels && db.models) {
-        req.models = db.models;
-      }
-      await next();
-    } catch (_error) {
-      console.error("Database middleware _error:", _error);
-      if (typeof next === "function") {
-        next(_error);
-      } else {
-        throw _error;
-      }
-    }
-  };
-}
-function withTransaction(db, options = {}) {
-  const config = {
-    isolationLevel: null,
-    readOnly: false,
-    ...options
-  };
-  return async (req, res, next) => {
-    const tx = await db.transaction(config);
-    req.tx = tx;
-    try {
-      await next();
-      if (!tx.isCommitted && !tx.isRolledBack) {
-        await tx.commit();
-      }
-    } catch (_error) {
-      if (!tx.isRolledBack && !tx.isCommitted) {
-        await tx.rollback();
-      }
-      throw _error;
-    }
-  };
-}
-function withModel(ModelClass, paramName = "id", requestKey = null) {
-  let modelName = requestKey;
-  if (!modelName) {
-    if (ModelClass && ModelClass.name) {
-      modelName = ModelClass.name.toLowerCase();
-    } else if (ModelClass && ModelClass.tableName) {
-      modelName = ModelClass.tableName.slice(0, -1);
-    } else {
-      modelName = "model";
-    }
-  }
-  const key = modelName;
-  return async (req, res, next) => {
-    try {
-      const paramValue = req.params[paramName];
-      if (!paramValue) {
-        const _error = new Error(`Parameter '${paramName}' is required`);
-        _error.status = 400;
-        throw _error;
-      }
-      const model = await ModelClass.find(paramValue);
-      if (!model) {
-        const _error = new Error(`${ModelClass.name} not found`);
-        _error.status = 404;
-        throw _error;
-      }
-      req[key] = model;
-      await next();
-    } catch (_error) {
-      if (typeof next === "function") {
-        next(_error);
-      } else {
-        throw _error;
-      }
-    }
-  };
-}
-function withPagination(options = {}) {
-  const config = {
-    defaultLimit: 20,
-    maxLimit: 100,
-    pageParam: "page",
-    limitParam: "limit",
-    ...options
-  };
-  return async (req, res, next) => {
-    const page = Math.max(1, parseInt(req.query[config.pageParam]) || 1);
-    const limit = Math.min(
-      config.maxLimit,
-      Math.max(1, parseInt(req.query[config.limitParam]) || config.defaultLimit)
-    );
-    const offset = (page - 1) * limit;
-    req.pagination = {
-      page,
-      limit,
-      offset,
-      hasNext: null,
-      // To be set by the handler
-      hasPrev: page > 1,
-      totalPages: null,
-      // To be set by the handler
-      totalCount: null
-      // To be set by the handler
-    };
-    await next();
-  };
-}
 
 // src/adapters/postgresql.js
 function createPostgreSQLAdapter() {
@@ -1724,468 +1299,1112 @@ function createPostgreSQLAdapter() {
             client.release();
           }
         }
-      };
-      return transaction;
-    },
-    /**
-     * Get pool statistics
-     */
-    getPoolStats(pool) {
-      return {
-        total: pool.totalCount,
-        available: pool.idleCount,
-        acquired: pool.totalCount - pool.idleCount,
-        waiting: pool.waitingCount
-      };
-    },
-    /**
-     * Close connection pool
-     */
-    async closePool(pool) {
-      await pool.end();
+      };
+      return transaction;
+    },
+    /**
+     * Get pool statistics
+     */
+    getPoolStats(pool) {
+      return {
+        total: pool.totalCount,
+        available: pool.idleCount,
+        acquired: pool.totalCount - pool.idleCount,
+        waiting: pool.waitingCount
+      };
+    },
+    /**
+     * Close connection pool
+     */
+    async closePool(pool) {
+      await pool.end();
+    }
+  };
+}
+
+// src/adapters/mysql.js
+function createMySQLAdapter() {
+  let mysql = null;
+  async function initializeMySQL() {
+    if (!mysql) {
+      try {
+        const mysqlModule = await import("mysql2/promise");
+        mysql = mysqlModule.default || mysqlModule;
+      } catch {
+        throw new Error("mysql2 package is required for MySQL adapter. Install with: npm install mysql2");
+      }
+    }
+  }
+  return {
+    /**
+     * Create connection pool
+     */
+    async createPool(config) {
+      await initializeMySQL();
+      const poolConfig = {
+        host: config.host,
+        port: config.port,
+        database: config.database,
+        user: config.username,
+        password: config.password,
+        connectionLimit: config.pool.max,
+        acquireTimeout: config.pool.acquireTimeoutMillis,
+        timeout: config.pool.createTimeoutMillis,
+        reconnect: true,
+        charset: "utf8mb4",
+        timezone: "Z"
+      };
+      const pool = mysql.createPool(poolConfig);
+      return pool;
+    },
+    /**
+     * Test database connection
+     */
+    async testConnection(pool) {
+      const connection = await pool.getConnection();
+      try {
+        await connection.query("SELECT 1");
+      } finally {
+        connection.release();
+      }
+    },
+    /**
+     * Execute database query
+     */
+    async query(pool, sql, params = [], options = {}) {
+      const connection = await pool.getConnection();
+      try {
+        const [rows] = await connection.execute(sql, params);
+        if (options.single) {
+          return Array.isArray(rows) ? rows[0] || null : rows;
+        }
+        if (Array.isArray(rows)) {
+          return {
+            rows,
+            rowCount: rows.length,
+            affectedRows: rows.affectedRows || rows.length,
+            insertId: rows.insertId || null
+          };
+        } else {
+          return {
+            rows: [],
+            rowCount: rows.affectedRows || 0,
+            affectedRows: rows.affectedRows || 0,
+            insertId: rows.insertId || null
+          };
+        }
+      } finally {
+        connection.release();
+      }
+    },
+    /**
+     * Start database transaction
+     */
+    async transaction(pool) {
+      const connection = await pool.getConnection();
+      await connection.beginTransaction();
+      const transaction = {
+        connection,
+        pool,
+        isCommitted: false,
+        isRolledBack: false,
+        query: async (sql, params, queryOptions) => {
+          if (transaction.isCommitted || transaction.isRolledBack) {
+            throw new Error("Cannot execute query on completed transaction");
+          }
+          const [rows] = await connection.execute(sql, params);
+          if (queryOptions && queryOptions.single) {
+            return Array.isArray(rows) ? rows[0] || null : rows;
+          }
+          if (Array.isArray(rows)) {
+            return {
+              rows,
+              rowCount: rows.length,
+              affectedRows: rows.affectedRows || rows.length,
+              insertId: rows.insertId || null
+            };
+          } else {
+            return {
+              rows: [],
+              rowCount: rows.affectedRows || 0,
+              affectedRows: rows.affectedRows || 0,
+              insertId: rows.insertId || null
+            };
+          }
+        },
+        commit: async () => {
+          if (transaction.isCommitted || transaction.isRolledBack) {
+            throw new Error("Transaction already completed");
+          }
+          try {
+            await connection.commit();
+            transaction.isCommitted = true;
+          } finally {
+            connection.release();
+          }
+        },
+        rollback: async () => {
+          if (transaction.isCommitted || transaction.isRolledBack) {
+            throw new Error("Transaction already completed");
+          }
+          try {
+            await connection.rollback();
+            transaction.isRolledBack = true;
+          } finally {
+            connection.release();
+          }
+        }
+      };
+      return transaction;
+    },
+    /**
+     * Get pool statistics
+     */
+    getPoolStats(pool) {
+      return {
+        total: pool.config.connectionLimit,
+        available: pool._freeConnections ? pool._freeConnections.length : 0,
+        acquired: pool._allConnections ? pool._allConnections.length - (pool._freeConnections ? pool._freeConnections.length : 0) : 0,
+        waiting: pool._connectionQueue ? pool._connectionQueue.length : 0
+      };
+    },
+    /**
+     * Close connection pool
+     */
+    async closePool(pool) {
+      await pool.end();
+    }
+  };
+}
+
+// src/adapters/sqlite.js
+function createSQLiteAdapter() {
+  let sqlite3 = null;
+  let db = null;
+  async function initializeSQLite() {
+    if (!sqlite3) {
+      try {
+        const sqlite3Module = await import("sqlite3");
+        sqlite3 = sqlite3Module.default || sqlite3Module;
+      } catch {
+        throw new Error("Failed to load sqlite3 module. Make sure to install it: npm install sqlite3");
+      }
+    }
+  }
+  async function connect(config) {
+    await initializeSQLite();
+    return new Promise((resolve, reject) => {
+      try {
+        db = new sqlite3.Database(
+          config.database,
+          config.readonly ? sqlite3.OPEN_READONLY : sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE,
+          (err) => {
+            if (err) {
+              return reject(new Error(`Failed to connect to SQLite database: ${err.message}`));
+            }
+            db.run("PRAGMA foreign_keys = ON");
+            db.run("PRAGMA journal_mode = WAL");
+            db.run("PRAGMA busy_timeout = 5000");
+            resolve(instance);
+          }
+        );
+      } catch (_error) {
+        reject(new Error(`Failed to connect to SQLite database: ${_error.message}`));
+      }
+    });
+  }
+  function query(sql, params = []) {
+    return new Promise((resolve, reject) => {
+      if (!db) {
+        return reject(new Error("Database connection not established. Call connect() first."));
+      }
+      db.all(sql, params, (err, rows) => {
+        if (err) {
+          return reject(new Error(`SQLite query _error: ${err.message}`));
+        }
+        resolve({ rows });
+      });
+    });
+  }
+  function execute(sql, params = []) {
+    return new Promise((resolve, reject) => {
+      if (!db) {
+        return reject(new Error("Database connection not established. Call connect() first."));
+      }
+      db.run(sql, params, function(err) {
+        if (err) {
+          return reject(new Error(`SQLite execute _error: ${err.message}`));
+        }
+        resolve({
+          affectedRows: this.changes,
+          insertId: this.lastID
+        });
+      });
+    });
+  }
+  function beginTransaction() {
+    return new Promise((resolve, reject) => {
+      if (!db) {
+        return reject(new Error("Database connection not established. Call connect() first."));
+      }
+      db.run("BEGIN TRANSACTION", (err) => {
+        if (err) {
+          return reject(new Error(`Failed to begin transaction: ${err.message}`));
+        }
+        resolve();
+      });
+    });
+  }
+  function commit() {
+    return new Promise((resolve, reject) => {
+      if (!db) {
+        return reject(new Error("Database connection not established. Call connect() first."));
+      }
+      db.run("COMMIT", (err) => {
+        if (err) {
+          return reject(new Error(`Failed to commit transaction: ${err.message}`));
+        }
+        resolve();
+      });
+    });
+  }
+  function rollback() {
+    return new Promise((resolve, reject) => {
+      if (!db) {
+        return reject(new Error("Database connection not established. Call connect() first."));
+      }
+      db.run("ROLLBACK", (err) => {
+        if (err) {
+          return reject(new Error(`Failed to rollback transaction: ${err.message}`));
+        }
+        resolve();
+      });
+    });
+  }
+  function disconnect() {
+    return new Promise((resolve, reject) => {
+      if (!db) {
+        return resolve();
+      }
+      db.close((err) => {
+        if (err) {
+          return reject(new Error(`Failed to close database connection: ${err.message}`));
+        }
+        db = null;
+        resolve();
+      });
+    });
+  }
+  function getConnection() {
+    if (!db) {
+      throw new Error("Database connection not established. Call connect() first.");
+    }
+    return db;
+  }
+  async function ping() {
+    try {
+      await query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function escape(value) {
+    if (value === null || value === void 0) {
+      return "NULL";
+    }
+    if (typeof value === "boolean") {
+      return value ? "1" : "0";
+    }
+    if (typeof value === "number") {
+      return String(value);
     }
+    return `'${String(value).replace(/'/g, "''")}'`;
+  }
+  const instance = {
+    connect,
+    query,
+    execute,
+    beginTransaction,
+    commit,
+    rollback,
+    disconnect,
+    getConnection,
+    ping,
+    escape
   };
+  return instance;
 }
 
-// src/adapters/mysql.js
-function createMySQLAdapter() {
-  let mysql = null;
-  async function initializeMySQL() {
-    if (!mysql) {
+// src/adapters/mongodb.js
+function createMongoDBAdapter() {
+  let mongodb = null;
+  let client = null;
+  let db = null;
+  async function initializeMongoDB() {
+    if (!mongodb) {
       try {
-        const mysqlModule = await import("mysql2/promise");
-        mysql = mysqlModule.default || mysqlModule;
+        const mongoModule = await import("mongodb");
+        mongodb = mongoModule;
       } catch {
-        throw new Error("mysql2 package is required for MySQL adapter. Install with: npm install mysql2");
+        throw new Error("Failed to load mongodb module. Make sure to install it: npm install mongodb");
       }
     }
   }
-  return {
-    /**
-     * Create connection pool
-     */
-    async createPool(config) {
-      await initializeMySQL();
-      const poolConfig = {
-        host: config.host,
-        port: config.port,
-        database: config.database,
-        user: config.username,
-        password: config.password,
-        connectionLimit: config.pool.max,
-        acquireTimeout: config.pool.acquireTimeoutMillis,
-        timeout: config.pool.createTimeoutMillis,
-        reconnect: true,
-        charset: "utf8mb4",
-        timezone: "Z"
-      };
-      const pool = mysql.createPool(poolConfig);
-      return pool;
-    },
-    /**
-     * Test database connection
-     */
-    async testConnection(pool) {
-      const connection = await pool.getConnection();
-      try {
-        await connection.query("SELECT 1");
-      } finally {
-        connection.release();
+  async function connect(config) {
+    await initializeMongoDB();
+    try {
+      client = new mongodb.MongoClient(config.url, config.options || {});
+      await client.connect();
+      db = client.db(config.database);
+      return instance;
+    } catch (_error) {
+      throw new Error(`Failed to connect to MongoDB: ${_error.message}`);
+    }
+  }
+  async function query(collectionName, query2 = {}, options = {}) {
+    if (!db) {
+      throw new Error("Database connection not established. Call connect() first.");
+    }
+    try {
+      const collection = db.collection(collectionName);
+      const cursor = collection.find(query2, options);
+      if (options.sort) {
+        cursor.sort(options.sort);
       }
-    },
-    /**
-     * Execute database query
-     */
-    async query(pool, sql, params = [], options = {}) {
-      const connection = await pool.getConnection();
-      try {
-        const [rows] = await connection.execute(sql, params);
-        if (options.single) {
-          return Array.isArray(rows) ? rows[0] || null : rows;
-        }
-        if (Array.isArray(rows)) {
-          return {
-            rows,
-            rowCount: rows.length,
-            affectedRows: rows.affectedRows || rows.length,
-            insertId: rows.insertId || null
-          };
-        } else {
-          return {
-            rows: [],
-            rowCount: rows.affectedRows || 0,
-            affectedRows: rows.affectedRows || 0,
-            insertId: rows.insertId || null
-          };
+      if (options.limit) {
+        cursor.limit(options.limit);
+      }
+      if (options.skip) {
+        cursor.skip(options.skip);
+      }
+      if (options.projection) {
+        cursor.project(options.projection);
+      }
+      return cursor.toArray();
+    } catch (_error) {
+      throw new Error(`MongoDB query _error: ${_error.message}`);
+    }
+  }
+  async function execute(command) {
+    if (!db) {
+      throw new Error("Database connection not established. Call connect() first.");
+    }
+    try {
+      return await db.command(command);
+    } catch (_error) {
+      throw new Error(`MongoDB command _error: ${_error.message}`);
+    }
+  }
+  async function beginTransaction() {
+    if (!client) {
+      throw new Error("Database connection not established. Call connect() first.");
+    }
+    const session = client.startSession();
+    session.startTransaction();
+    return session;
+  }
+  async function commit(session) {
+    if (!session) {
+      throw new Error("No active transaction session");
+    }
+    try {
+      await session.commitTransaction();
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function rollback(session) {
+    if (!session) {
+      throw new Error("No active transaction session");
+    }
+    try {
+      await session.abortTransaction();
+    } finally {
+      await session.endSession();
+    }
+  }
+  async function disconnect() {
+    if (client) {
+      await client.close();
+      client = null;
+      db = null;
+    }
+  }
+  function getConnection() {
+    if (!db) {
+      throw new Error("Database connection not established. Call connect() first.");
+    }
+    return db;
+  }
+  async function ping() {
+    try {
+      await db.command({ ping: 1 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function escape(value) {
+    return value;
+  }
+  const instance = {
+    connect,
+    query,
+    execute,
+    beginTransaction,
+    commit,
+    rollback,
+    disconnect,
+    getConnection,
+    ping,
+    escape
+  };
+  return instance;
+}
+
+// src/adapters/memory.js
+var MemoryAdapter = class {
+  constructor() {
+    this.stores = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Create a new in-memory store
+   * 
+   * @param {Object} config - Store configuration
+   * @returns {Promise<Object>} Store instance
+   */
+  async createPool(config) {
+    const collections = /* @__PURE__ */ new Map();
+    const schemas = /* @__PURE__ */ new Map();
+    const store = {
+      config,
+      stats: {
+        created: Date.now(),
+        operations: 0,
+        collections: 0,
+        queries: 0
+      },
+      /**
+       * Get a collection by name
+       * @private
+       */
+      _getCollection(name) {
+        if (!collections.has(name)) {
+          collections.set(name, /* @__PURE__ */ new Map());
         }
-      } finally {
-        connection.release();
-      }
-    },
-    /**
-     * Start database transaction
-     */
-    async transaction(pool) {
-      const connection = await pool.getConnection();
-      await connection.beginTransaction();
-      const transaction = {
-        connection,
-        pool,
-        isCommitted: false,
-        isRolledBack: false,
-        query: async (sql, params, queryOptions) => {
-          if (transaction.isCommitted || transaction.isRolledBack) {
-            throw new Error("Cannot execute query on completed transaction");
+        return collections.get(name);
+      },
+      /**
+       * Get schema for a collection
+       * @private
+       */
+      _getSchema(collectionName) {
+        return schemas.get(collectionName) || {};
+      },
+      /**
+       * Execute a query
+       * @param {string} operation - Operation type
+       * @param {Object} params - Query parameters
+       * @returns {Promise<*>} Query result
+       */
+      async query(operation, params = {}) {
+        this.stats.operations++;
+        this.stats.queries++;
+        const { table, where = {}, data, limit, offset, orderBy } = params;
+        const collection = this._getCollection(table);
+        switch (operation.toUpperCase()) {
+          case "FIND": {
+            let results = Array.from(collection.values());
+            if (Object.keys(where).length > 0) {
+              results = results.filter(
+                (item) => Object.entries(where).every(([key, value]) => {
+                  if (value === void 0) return true;
+                  if (value === null) return item[key] === null;
+                  return JSON.stringify(item[key]) === JSON.stringify(value);
+                })
+              );
+            }
+            if (orderBy) {
+              let field, direction;
+              if (Array.isArray(orderBy)) {
+                [field, direction = "ASC"] = orderBy;
+              } else if (typeof orderBy === "object") {
+                const entries = Object.entries(orderBy);
+                if (entries.length > 0) {
+                  [field, direction] = entries[0];
+                }
+              } else {
+                field = orderBy;
+                direction = "ASC";
+              }
+              if (field) {
+                const dir = direction.toLowerCase();
+                results.sort((a, b) => {
+                  if (a[field] < b[field]) return dir === "asc" ? -1 : 1;
+                  if (a[field] > b[field]) return dir === "asc" ? 1 : -1;
+                  return 0;
+                });
+              }
+            }
+            if (offset) results = results.slice(offset);
+            if (limit) results = results.slice(0, limit);
+            return results;
           }
-          const [rows] = await connection.execute(sql, params);
-          if (queryOptions && queryOptions.single) {
-            return Array.isArray(rows) ? rows[0] || null : rows;
+          case "INSERT": {
+            if (!data) throw new Error("No data provided for insert");
+            const id = data.id || Date.now().toString(36) + Math.random().toString(36).substr(2);
+            const record = { ...data, id };
+            collection.set(id, record);
+            this.stats.collections = collections.size;
+            return { id };
           }
-          if (Array.isArray(rows)) {
-            return {
-              rows,
-              rowCount: rows.length,
-              affectedRows: rows.affectedRows || rows.length,
-              insertId: rows.insertId || null
-            };
-          } else {
-            return {
-              rows: [],
-              rowCount: rows.affectedRows || 0,
-              affectedRows: rows.affectedRows || 0,
-              insertId: rows.insertId || null
-            };
+          case "UPDATE": {
+            if (!data) throw new Error("No data provided for update");
+            const records = await this.query("FIND", { table, where });
+            const updated = [];
+            for (const record of records) {
+              const updatedRecord = { ...record, ...data };
+              collection.set(record.id, updatedRecord);
+              updated.push(updatedRecord);
+            }
+            return { affectedRows: updated.length };
           }
-        },
-        commit: async () => {
-          if (transaction.isCommitted || transaction.isRolledBack) {
-            throw new Error("Transaction already completed");
+          case "DELETE": {
+            const records = await this.query("FIND", { table, where });
+            const deleted = [];
+            for (const record of records) {
+              if (collection.delete(record.id)) {
+                deleted.push(record);
+              }
+            }
+            return { affectedRows: deleted.length };
           }
-          try {
-            await connection.commit();
-            transaction.isCommitted = true;
-          } finally {
-            connection.release();
+          case "COUNT": {
+            const results = await this.query("FIND", { table, where });
+            return { count: results.length };
           }
-        },
-        rollback: async () => {
-          if (transaction.isCommitted || transaction.isRolledBack) {
-            throw new Error("Transaction already completed");
+          case "CREATE_COLLECTION": {
+            const { name, schema } = params;
+            schemas.set(name, schema || {});
+            return { success: true };
           }
-          try {
-            await connection.rollback();
-            transaction.isRolledBack = true;
-          } finally {
-            connection.release();
+          case "SET_SCHEMA": {
+            const { model, schema } = params;
+            schemas.set(model, schema);
+            return { success: true };
           }
+          default:
+            throw new Error(`Unsupported operation: ${operation}`);
         }
-      };
-      return transaction;
-    },
-    /**
-     * Get pool statistics
-     */
-    getPoolStats(pool) {
-      return {
-        total: pool.config.connectionLimit,
-        available: pool._freeConnections ? pool._freeConnections.length : 0,
-        acquired: pool._allConnections ? pool._allConnections.length - (pool._freeConnections ? pool._freeConnections.length : 0) : 0,
-        waiting: pool._connectionQueue ? pool._connectionQueue.length : 0
-      };
-    },
-    /**
-     * Close connection pool
-     */
-    async closePool(pool) {
-      await pool.end();
+      },
+      /**
+       * Get store statistics
+       * @returns {Object}
+       */
+      getStats() {
+        return {
+          ...this.stats,
+          uptime: Date.now() - this.stats.created,
+          collections: collections.size,
+          operations: this.stats.operations,
+          queries: this.stats.queries
+        };
+      },
+      /**
+       * Execute a transaction
+       * @param {Function} callback - Transaction callback
+       * @returns {Promise<*>} Result of the transaction
+       */
+      async transaction(callback) {
+        try {
+          const result = await callback({
+            query: (operation, params) => this.query(operation, params)
+          });
+          return result;
+        } catch (_error) {
+          throw _error;
+        }
+      }
+    };
+    this.stores.set(config.name || "default", store);
+    return store;
+  }
+  /**
+   * Get a store by name
+   * 
+   * @param {string} name - Store name
+   * @returns {Object|undefined} Store instance or undefined if not found
+   */
+  getStore(name = "default") {
+    return this.stores.get(name);
+  }
+  /**
+   * Close all stores and clean up
+   * 
+   * @returns {Promise<void>}
+   */
+  async close() {
+    this.stores.clear();
+  }
+  /**
+   * Close the connection pool
+   * @param {Object} pool - The connection pool to close
+   * @returns {Promise<void>}
+   */
+  async closePool(pool) {
+    if (pool) {
+      if (pool.collections) {
+        pool.collections.clear();
+      }
+      if (pool.schemas) {
+        pool.schemas.clear();
+      }
     }
-  };
-}
+    return Promise.resolve();
+  }
+  /**
+   * Execute a transaction
+   * @param {Function} callback - Transaction callback
+   * @returns {Promise<*>} Result of the transaction
+   */
+  async transaction(callback) {
+    try {
+      const result = await callback({
+        query: (operation, params) => this.query(operation, params)
+      });
+      return result;
+    } catch (_error) {
+      throw _error;
+    }
+  }
+};
 
-// src/adapters/sqlite.js
-function createSQLiteAdapter() {
-  let sqlite3 = null;
-  let db = null;
-  async function initializeSQLite() {
-    if (!sqlite3) {
-      try {
-        const sqlite3Module = await import("sqlite3");
-        sqlite3 = sqlite3Module.default || sqlite3Module;
-      } catch {
-        throw new Error("Failed to load sqlite3 module. Make sure to install it: npm install sqlite3");
+// src/connection-manager.js
+var DatabaseManager = class extends EventEmitter {
+  constructor(config) {
+    super();
+    this.config = this.validateConfig(config);
+    this.adapter = null;
+    this.pool = null;
+    this.isConnected = false;
+    this.connectionAttempts = 0;
+    this.maxRetries = 3;
+    this.healthCheckInterval = null;
+    this.healthCheckFrequency = 3e4;
+    this.stats = {
+      totalConnections: 0,
+      activeConnections: 0,
+      failedConnections: 0,
+      queriesExecuted: 0,
+      averageQueryTime: 0,
+      lastHealthCheck: null
+    };
+  }
+  /**
+   * Validate database configuration
+   *
+   * @private
+   * @param {Object} config - Configuration to validate
+   * @returns {Object} Validated configuration
+   * @throws {Error} If configuration is invalid
+   */
+  validateConfig(config) {
+    if (!config || typeof config !== "object") {
+      throw new Error("Database configuration is required");
+    }
+    if (config.adapter) {
+      if (typeof config.adapter !== "object" || typeof config.adapter.createPool !== "function") {
+        throw new Error("Invalid adapter provided. Adapter must be an object with a createPool method");
+      }
+      if (!config.store) {
+        config.store = { name: "default" };
+      } else if (typeof config.store === "string") {
+        config.store = { name: config.store };
       }
+      return config;
     }
-  }
-  async function connect(config) {
-    await initializeSQLite();
-    return new Promise((resolve, reject) => {
-      try {
-        db = new sqlite3.Database(
-          config.database,
-          config.readonly ? sqlite3.OPEN_READONLY : sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE,
-          (err) => {
-            if (err) {
-              return reject(new Error(`Failed to connect to SQLite database: ${err.message}`));
-            }
-            db.run("PRAGMA foreign_keys = ON");
-            db.run("PRAGMA journal_mode = WAL");
-            db.run("PRAGMA busy_timeout = 5000");
-            resolve(instance);
-          }
-        );
-      } catch (_error) {
-        reject(new Error(`Failed to connect to SQLite database: ${_error.message}`));
+    const { type, database } = config;
+    if (!type) {
+      throw new Error("Either database type or adapter is required");
+    }
+    const supportedTypes = ["postgresql", "mysql", "sqlite", "mongodb"];
+    if (!supportedTypes.includes(type)) {
+      throw new Error(`Unsupported database type: ${type}. Supported types: ${supportedTypes.join(", ")}`);
+    }
+    if (!database) {
+      throw new Error("Database name is required for type-based configuration");
+    }
+    const defaultPorts = {
+      postgresql: 5432,
+      mysql: 3306,
+      mongodb: 27017,
+      sqlite: null
+    };
+    return {
+      host: config.host || "localhost",
+      port: config.port || defaultPorts[type],
+      ...config,
+      pool: {
+        min: 2,
+        max: 10,
+        acquireTimeoutMillis: 3e4,
+        createTimeoutMillis: 3e4,
+        destroyTimeoutMillis: 5e3,
+        idleTimeoutMillis: 3e4,
+        reapIntervalMillis: 1e3,
+        createRetryIntervalMillis: 200,
+        ...config.pool
       }
-    });
+    };
   }
-  function query(sql, params = []) {
-    return new Promise((resolve, reject) => {
-      if (!db) {
-        return reject(new Error("Database connection not established. Call connect() first."));
+  /**
+   * Connect to the database
+   *
+   * @returns {Promise<void>}
+   * @throws {Error} If connection fails after retries
+   *
+   * @example
+   * await db.connect();
+   * console.log('Database connected successfully');
+   */
+  async connect() {
+    if (this.isConnected) {
+      return;
+    }
+    try {
+      this.adapter = await this.loadAdapter(this.config.type);
+      if (typeof this.adapter.createPool === "function") {
+        this.pool = await this.adapter.createPool(this.config);
+      } else if (typeof this.adapter.connect === "function") {
+        this.pool = await this.adapter.connect(this.config);
+      } else {
+        throw new Error("Adapter must have either createPool or connect method");
       }
-      db.all(sql, params, (err, rows) => {
-        if (err) {
-          return reject(new Error(`SQLite query _error: ${err.message}`));
-        }
-        resolve({ rows });
-      });
-    });
-  }
-  function execute(sql, params = []) {
-    return new Promise((resolve, reject) => {
-      if (!db) {
-        return reject(new Error("Database connection not established. Call connect() first."));
+      await this.testConnection();
+      this.isConnected = true;
+      this.connectionAttempts = 0;
+      if (this.adapter.startHealthChecks) {
+        this.startHealthChecks();
       }
-      db.run(sql, params, function(err) {
-        if (err) {
-          return reject(new Error(`SQLite execute _error: ${err.message}`));
-        }
-        resolve({
-          affectedRows: this.changes,
-          insertId: this.lastID
-        });
-      });
-    });
-  }
-  function beginTransaction() {
-    return new Promise((resolve, reject) => {
-      if (!db) {
-        return reject(new Error("Database connection not established. Call connect() first."));
+      return this;
+    } catch (_error) {
+      this.connectionAttempts++;
+      this.stats.failedConnections++;
+      this.emit("_error", _error);
+      if (this.connectionAttempts < this.maxRetries) {
+        console.warn(`Connection attempt ${this.connectionAttempts} failed. Retrying in 2 seconds...`);
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+        return this.connect();
       }
-      db.run("BEGIN TRANSACTION", (err) => {
-        if (err) {
-          return reject(new Error(`Failed to begin transaction: ${err.message}`));
-        }
-        resolve();
-      });
-    });
+      throw new Error(`Failed to connect to database after ${this.connectionAttempts} attempts: ${_error.message}`);
+    }
   }
-  function commit() {
-    return new Promise((resolve, reject) => {
-      if (!db) {
-        return reject(new Error("Database connection not established. Call connect() first."));
-      }
-      db.run("COMMIT", (err) => {
-        if (err) {
-          return reject(new Error(`Failed to commit transaction: ${err.message}`));
-        }
-        resolve();
-      });
-    });
+  /**
+   * Load database adapter
+   *
+   * @private
+   * @param {string} type - Database type
+   * @returns {Object} Database adapter
+   */
+  loadAdapter(type) {
+    if (this.config.adapter) {
+      return Promise.resolve(this.config.adapter);
+    }
+    const adapterFactories = {
+      postgresql: createPostgreSQLAdapter,
+      mysql: createMySQLAdapter,
+      sqlite: createSQLiteAdapter,
+      mongodb: createMongoDBAdapter,
+      memory: () => new MemoryAdapter()
+    };
+    const adapterFactory = adapterFactories[type];
+    if (!adapterFactory) {
+      return Promise.reject(new Error(`No adapter found for database type: ${type}`));
+    }
+    try {
+      const adapter = adapterFactory();
+      return Promise.resolve(adapter);
+    } catch (_error) {
+      return Promise.reject(new Error(`Failed to load ${type} adapter: ${_error.message}`));
+    }
   }
-  function rollback() {
-    return new Promise((resolve, reject) => {
-      if (!db) {
-        return reject(new Error("Database connection not established. Call connect() first."));
+  /**
+   * Test database connection
+   *
+   * @private
+   * @returns {Promise<void>}
+   */
+  async testConnection() {
+    const startTime = Date.now();
+    try {
+      if (typeof this.adapter.testConnection === "function") {
+        await this.adapter.testConnection(this.pool);
+      } else if (this.adapter.ping) {
+        await this.adapter.ping();
       }
-      db.run("ROLLBACK", (err) => {
-        if (err) {
-          return reject(new Error(`Failed to rollback transaction: ${err.message}`));
-        }
-        resolve();
-      });
-    });
+      const duration = Date.now() - startTime;
+      this.stats.lastHealthCheck = /* @__PURE__ */ new Date();
+      this.emit("connect:test", { duration });
+    } catch (_error) {
+      this.emit("_error", _error);
+      throw new Error(`Database connection test failed: ${_error.message}`);
+    }
   }
-  function disconnect() {
-    return new Promise((resolve, reject) => {
-      if (!db) {
-        return resolve();
+  /**
+   * Execute a database query
+   *
+   * @param {string} sql - SQL query string
+   * @param {Array} [params=[]] - Query parameters
+   * @param {Object} [options={}] - Query options
+   * @returns {Promise<Object>} Query result
+   *
+   * @example
+   * const users = await db.query('SELECT * FROM users WHERE age > ?', [18]);
+   * const user = await db.query('SELECT * FROM users WHERE id = ?', [123], { single: true });
+   */
+  async query(operation, params = {}) {
+    if (!this.isConnected) {
+      throw new Error("Database not connected. Call connect() first.");
+    }
+    const startTime = Date.now();
+    try {
+      let result;
+      if (typeof this.pool.query === "function") {
+        result = await this.pool.query(operation, params);
+      } else if (typeof this.adapter.query === "function") {
+        result = await this.adapter.query(this.pool, operation, params);
+      } else {
+        throw new Error("No valid query method found on adapter or pool");
       }
-      db.close((err) => {
-        if (err) {
-          return reject(new Error(`Failed to close database connection: ${err.message}`));
-        }
-        db = null;
-        resolve();
-      });
-    });
+      const duration = Date.now() - startTime;
+      this.stats.queriesExecuted++;
+      this.stats.averageQueryTime = (this.stats.averageQueryTime * (this.stats.queriesExecuted - 1) + duration) / this.stats.queriesExecuted;
+      if (this.config.debug) {
+        console.log(`Query executed in ${duration}ms: ${operation}`, params);
+      }
+      this.emit("query", { operation, params, duration });
+      return result;
+    } catch (_error) {
+      const duration = Date.now() - startTime;
+      this.emit("queryError", { operation, params, duration, _error: _error.message });
+      throw new Error(`Query failed: ${_error.message}`);
+    }
   }
-  function getConnection() {
-    if (!db) {
-      throw new Error("Database connection not established. Call connect() first.");
+  /**
+   * Start a database transaction
+   *
+   * @returns {Promise<Object>} Transaction object
+   *
+   * @example
+   * const tx = await db.transaction();
+   * try {
+   *   await tx.query('INSERT INTO users (name) VALUES (?)', ['John']);
+   *   await tx.query('INSERT INTO profiles (user_id) VALUES (?)', [userId]);
+   *   await tx.commit();
+   * } catch (_error) {
+   *   await tx.rollback();
+   *   throw _error;
+   * }
+   */
+  async transaction() {
+    if (!this.isConnected) {
+      throw new Error("Database not connected. Call connect() first.");
     }
-    return db;
+    return await this.adapter.transaction(this.pool);
   }
-  async function ping() {
-    try {
-      await query("SELECT 1");
-      return true;
-    } catch {
-      return false;
+  /**
+   * Start health check monitoring
+   *
+   * @private
+   */
+  startHealthCheck() {
+    if (this.healthCheckInterval) {
+      return;
     }
+    this.healthCheckInterval = setInterval(async () => {
+      try {
+        await this.testConnection();
+        this.emit("healthCheck", { status: "healthy", timestamp: /* @__PURE__ */ new Date() });
+      } catch (_error) {
+        this.emit("healthCheck", { status: "unhealthy", _error: _error.message, timestamp: /* @__PURE__ */ new Date() });
+        if (this.config.debug) {
+          console.error("Database health check failed:", _error.message);
+        }
+      }
+    }, this.healthCheckFrequency);
   }
-  function escape(value) {
-    if (value === null || value === void 0) {
-      return "NULL";
+  /**
+   * Get connection statistics
+   *
+   * @returns {Object} Connection statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      isConnected: this.isConnected,
+      poolStats: this.pool ? this.adapter.getPoolStats(this.pool) : null
+    };
+  }
+  /**
+   * Close database connection
+   *
+   * @returns {Promise<void>}
+   */
+  async close() {
+    if (!this.isConnected) {
+      return;
     }
-    if (typeof value === "boolean") {
-      return value ? "1" : "0";
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+    if (this.pool && this.adapter) {
+      await this.adapter.closePool(this.pool);
     }
-    if (typeof value === "number") {
-      return String(value);
+    this.isConnected = false;
+    this.pool = null;
+    this.adapter = null;
+    this.emit("disconnected");
+    if (this.config.debug) {
+      console.log("Database connection closed");
     }
-    return `'${String(value).replace(/'/g, "''")}'`;
   }
-  const instance = {
-    connect,
-    query,
-    execute,
-    beginTransaction,
-    commit,
-    rollback,
-    disconnect,
-    getConnection,
-    ping,
-    escape
-  };
-  return instance;
+};
+function createDatabaseManager(config) {
+  return new DatabaseManager(config);
 }
 
-// src/adapters/mongodb.js
-function createMongoDBAdapter() {
-  let mongodb = null;
-  let client = null;
-  let db = null;
-  async function initializeMongoDB() {
-    if (!mongodb) {
-      try {
-        const mongoModule = await import("mongodb");
-        mongodb = mongoModule;
-      } catch {
-        throw new Error("Failed to load mongodb module. Make sure to install it: npm install mongodb");
-      }
-    }
-  }
-  async function connect(config) {
-    await initializeMongoDB();
-    try {
-      client = new mongodb.MongoClient(config.url, config.options || {});
-      await client.connect();
-      db = client.db(config.database);
-      return instance;
-    } catch (_error) {
-      throw new Error(`Failed to connect to MongoDB: ${_error.message}`);
-    }
-  }
-  async function query(collectionName, query2 = {}, options = {}) {
-    if (!db) {
-      throw new Error("Database connection not established. Call connect() first.");
-    }
+// src/middleware.js
+function withDatabase(db, options = {}) {
+  const config = {
+    autoConnect: true,
+    attachModels: true,
+    transactionKey: "tx",
+    ...options
+  };
+  return async (req, res, next) => {
     try {
-      const collection = db.collection(collectionName);
-      const cursor = collection.find(query2, options);
-      if (options.sort) {
-        cursor.sort(options.sort);
-      }
-      if (options.limit) {
-        cursor.limit(options.limit);
-      }
-      if (options.skip) {
-        cursor.skip(options.skip);
+      if (config.autoConnect && !db.isConnected) {
+        await db.connect();
       }
-      if (options.projection) {
-        cursor.project(options.projection);
+      req.db = db;
+      req.dbQuery = async (sql, params, queryOptions) => {
+        return await db.query(sql, params, queryOptions);
+      };
+      req.transaction = async (callback) => {
+        const tx = await db.transaction();
+        try {
+          const result = await callback(tx);
+          await tx.commit();
+          return result;
+        } catch (_error) {
+          await tx.rollback();
+          throw _error;
+        }
+      };
+      if (config.attachModels && db.models) {
+        req.models = db.models;
       }
-      return cursor.toArray();
+      await next();
     } catch (_error) {
-      throw new Error(`MongoDB query _error: ${_error.message}`);
-    }
-  }
-  async function execute(command) {
-    if (!db) {
-      throw new Error("Database connection not established. Call connect() first.");
+      console.error("Database middleware _error:", _error);
+      if (typeof next === "function") {
+        next(_error);
+      } else {
+        throw _error;
+      }
     }
+  };
+}
+function withTransaction(db, options = {}) {
+  const config = {
+    isolationLevel: null,
+    readOnly: false,
+    ...options
+  };
+  return async (req, res, next) => {
+    const tx = await db.transaction(config);
+    req.tx = tx;
     try {
-      return await db.command(command);
+      await next();
+      if (!tx.isCommitted && !tx.isRolledBack) {
+        await tx.commit();
+      }
     } catch (_error) {
-      throw new Error(`MongoDB command _error: ${_error.message}`);
-    }
-  }
-  async function beginTransaction() {
-    if (!client) {
-      throw new Error("Database connection not established. Call connect() first.");
-    }
-    const session = client.startSession();
-    session.startTransaction();
-    return session;
-  }
-  async function commit(session) {
-    if (!session) {
-      throw new Error("No active transaction session");
-    }
-    try {
-      await session.commitTransaction();
-    } finally {
-      await session.endSession();
-    }
-  }
-  async function rollback(session) {
-    if (!session) {
-      throw new Error("No active transaction session");
-    }
-    try {
-      await session.abortTransaction();
-    } finally {
-      await session.endSession();
-    }
-  }
-  async function disconnect() {
-    if (client) {
-      await client.close();
-      client = null;
-      db = null;
+      if (!tx.isRolledBack && !tx.isCommitted) {
+        await tx.rollback();
+      }
+      throw _error;
     }
-  }
-  function getConnection() {
-    if (!db) {
-      throw new Error("Database connection not established. Call connect() first.");
+  };
+}
+function withModel(ModelClass, paramName = "id", requestKey = null) {
+  let modelName = requestKey;
+  if (!modelName) {
+    if (ModelClass && ModelClass.name) {
+      modelName = ModelClass.name.toLowerCase();
+    } else if (ModelClass && ModelClass.tableName) {
+      modelName = ModelClass.tableName.slice(0, -1);
+    } else {
+      modelName = "model";
     }
-    return db;
   }
-  async function ping() {
+  const key = modelName;
+  return async (req, res, next) => {
     try {
-      await db.command({ ping: 1 });
-      return true;
-    } catch {
-      return false;
+      const paramValue = req.params[paramName];
+      if (!paramValue) {
+        const _error = new Error(`Parameter '${paramName}' is required`);
+        _error.status = 400;
+        throw _error;
+      }
+      const model = await ModelClass.find(paramValue);
+      if (!model) {
+        const _error = new Error(`${ModelClass.name} not found`);
+        _error.status = 404;
+        throw _error;
+      }
+      req[key] = model;
+      await next();
+    } catch (_error) {
+      if (typeof next === "function") {
+        next(_error);
+      } else {
+        throw _error;
+      }
     }
-  }
-  function escape(value) {
-    return value;
-  }
-  const instance = {
-    connect,
-    query,
-    execute,
-    beginTransaction,
-    commit,
-    rollback,
-    disconnect,
-    getConnection,
-    ping,
-    escape
   };
-  return instance;
+}
+function withPagination(options = {}) {
+  const config = {
+    defaultLimit: 20,
+    maxLimit: 100,
+    pageParam: "page",
+    limitParam: "limit",
+    ...options
+  };
+  return async (req, res, next) => {
+    const page = Math.max(1, parseInt(req.query[config.pageParam]) || 1);
+    const limit = Math.min(
+      config.maxLimit,
+      Math.max(1, parseInt(req.query[config.limitParam]) || config.defaultLimit)
+    );
+    const offset = (page - 1) * limit;
+    req.pagination = {
+      page,
+      limit,
+      offset,
+      hasNext: null,
+      // To be set by the handler
+      hasPrev: page > 1,
+      totalPages: null,
+      // To be set by the handler
+      totalCount: null
+      // To be set by the handler
+    };
+    await next();
+  };
 }
 
 // src/utils.js