drizzle-multitenant 1.0.9 → 1.1.0

package/dist/integrations/express.d.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction, RequestHandler } from 'express';
-import { T as TenantManager } from '../types-B5eSRLFW.js';
-import { T as TenantContextData, a as TenantContext } from '../context-DoHx79MS.js';
-export { c as createTenantContext } from '../context-DoHx79MS.js';
+import { T as TenantManager } from '../types-BhK96FPC.js';
+import { T as TenantContextData, a as TenantContext } from '../context-Vki959ri.js';
+export { c as createTenantContext } from '../context-Vki959ri.js';
 import 'pg';
 import 'drizzle-orm/node-postgres';
 

package/dist/integrations/fastify.d.ts

@@ -1,7 +1,7 @@
 import { FastifyRequest, FastifyReply, FastifyPluginAsync } from 'fastify';
-import { T as TenantManager } from '../types-B5eSRLFW.js';
-import { T as TenantContextData, a as TenantContext } from '../context-DoHx79MS.js';
-export { c as createTenantContext } from '../context-DoHx79MS.js';
+import { T as TenantManager } from '../types-BhK96FPC.js';
+import { T as TenantContextData, a as TenantContext } from '../context-Vki959ri.js';
+export { c as createTenantContext } from '../context-Vki959ri.js';
 import 'pg';
 import 'drizzle-orm/node-postgres';
 

package/dist/integrations/nestjs/index.d.ts

@@ -1,7 +1,7 @@
 import * as _nestjs_common from '@nestjs/common';
 import { ModuleMetadata, Type, InjectionToken, DynamicModule, CanActivate, ExecutionContext, NestInterceptor, CallHandler, Provider } from '@nestjs/common';
 import { Request } from 'express';
-import { C as Config, a as TenantDb, T as TenantManager, S as SharedDb } from '../../types-B5eSRLFW.js';
+import { C as Config, a as TenantDb, T as TenantManager, S as SharedDb } from '../../types-BhK96FPC.js';
 import { Reflector } from '@nestjs/core';
 import { Observable } from 'rxjs';
 import 'pg';

package/dist/integrations/nestjs/index.js

@@ -9772,6 +9772,227 @@ 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.pools.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();
+    const startTime = Date.now();
+    const {
+      ping = true,
+      pingTimeoutMs = 5e3,
+      includeShared = true,
+      tenantIds
+    } = options;
+    const poolHealthResults = [];
+    let sharedDbStatus = "ok";
+    let sharedDbResponseTimeMs;
+    let sharedDbError;
+    const poolsToCheck = [];
+    if (tenantIds && tenantIds.length > 0) {
+      for (const tenantId of tenantIds) {
+        const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
+        const entry = this.pools.get(schemaName);
+        if (entry) {
+          poolsToCheck.push({ schemaName, tenantId, entry });
+        }
+      }
+    } else {
+      for (const [schemaName, entry] of this.pools.entries()) {
+        const tenantId = this.tenantIdBySchema.get(schemaName) ?? schemaName;
+        poolsToCheck.push({ schemaName, tenantId, entry });
+      }
+    }
+    const poolChecks = poolsToCheck.map(async ({ schemaName, tenantId, entry }) => {
+      const poolHealth = await this.checkPoolHealth(tenantId, schemaName, entry, ping, pingTimeoutMs);
+      return poolHealth;
+    });
+    poolHealthResults.push(...await Promise.all(poolChecks));
+    if (includeShared && this.sharedPool) {
+      const sharedResult = await this.checkSharedDbHealth(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";
+    return {
+      healthy,
+      pools: poolHealthResults,
+      sharedDb: sharedDbStatus,
+      sharedDbResponseTimeMs,
+      sharedDbError,
+      totalPools: poolHealthResults.length,
+      degradedPools,
+      unhealthyPools,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - startTime
+    };
+  }
+  /**
+   * 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";
+        }
+      }
+    }
+    return {
+      tenantId,
+      schemaName,
+      status,
+      totalConnections,
+      idleConnections,
+      waitingRequests,
+      responseTimeMs,
+      error
+    };
+  }
+  /**
+   * Check health of shared database
+   */
+  async checkSharedDbHealth(ping, pingTimeoutMs) {
+    if (!this.sharedPool) {
+      return { status: "ok" };
+    }
+    let status = "ok";
+    let responseTimeMs;
+    let error;
+    const waitingRequests = this.sharedPool.waitingCount;
+    if (waitingRequests > 0) {
+      status = "degraded";
+    }
+    if (ping) {
+      const pingResult = await this.executePingQuery(this.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";
+        }
+      }
+    }
+    return { status, responseTimeMs, error };
+  }
+  /**
+   * Execute a ping query with timeout
+   */
+  async executePingQuery(pool, timeoutMs) {
+    const startTime = Date.now();
+    try {
+      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 {
+        success: true,
+        responseTimeMs: Date.now() - startTime
+      };
+    } catch (err) {
+      return {
+        success: false,
+        responseTimeMs: Date.now() - startTime,
+        error: err.message
+      };
+    }
+  }
   /**
    * Manually evict a tenant pool
    */
@@ -9943,6 +10164,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();
     }