drizzle-multitenant 1.0.10 → 1.2.0

package/dist/integrations/nestjs/index.js

@@ -9407,8 +9407,161 @@ var DebugLogger = class {
 function createDebugLogger(config) {
   return new DebugLogger(config);
 }
+var PoolCache = class {
+  cache;
+  poolTtlMs;
+  onDispose;
+  constructor(options) {
+    this.poolTtlMs = options.poolTtlMs;
+    this.onDispose = options.onDispose;
+    this.cache = new LRUCache({
+      max: options.maxPools,
+      dispose: (entry, key) => {
+        void this.handleDispose(key, entry);
+      },
+      noDisposeOnSet: true
+    });
+  }
+  /**
+   * Get a pool entry from cache
+   *
+   * This does NOT update the last access time automatically.
+   * Use `touch()` to update access time when needed.
+   */
+  get(schemaName) {
+    return this.cache.get(schemaName);
+  }
+  /**
+   * Set a pool entry in cache
+   *
+   * If the cache is full, the least recently used entry will be evicted.
+   */
+  set(schemaName, entry) {
+    this.cache.set(schemaName, entry);
+  }
+  /**
+   * Check if a pool exists in cache
+   */
+  has(schemaName) {
+    return this.cache.has(schemaName);
+  }
+  /**
+   * Delete a pool from cache
+   *
+   * Note: This triggers the dispose callback if configured.
+   */
+  delete(schemaName) {
+    return this.cache.delete(schemaName);
+  }
+  /**
+   * Get the number of pools in cache
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * Get all schema names in cache
+   */
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  /**
+   * Iterate over all entries in cache
+   *
+   * @yields [schemaName, entry] pairs
+   */
+  *entries() {
+    for (const [key, value] of this.cache.entries()) {
+      yield [key, value];
+    }
+  }
+  /**
+   * Clear all pools from cache
+   *
+   * Each pool's dispose callback will be triggered by the LRU cache.
+   */
+  async clear() {
+    this.cache.clear();
+    await Promise.resolve();
+  }
+  /**
+   * Evict the least recently used pool
+   *
+   * @returns The schema name of the evicted pool, or undefined if cache is empty
+   */
+  evictLRU() {
+    const keys = Array.from(this.cache.keys());
+    if (keys.length === 0) {
+      return void 0;
+    }
+    const lruKey = keys[keys.length - 1];
+    this.cache.delete(lruKey);
+    return lruKey;
+  }
+  /**
+   * Evict pools that have exceeded TTL
+   *
+   * @returns Array of schema names that were evicted
+   */
+  async evictExpired() {
+    if (!this.poolTtlMs) {
+      return [];
+    }
+    const now = Date.now();
+    const toEvict = [];
+    for (const [schemaName, entry] of this.cache.entries()) {
+      if (now - entry.lastAccess > this.poolTtlMs) {
+        toEvict.push(schemaName);
+      }
+    }
+    for (const schemaName of toEvict) {
+      this.cache.delete(schemaName);
+    }
+    return toEvict;
+  }
+  /**
+   * Update last access time for a pool
+   *
+   * This moves the pool to the front of the LRU list.
+   */
+  touch(schemaName) {
+    const entry = this.cache.get(schemaName);
+    if (entry) {
+      entry.lastAccess = Date.now();
+    }
+  }
+  /**
+   * Get the maximum number of pools allowed in cache
+   */
+  getMaxPools() {
+    return this.cache.max;
+  }
+  /**
+   * Get the configured TTL in milliseconds
+   */
+  getTtlMs() {
+    return this.poolTtlMs;
+  }
+  /**
+   * Check if an entry has expired based on TTL
+   */
+  isExpired(entry) {
+    if (!this.poolTtlMs) {
+      return false;
+    }
+    return Date.now() - entry.lastAccess > this.poolTtlMs;
+  }
+  /**
+   * Handle disposal of a cache entry
+   */
+  async handleDispose(schemaName, entry) {
+    if (this.onDispose) {
+      await this.onDispose(schemaName, entry);
+    }
+  }
+};
 
-// src/retry.ts
+// src/pool/retry/retry-handler.ts
 function isRetryableError(error) {
   const message = error.message.toLowerCase();
   if (message.includes("econnrefused") || message.includes("econnreset") || message.includes("etimedout") || message.includes("enotfound") || message.includes("connection refused") || message.includes("connection reset") || message.includes("connection terminated") || message.includes("connection timed out") || message.includes("timeout expired") || message.includes("socket hang up")) {
@@ -9422,77 +9575,315 @@ function isRetryableError(error) {
   }
   return false;
 }
-function calculateDelay(attempt, config) {
-  const exponentialDelay = config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt);
-  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs);
-  if (config.jitter) {
-    const jitterFactor = 1 + Math.random() * 0.25;
-    return Math.floor(cappedDelay * jitterFactor);
-  }
-  return Math.floor(cappedDelay);
-}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function withRetry(operation, config) {
-  const retryConfig = {
-    maxAttempts: config?.maxAttempts ?? DEFAULT_CONFIG.retry.maxAttempts,
-    initialDelayMs: config?.initialDelayMs ?? DEFAULT_CONFIG.retry.initialDelayMs,
-    maxDelayMs: config?.maxDelayMs ?? DEFAULT_CONFIG.retry.maxDelayMs,
-    backoffMultiplier: config?.backoffMultiplier ?? DEFAULT_CONFIG.retry.backoffMultiplier,
-    jitter: config?.jitter ?? DEFAULT_CONFIG.retry.jitter,
-    isRetryable: config?.isRetryable ?? isRetryableError,
-    onRetry: config?.onRetry
-  };
-  const startTime = Date.now();
-  let lastError = null;
-  for (let attempt = 0; attempt < retryConfig.maxAttempts; attempt++) {
+var RetryHandler = class {
+  config;
+  constructor(config) {
+    this.config = {
+      maxAttempts: config?.maxAttempts ?? DEFAULT_CONFIG.retry.maxAttempts,
+      initialDelayMs: config?.initialDelayMs ?? DEFAULT_CONFIG.retry.initialDelayMs,
+      maxDelayMs: config?.maxDelayMs ?? DEFAULT_CONFIG.retry.maxDelayMs,
+      backoffMultiplier: config?.backoffMultiplier ?? DEFAULT_CONFIG.retry.backoffMultiplier,
+      jitter: config?.jitter ?? DEFAULT_CONFIG.retry.jitter,
+      isRetryable: config?.isRetryable ?? isRetryableError,
+      onRetry: config?.onRetry
+    };
+  }
+  /**
+   * Execute an operation with retry logic
+   *
+   * @param operation - The async operation to execute
+   * @param overrideConfig - Optional config to override defaults for this call
+   * @returns Result with metadata about attempts and timing
+   */
+  async withRetry(operation, overrideConfig) {
+    const config = overrideConfig ? { ...this.config, ...overrideConfig } : this.config;
+    const startTime = Date.now();
+    let lastError = null;
+    for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
+      try {
+        const result = await operation();
+        return {
+          result,
+          attempts: attempt + 1,
+          totalTimeMs: Date.now() - startTime
+        };
+      } catch (error) {
+        lastError = error;
+        const isLastAttempt = attempt >= config.maxAttempts - 1;
+        const checkRetryable = config.isRetryable ?? this.isRetryable;
+        if (isLastAttempt || !checkRetryable(lastError)) {
+          throw lastError;
+        }
+        const delay = this.calculateDelay(attempt, config);
+        config.onRetry?.(attempt + 1, lastError, delay);
+        await sleep(delay);
+      }
+    }
+    throw lastError ?? new Error("Retry failed with no error");
+  }
+  /**
+   * Calculate delay with exponential backoff and optional jitter
+   *
+   * @param attempt - Current attempt number (0-indexed)
+   * @param config - Retry configuration
+   * @returns Delay in milliseconds
+   */
+  calculateDelay(attempt, config) {
+    const cfg = config ? { ...this.config, ...config } : this.config;
+    const exponentialDelay = cfg.initialDelayMs * Math.pow(cfg.backoffMultiplier, attempt);
+    const cappedDelay = Math.min(exponentialDelay, cfg.maxDelayMs);
+    if (cfg.jitter) {
+      const jitterFactor = 1 + Math.random() * 0.25;
+      return Math.floor(cappedDelay * jitterFactor);
+    }
+    return Math.floor(cappedDelay);
+  }
+  /**
+   * Check if an error is retryable
+   *
+   * Uses the configured isRetryable function or the default implementation.
+   */
+  isRetryable(error) {
+    return (this.config.isRetryable ?? isRetryableError)(error);
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Get the maximum number of attempts
+   */
+  getMaxAttempts() {
+    return this.config.maxAttempts;
+  }
+};
+
+// src/pool/health/health-checker.ts
+var HealthChecker = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  /**
+   * Check health of all pools and connections
+   *
+   * Verifies the health of tenant pools and optionally the shared database.
+   * Returns detailed status information for monitoring and load balancer integration.
+   *
+   * @example
+   * ```typescript
+   * // Basic health check
+   * const health = await healthChecker.checkHealth();
+   * console.log(health.healthy); // true/false
+   *
+   * // Check specific tenants only
+   * const health = await healthChecker.checkHealth({
+   *   tenantIds: ['tenant-1', 'tenant-2'],
+   *   ping: true,
+   *   pingTimeoutMs: 3000,
+   * });
+   * ```
+   */
+  async checkHealth(options = {}) {
+    const startTime = Date.now();
+    const {
+      ping = true,
+      pingTimeoutMs = 5e3,
+      includeShared = true,
+      tenantIds
+    } = options;
+    const poolHealthResults = [];
+    let sharedDbStatus = "ok";
+    let sharedDbResponseTimeMs;
+    let sharedDbError;
+    const poolsToCheck = this.getPoolsToCheck(tenantIds);
+    const poolChecks = poolsToCheck.map(async ({ schemaName, tenantId, entry }) => {
+      return this.checkPoolHealth(tenantId, schemaName, entry, ping, pingTimeoutMs);
+    });
+    poolHealthResults.push(...await Promise.all(poolChecks));
+    const sharedPool = this.deps.getSharedPool();
+    if (includeShared && sharedPool) {
+      const sharedResult = await this.checkSharedDbHealth(sharedPool, ping, pingTimeoutMs);
+      sharedDbStatus = sharedResult.status;
+      sharedDbResponseTimeMs = sharedResult.responseTimeMs;
+      sharedDbError = sharedResult.error;
+    }
+    const degradedPools = poolHealthResults.filter((p) => p.status === "degraded").length;
+    const unhealthyPools = poolHealthResults.filter((p) => p.status === "unhealthy").length;
+    const healthy = unhealthyPools === 0 && sharedDbStatus !== "unhealthy";
+    const result = {
+      healthy,
+      pools: poolHealthResults,
+      sharedDb: sharedDbStatus,
+      totalPools: poolHealthResults.length,
+      degradedPools,
+      unhealthyPools,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - startTime
+    };
+    if (sharedDbResponseTimeMs !== void 0) {
+      result.sharedDbResponseTimeMs = sharedDbResponseTimeMs;
+    }
+    if (sharedDbError !== void 0) {
+      result.sharedDbError = sharedDbError;
+    }
+    return result;
+  }
+  /**
+   * Get pools to check based on options
+   */
+  getPoolsToCheck(tenantIds) {
+    const poolsToCheck = [];
+    if (tenantIds && tenantIds.length > 0) {
+      for (const tenantId of tenantIds) {
+        const schemaName = this.deps.getSchemaName(tenantId);
+        const entry = this.deps.getPoolEntry(schemaName);
+        if (entry) {
+          poolsToCheck.push({ schemaName, tenantId, entry });
+        }
+      }
+    } else {
+      for (const [schemaName, entry] of this.deps.getPoolEntries()) {
+        const tenantId = this.deps.getTenantIdBySchema(schemaName) ?? schemaName;
+        poolsToCheck.push({ schemaName, tenantId, entry });
+      }
+    }
+    return poolsToCheck;
+  }
+  /**
+   * Check health of a single tenant pool
+   */
+  async checkPoolHealth(tenantId, schemaName, entry, ping, pingTimeoutMs) {
+    const pool = entry.pool;
+    const totalConnections = pool.totalCount;
+    const idleConnections = pool.idleCount;
+    const waitingRequests = pool.waitingCount;
+    let status = "ok";
+    let responseTimeMs;
+    let error;
+    if (waitingRequests > 0) {
+      status = "degraded";
+    }
+    if (ping) {
+      const pingResult = await this.executePingQuery(pool, pingTimeoutMs);
+      responseTimeMs = pingResult.responseTimeMs;
+      if (!pingResult.success) {
+        status = "unhealthy";
+        error = pingResult.error;
+      } else if (pingResult.responseTimeMs && pingResult.responseTimeMs > pingTimeoutMs / 2) {
+        if (status === "ok") {
+          status = "degraded";
+        }
+      }
+    }
+    const result = {
+      tenantId,
+      schemaName,
+      status,
+      totalConnections,
+      idleConnections,
+      waitingRequests
+    };
+    if (responseTimeMs !== void 0) {
+      result.responseTimeMs = responseTimeMs;
+    }
+    if (error !== void 0) {
+      result.error = error;
+    }
+    return result;
+  }
+  /**
+   * Check health of shared database
+   */
+  async checkSharedDbHealth(sharedPool, ping, pingTimeoutMs) {
+    let status = "ok";
+    let responseTimeMs;
+    let error;
+    const waitingRequests = sharedPool.waitingCount;
+    if (waitingRequests > 0) {
+      status = "degraded";
+    }
+    if (ping) {
+      const pingResult = await this.executePingQuery(sharedPool, pingTimeoutMs);
+      responseTimeMs = pingResult.responseTimeMs;
+      if (!pingResult.success) {
+        status = "unhealthy";
+        error = pingResult.error;
+      } else if (pingResult.responseTimeMs && pingResult.responseTimeMs > pingTimeoutMs / 2) {
+        if (status === "ok") {
+          status = "degraded";
+        }
+      }
+    }
+    const result = { status };
+    if (responseTimeMs !== void 0) {
+      result.responseTimeMs = responseTimeMs;
+    }
+    if (error !== void 0) {
+      result.error = error;
+    }
+    return result;
+  }
+  /**
+   * Execute a ping query with timeout
+   */
+  async executePingQuery(pool, timeoutMs) {
+    const startTime = Date.now();
     try {
-      const result = await operation();
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("Health check ping timeout")), timeoutMs);
+      });
+      const queryPromise = pool.query("SELECT 1");
+      await Promise.race([queryPromise, timeoutPromise]);
       return {
-        result,
-        attempts: attempt + 1,
-        totalTimeMs: Date.now() - startTime
+        success: true,
+        responseTimeMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        success: false,
+        responseTimeMs: Date.now() - startTime,
+        error: err.message
       };
-    } catch (error) {
-      lastError = error;
-      const isLastAttempt = attempt >= retryConfig.maxAttempts - 1;
-      if (isLastAttempt || !retryConfig.isRetryable(lastError)) {
-        throw lastError;
-      }
-      const delay = calculateDelay(attempt, retryConfig);
-      retryConfig.onRetry?.(attempt + 1, lastError, delay);
-      await sleep(delay);
     }
   }
-  throw lastError ?? new Error("Retry failed with no error");
-}
+  /**
+   * Determine overall health status from pool health results
+   */
+  determineOverallHealth(pools, sharedDbStatus = "ok") {
+    const unhealthyPools = pools.filter((p) => p.status === "unhealthy").length;
+    return unhealthyPools === 0 && sharedDbStatus !== "unhealthy";
+  }
+};
 
 // src/pool.ts
 var PoolManager = class {
   constructor(config) {
     this.config = config;
     const maxPools = config.isolation.maxPools ?? DEFAULT_CONFIG.maxPools;
+    const poolTtlMs = config.isolation.poolTtlMs ?? DEFAULT_CONFIG.poolTtlMs;
     this.debugLogger = createDebugLogger(config.debug);
-    const userRetry = config.connection.retry ?? {};
-    this.retryConfig = {
-      maxAttempts: userRetry.maxAttempts ?? DEFAULT_CONFIG.retry.maxAttempts,
-      initialDelayMs: userRetry.initialDelayMs ?? DEFAULT_CONFIG.retry.initialDelayMs,
-      maxDelayMs: userRetry.maxDelayMs ?? DEFAULT_CONFIG.retry.maxDelayMs,
-      backoffMultiplier: userRetry.backoffMultiplier ?? DEFAULT_CONFIG.retry.backoffMultiplier,
-      jitter: userRetry.jitter ?? DEFAULT_CONFIG.retry.jitter,
-      isRetryable: userRetry.isRetryable ?? isRetryableError,
-      onRetry: userRetry.onRetry
-    };
-    this.pools = new LRUCache({
-      max: maxPools,
-      dispose: (entry, key) => {
-        this.disposePoolEntry(entry, key);
-      },
-      noDisposeOnSet: true
+    this.retryHandler = new RetryHandler(config.connection.retry);
+    this.poolCache = new PoolCache({
+      maxPools,
+      poolTtlMs,
+      onDispose: (schemaName, entry) => {
+        this.disposePoolEntry(entry, schemaName);
+      }
+    });
+    this.healthChecker = new HealthChecker({
+      getPoolEntries: () => this.poolCache.entries(),
+      getTenantIdBySchema: (schemaName) => this.tenantIdBySchema.get(schemaName),
+      getPoolEntry: (schemaName) => this.poolCache.get(schemaName),
+      getSchemaName: (tenantId) => this.config.isolation.schemaNameTemplate(tenantId),
+      getSharedPool: () => this.sharedPool
     });
   }
-  pools;
+  poolCache;
   tenantIdBySchema = /* @__PURE__ */ new Map();
   pendingConnections = /* @__PURE__ */ new Map();
   sharedPool = null;
@@ -9501,22 +9892,23 @@ var PoolManager = class {
   cleanupInterval = null;
   disposed = false;
   debugLogger;
-  retryConfig;
+  retryHandler;
+  healthChecker;
   /**
    * Get or create a database connection for a tenant
    */
   getDb(tenantId) {
     this.ensureNotDisposed();
     const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    let entry = this.pools.get(schemaName);
+    let entry = this.poolCache.get(schemaName);
     if (!entry) {
       entry = this.createPoolEntry(tenantId, schemaName);
-      this.pools.set(schemaName, entry);
+      this.poolCache.set(schemaName, entry);
       this.tenantIdBySchema.set(schemaName, tenantId);
       this.debugLogger.logPoolCreated(tenantId, schemaName);
       void this.config.hooks?.onPoolCreated?.(tenantId);
     }
-    entry.lastAccess = Date.now();
+    this.poolCache.touch(schemaName);
     return entry.db;
   }
   /**
@@ -9537,26 +9929,26 @@ var PoolManager = class {
   async getDbAsync(tenantId) {
     this.ensureNotDisposed();
     const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    let entry = this.pools.get(schemaName);
+    let entry = this.poolCache.get(schemaName);
     if (entry) {
-      entry.lastAccess = Date.now();
+      this.poolCache.touch(schemaName);
       return entry.db;
     }
     const pending = this.pendingConnections.get(schemaName);
     if (pending) {
       entry = await pending;
-      entry.lastAccess = Date.now();
+      this.poolCache.touch(schemaName);
       return entry.db;
     }
     const connectionPromise = this.connectWithRetry(tenantId, schemaName);
     this.pendingConnections.set(schemaName, connectionPromise);
     try {
       entry = await connectionPromise;
-      this.pools.set(schemaName, entry);
+      this.poolCache.set(schemaName, entry);
       this.tenantIdBySchema.set(schemaName, tenantId);
       this.debugLogger.logPoolCreated(tenantId, schemaName);
       void this.config.hooks?.onPoolCreated?.(tenantId);
-      entry.lastAccess = Date.now();
+      this.poolCache.touch(schemaName);
       return entry.db;
     } finally {
       this.pendingConnections.delete(schemaName);
@@ -9566,8 +9958,9 @@ var PoolManager = class {
    * Connect to a tenant database with retry logic
    */
   async connectWithRetry(tenantId, schemaName) {
-    const maxAttempts = this.retryConfig.maxAttempts;
-    const result = await withRetry(
+    const retryConfig = this.retryHandler.getConfig();
+    const maxAttempts = retryConfig.maxAttempts;
+    const result = await this.retryHandler.withRetry(
       async () => {
         const entry = this.createPoolEntry(tenantId, schemaName);
         try {
@@ -9582,10 +9975,9 @@ var PoolManager = class {
         }
       },
       {
-        ...this.retryConfig,
         onRetry: (attempt, error, delayMs) => {
           this.debugLogger.logConnectionRetry(tenantId, attempt, maxAttempts, error, delayMs);
-          this.retryConfig.onRetry?.(attempt, error, delayMs);
+          retryConfig.onRetry?.(attempt, error, delayMs);
         }
       }
     );
@@ -9647,8 +10039,9 @@ var PoolManager = class {
    * Connect to shared database with retry logic
    */
   async connectSharedWithRetry() {
-    const maxAttempts = this.retryConfig.maxAttempts;
-    const result = await withRetry(
+    const retryConfig = this.retryHandler.getConfig();
+    const maxAttempts = retryConfig.maxAttempts;
+    const result = await this.retryHandler.withRetry(
       async () => {
         const pool = new Pool({
           connectionString: this.config.connection.url,
@@ -9674,10 +10067,9 @@ var PoolManager = class {
         }
       },
       {
-        ...this.retryConfig,
         onRetry: (attempt, error, delayMs) => {
           this.debugLogger.logConnectionRetry("shared", attempt, maxAttempts, error, delayMs);
-          this.retryConfig.onRetry?.(attempt, error, delayMs);
+          retryConfig.onRetry?.(attempt, error, delayMs);
         }
       }
     );
@@ -9695,13 +10087,13 @@ var PoolManager = class {
    */
   hasPool(tenantId) {
     const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    return this.pools.has(schemaName);
+    return this.poolCache.has(schemaName);
   }
   /**
    * Get count of active pools
    */
   getPoolCount() {
-    return this.pools.size;
+    return this.poolCache.size();
   }
   /**
    * Get all active tenant IDs
@@ -9713,7 +10105,7 @@ var PoolManager = class {
    * Get the retry configuration
    */
   getRetryConfig() {
-    return { ...this.retryConfig };
+    return this.retryHandler.getConfig();
   }
   /**
    * Pre-warm pools for specified tenants to reduce cold start latency
@@ -9772,15 +10164,97 @@ var PoolManager = class {
       details: results
     };
   }
+  /**
+   * Get current metrics for all pools
+   *
+   * Collects metrics on demand with zero overhead when not called.
+   * Returns raw data that can be formatted for any monitoring system.
+   *
+   * @example
+   * ```typescript
+   * const metrics = manager.getMetrics();
+   * console.log(metrics.pools.total); // 15
+   *
+   * // Format for Prometheus
+   * for (const pool of metrics.pools.tenants) {
+   *   gauge.labels(pool.tenantId).set(pool.connections.idle);
+   * }
+   * ```
+   */
+  getMetrics() {
+    this.ensureNotDisposed();
+    const maxPools = this.config.isolation.maxPools ?? DEFAULT_CONFIG.maxPools;
+    const tenantMetrics = [];
+    for (const [schemaName, entry] of this.poolCache.entries()) {
+      const tenantId = this.tenantIdBySchema.get(schemaName) ?? schemaName;
+      const pool = entry.pool;
+      tenantMetrics.push({
+        tenantId,
+        schemaName,
+        connections: {
+          total: pool.totalCount,
+          idle: pool.idleCount,
+          waiting: pool.waitingCount
+        },
+        lastAccessedAt: new Date(entry.lastAccess).toISOString()
+      });
+    }
+    return {
+      pools: {
+        total: tenantMetrics.length,
+        maxPools,
+        tenants: tenantMetrics
+      },
+      shared: {
+        initialized: this.sharedPool !== null,
+        connections: this.sharedPool ? {
+          total: this.sharedPool.totalCount,
+          idle: this.sharedPool.idleCount,
+          waiting: this.sharedPool.waitingCount
+        } : null
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Check health of all pools and connections
+   *
+   * Verifies the health of tenant pools and optionally the shared database.
+   * Returns detailed status information for monitoring and load balancer integration.
+   *
+   * @example
+   * ```typescript
+   * // Basic health check
+   * const health = await manager.healthCheck();
+   * console.log(health.healthy); // true/false
+   *
+   * // Use with Express endpoint
+   * app.get('/health', async (req, res) => {
+   *   const health = await manager.healthCheck();
+   *   res.status(health.healthy ? 200 : 503).json(health);
+   * });
+   *
+   * // Check specific tenants only
+   * const health = await manager.healthCheck({
+   *   tenantIds: ['tenant-1', 'tenant-2'],
+   *   ping: true,
+   *   pingTimeoutMs: 3000,
+   * });
+   * ```
+   */
+  async healthCheck(options = {}) {
+    this.ensureNotDisposed();
+    return this.healthChecker.checkHealth(options);
+  }
   /**
    * Manually evict a tenant pool
    */
   async evictPool(tenantId, reason = "manual") {
     const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    const entry = this.pools.get(schemaName);
+    const entry = this.poolCache.get(schemaName);
     if (entry) {
       this.debugLogger.logPoolEvicted(tenantId, schemaName, reason);
-      this.pools.delete(schemaName);
+      this.poolCache.delete(schemaName);
       this.tenantIdBySchema.delete(schemaName);
       await this.closePool(entry.pool, tenantId);
     }
@@ -9790,10 +10264,9 @@ var PoolManager = class {
    */
   startCleanup() {
     if (this.cleanupInterval) return;
-    const poolTtlMs = this.config.isolation.poolTtlMs ?? DEFAULT_CONFIG.poolTtlMs;
     const cleanupIntervalMs = DEFAULT_CONFIG.cleanupIntervalMs;
     this.cleanupInterval = setInterval(() => {
-      void this.cleanupIdlePools(poolTtlMs);
+      void this.cleanupIdlePools();
     }, cleanupIntervalMs);
     this.cleanupInterval.unref();
   }
@@ -9814,11 +10287,11 @@ var PoolManager = class {
     this.disposed = true;
     this.stopCleanup();
     const closePromises = [];
-    for (const [schemaName, entry] of this.pools.entries()) {
+    for (const [schemaName, entry] of this.poolCache.entries()) {
       const tenantId = this.tenantIdBySchema.get(schemaName);
       closePromises.push(this.closePool(entry.pool, tenantId ?? schemaName));
     }
-    this.pools.clear();
+    await this.poolCache.clear();
     this.tenantIdBySchema.clear();
     if (this.sharedPool) {
       closePromises.push(this.closePool(this.sharedPool, "shared"));
@@ -9880,18 +10353,13 @@ var PoolManager = class {
   /**
    * Cleanup pools that have been idle for too long
    */
-  async cleanupIdlePools(poolTtlMs) {
-    const now = Date.now();
-    const toEvict = [];
-    for (const [schemaName, entry] of this.pools.entries()) {
-      if (now - entry.lastAccess > poolTtlMs) {
-        toEvict.push(schemaName);
-      }
-    }
-    for (const schemaName of toEvict) {
+  async cleanupIdlePools() {
+    const evictedSchemas = await this.poolCache.evictExpired();
+    for (const schemaName of evictedSchemas) {
       const tenantId = this.tenantIdBySchema.get(schemaName);
       if (tenantId) {
-        await this.evictPool(tenantId, "ttl_expired");
+        this.debugLogger.logPoolEvicted(tenantId, schemaName, "ttl_expired");
+        this.tenantIdBySchema.delete(schemaName);
       }
     }
   }
@@ -9943,6 +10411,12 @@ function createTenantManager(config) {
     async warmup(tenantIds, options) {
       return poolManager.warmup(tenantIds, options);
     },
+    async healthCheck(options) {
+      return poolManager.healthCheck(options);
+    },
+    getMetrics() {
+      return poolManager.getMetrics();
+    },
     async dispose() {
       await poolManager.dispose();
     }