drizzle-multitenant 1.0.8 → 1.0.9

package/dist/integrations/express.d.ts

@@ -1,7 +1,7 @@
 import { Request, Response, NextFunction, RequestHandler } from 'express';
-import { T as TenantManager } from '../types-DKVaTaIb.js';
-import { T as TenantContextData, a as TenantContext } from '../context-DBerWr50.js';
-export { c as createTenantContext } from '../context-DBerWr50.js';
+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 '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-DKVaTaIb.js';
-import { T as TenantContextData, a as TenantContext } from '../context-DBerWr50.js';
-export { c as createTenantContext } from '../context-DBerWr50.js';
+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 '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-DKVaTaIb.js';
+import { C as Config, a as TenantDb, T as TenantManager, S as SharedDb } from '../../types-B5eSRLFW.js';
 import { Reflector } from '@nestjs/core';
 import { Observable } from 'rxjs';
 import 'pg';

package/dist/integrations/nestjs/index.js

@@ -9225,14 +9225,265 @@ var DEFAULT_CONFIG = {
     max: 10,
     idleTimeoutMillis: 3e4,
     connectionTimeoutMillis: 5e3
+  },
+  retry: {
+    maxAttempts: 3,
+    initialDelayMs: 100,
+    maxDelayMs: 5e3,
+    backoffMultiplier: 2,
+    jitter: true
   }
 };
 
+// src/debug.ts
+var PREFIX = "[drizzle-multitenant]";
+var DEFAULT_SLOW_QUERY_THRESHOLD = 1e3;
+var DebugLogger = class {
+  enabled;
+  logQueries;
+  logPoolEvents;
+  slowQueryThreshold;
+  logger;
+  constructor(config) {
+    this.enabled = config?.enabled ?? false;
+    this.logQueries = config?.logQueries ?? true;
+    this.logPoolEvents = config?.logPoolEvents ?? true;
+    this.slowQueryThreshold = config?.slowQueryThreshold ?? DEFAULT_SLOW_QUERY_THRESHOLD;
+    this.logger = config?.logger ?? this.defaultLogger;
+  }
+  /**
+   * Check if debug mode is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Log a query execution
+   */
+  logQuery(tenantId, query, durationMs) {
+    if (!this.enabled || !this.logQueries) return;
+    const isSlowQuery = durationMs >= this.slowQueryThreshold;
+    const type = isSlowQuery ? "slow_query" : "query";
+    const context = {
+      type,
+      tenantId,
+      query: this.truncateQuery(query),
+      durationMs
+    };
+    if (isSlowQuery) {
+      this.logger(
+        `${PREFIX} tenant=${tenantId} SLOW_QUERY duration=${durationMs}ms query="${this.truncateQuery(query)}"`,
+        context
+      );
+    } else {
+      this.logger(
+        `${PREFIX} tenant=${tenantId} query="${this.truncateQuery(query)}" duration=${durationMs}ms`,
+        context
+      );
+    }
+  }
+  /**
+   * Log pool creation
+   */
+  logPoolCreated(tenantId, schemaName) {
+    if (!this.enabled || !this.logPoolEvents) return;
+    const context = {
+      type: "pool_created",
+      tenantId,
+      schemaName
+    };
+    this.logger(
+      `${PREFIX} tenant=${tenantId} POOL_CREATED schema=${schemaName}`,
+      context
+    );
+  }
+  /**
+   * Log pool eviction
+   */
+  logPoolEvicted(tenantId, schemaName, reason) {
+    if (!this.enabled || !this.logPoolEvents) return;
+    const context = {
+      type: "pool_evicted",
+      tenantId,
+      schemaName,
+      metadata: reason ? { reason } : void 0
+    };
+    const reasonStr = reason ? ` reason=${reason}` : "";
+    this.logger(
+      `${PREFIX} tenant=${tenantId} POOL_EVICTED schema=${schemaName}${reasonStr}`,
+      context
+    );
+  }
+  /**
+   * Log pool error
+   */
+  logPoolError(tenantId, error) {
+    if (!this.enabled || !this.logPoolEvents) return;
+    const context = {
+      type: "pool_error",
+      tenantId,
+      error: error.message
+    };
+    this.logger(
+      `${PREFIX} tenant=${tenantId} POOL_ERROR error="${error.message}"`,
+      context
+    );
+  }
+  /**
+   * Log warmup event
+   */
+  logWarmup(tenantId, success, durationMs, alreadyWarm) {
+    if (!this.enabled || !this.logPoolEvents) return;
+    const context = {
+      type: "warmup",
+      tenantId,
+      durationMs,
+      metadata: { success, alreadyWarm }
+    };
+    const status = alreadyWarm ? "already_warm" : success ? "success" : "failed";
+    this.logger(
+      `${PREFIX} tenant=${tenantId} WARMUP status=${status} duration=${durationMs}ms`,
+      context
+    );
+  }
+  /**
+   * Log connection retry event
+   */
+  logConnectionRetry(identifier, attempt, maxAttempts, error, delayMs) {
+    if (!this.enabled || !this.logPoolEvents) return;
+    const context = {
+      type: "connection_retry",
+      tenantId: identifier,
+      error: error.message,
+      metadata: { attempt, maxAttempts, delayMs }
+    };
+    this.logger(
+      `${PREFIX} tenant=${identifier} CONNECTION_RETRY attempt=${attempt}/${maxAttempts} delay=${delayMs}ms error="${error.message}"`,
+      context
+    );
+  }
+  /**
+   * Log connection success after retries
+   */
+  logConnectionSuccess(identifier, attempts, totalTimeMs) {
+    if (!this.enabled || !this.logPoolEvents) return;
+    const context = {
+      type: "pool_created",
+      tenantId: identifier,
+      durationMs: totalTimeMs,
+      metadata: { attempts }
+    };
+    if (attempts > 1) {
+      this.logger(
+        `${PREFIX} tenant=${identifier} CONNECTION_SUCCESS attempts=${attempts} totalTime=${totalTimeMs}ms`,
+        context
+      );
+    }
+  }
+  /**
+   * Log a custom debug message
+   */
+  log(message, context) {
+    if (!this.enabled) return;
+    this.logger(`${PREFIX} ${message}`, context);
+  }
+  /**
+   * Default logger implementation using console
+   */
+  defaultLogger(message, _context) {
+    console.log(message);
+  }
+  /**
+   * Truncate long queries for readability
+   */
+  truncateQuery(query, maxLength = 100) {
+    const normalized = query.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength) {
+      return normalized;
+    }
+    return normalized.substring(0, maxLength - 3) + "...";
+  }
+};
+function createDebugLogger(config) {
+  return new DebugLogger(config);
+}
+
+// src/retry.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")) {
+    return true;
+  }
+  if (message.includes("too many connections") || message.includes("sorry, too many clients") || message.includes("the database system is starting up") || message.includes("the database system is shutting down") || message.includes("server closed the connection unexpectedly") || message.includes("could not connect to server")) {
+    return true;
+  }
+  if (message.includes("ssl connection") || message.includes("ssl handshake")) {
+    return true;
+  }
+  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++) {
+    try {
+      const result = await operation();
+      return {
+        result,
+        attempts: attempt + 1,
+        totalTimeMs: Date.now() - startTime
+      };
+    } 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");
+}
+
 // src/pool.ts
 var PoolManager = class {
   constructor(config) {
     this.config = config;
     const maxPools = config.isolation.maxPools ?? DEFAULT_CONFIG.maxPools;
+    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) => {
@@ -9243,10 +9494,14 @@ var PoolManager = class {
   }
   pools;
   tenantIdBySchema = /* @__PURE__ */ new Map();
+  pendingConnections = /* @__PURE__ */ new Map();
   sharedPool = null;
   sharedDb = null;
+  sharedDbPending = null;
   cleanupInterval = null;
   disposed = false;
+  debugLogger;
+  retryConfig;
   /**
    * Get or create a database connection for a tenant
    */
@@ -9258,11 +9513,85 @@ var PoolManager = class {
       entry = this.createPoolEntry(tenantId, schemaName);
       this.pools.set(schemaName, entry);
       this.tenantIdBySchema.set(schemaName, tenantId);
+      this.debugLogger.logPoolCreated(tenantId, schemaName);
       void this.config.hooks?.onPoolCreated?.(tenantId);
     }
     entry.lastAccess = Date.now();
     return entry.db;
   }
+  /**
+   * Get or create a database connection for a tenant with retry and validation
+   *
+   * This async version validates the connection by executing a ping query
+   * and retries on transient failures with exponential backoff.
+   *
+   * @example
+   * ```typescript
+   * // Get tenant database with automatic retry
+   * const db = await manager.getDbAsync('tenant-123');
+   *
+   * // Queries will use the validated connection
+   * const users = await db.select().from(users);
+   * ```
+   */
+  async getDbAsync(tenantId) {
+    this.ensureNotDisposed();
+    const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
+    let entry = this.pools.get(schemaName);
+    if (entry) {
+      entry.lastAccess = Date.now();
+      return entry.db;
+    }
+    const pending = this.pendingConnections.get(schemaName);
+    if (pending) {
+      entry = await pending;
+      entry.lastAccess = Date.now();
+      return entry.db;
+    }
+    const connectionPromise = this.connectWithRetry(tenantId, schemaName);
+    this.pendingConnections.set(schemaName, connectionPromise);
+    try {
+      entry = await connectionPromise;
+      this.pools.set(schemaName, entry);
+      this.tenantIdBySchema.set(schemaName, tenantId);
+      this.debugLogger.logPoolCreated(tenantId, schemaName);
+      void this.config.hooks?.onPoolCreated?.(tenantId);
+      entry.lastAccess = Date.now();
+      return entry.db;
+    } finally {
+      this.pendingConnections.delete(schemaName);
+    }
+  }
+  /**
+   * Connect to a tenant database with retry logic
+   */
+  async connectWithRetry(tenantId, schemaName) {
+    const maxAttempts = this.retryConfig.maxAttempts;
+    const result = await withRetry(
+      async () => {
+        const entry = this.createPoolEntry(tenantId, schemaName);
+        try {
+          await entry.pool.query("SELECT 1");
+          return entry;
+        } catch (error) {
+          try {
+            await entry.pool.end();
+          } catch {
+          }
+          throw error;
+        }
+      },
+      {
+        ...this.retryConfig,
+        onRetry: (attempt, error, delayMs) => {
+          this.debugLogger.logConnectionRetry(tenantId, attempt, maxAttempts, error, delayMs);
+          this.retryConfig.onRetry?.(attempt, error, delayMs);
+        }
+      }
+    );
+    this.debugLogger.logConnectionSuccess(tenantId, result.attempts, result.totalTimeMs);
+    return result.result;
+  }
   /**
    * Get or create the shared database connection
    */
@@ -9283,6 +9612,78 @@ var PoolManager = class {
     }
     return this.sharedDb;
   }
+  /**
+   * Get or create the shared database connection with retry and validation
+   *
+   * This async version validates the connection by executing a ping query
+   * and retries on transient failures with exponential backoff.
+   *
+   * @example
+   * ```typescript
+   * // Get shared database with automatic retry
+   * const sharedDb = await manager.getSharedDbAsync();
+   *
+   * // Queries will use the validated connection
+   * const plans = await sharedDb.select().from(plans);
+   * ```
+   */
+  async getSharedDbAsync() {
+    this.ensureNotDisposed();
+    if (this.sharedDb) {
+      return this.sharedDb;
+    }
+    if (this.sharedDbPending) {
+      return this.sharedDbPending;
+    }
+    this.sharedDbPending = this.connectSharedWithRetry();
+    try {
+      const db = await this.sharedDbPending;
+      return db;
+    } finally {
+      this.sharedDbPending = null;
+    }
+  }
+  /**
+   * Connect to shared database with retry logic
+   */
+  async connectSharedWithRetry() {
+    const maxAttempts = this.retryConfig.maxAttempts;
+    const result = await withRetry(
+      async () => {
+        const pool = new Pool({
+          connectionString: this.config.connection.url,
+          ...DEFAULT_CONFIG.poolConfig,
+          ...this.config.connection.poolConfig
+        });
+        try {
+          await pool.query("SELECT 1");
+          pool.on("error", (err) => {
+            void this.config.hooks?.onError?.("shared", err);
+          });
+          this.sharedPool = pool;
+          this.sharedDb = drizzle(pool, {
+            schema: this.config.schemas.shared
+          });
+          return this.sharedDb;
+        } catch (error) {
+          try {
+            await pool.end();
+          } catch {
+          }
+          throw error;
+        }
+      },
+      {
+        ...this.retryConfig,
+        onRetry: (attempt, error, delayMs) => {
+          this.debugLogger.logConnectionRetry("shared", attempt, maxAttempts, error, delayMs);
+          this.retryConfig.onRetry?.(attempt, error, delayMs);
+        }
+      }
+    );
+    this.debugLogger.logConnectionSuccess("shared", result.attempts, result.totalTimeMs);
+    return result.result;
+  }
   /**
    * Get schema name for a tenant
    */
@@ -9308,13 +9709,77 @@ var PoolManager = class {
   getActiveTenantIds() {
     return Array.from(this.tenantIdBySchema.values());
   }
+  /**
+   * Get the retry configuration
+   */
+  getRetryConfig() {
+    return { ...this.retryConfig };
+  }
+  /**
+   * Pre-warm pools for specified tenants to reduce cold start latency
+   *
+   * Uses automatic retry with exponential backoff for connection failures.
+   */
+  async warmup(tenantIds, options = {}) {
+    this.ensureNotDisposed();
+    const startTime = Date.now();
+    const { concurrency = 10, ping = true, onProgress } = options;
+    const results = [];
+    for (let i = 0; i < tenantIds.length; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          const tenantStart = Date.now();
+          onProgress?.(tenantId, "starting");
+          try {
+            const alreadyWarm = this.hasPool(tenantId);
+            if (ping) {
+              await this.getDbAsync(tenantId);
+            } else {
+              this.getDb(tenantId);
+            }
+            const durationMs = Date.now() - tenantStart;
+            onProgress?.(tenantId, "completed");
+            this.debugLogger.logWarmup(tenantId, true, durationMs, alreadyWarm);
+            return {
+              tenantId,
+              success: true,
+              alreadyWarm,
+              durationMs
+            };
+          } catch (error) {
+            const durationMs = Date.now() - tenantStart;
+            onProgress?.(tenantId, "failed");
+            this.debugLogger.logWarmup(tenantId, false, durationMs, false);
+            return {
+              tenantId,
+              success: false,
+              alreadyWarm: false,
+              durationMs,
+              error: error.message
+            };
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return {
+      total: results.length,
+      succeeded: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success).length,
+      alreadyWarm: results.filter((r) => r.alreadyWarm).length,
+      durationMs: Date.now() - startTime,
+      details: results
+    };
+  }
   /**
    * Manually evict a tenant pool
    */
-  async evictPool(tenantId) {
+  async evictPool(tenantId, reason = "manual") {
     const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
     const entry = this.pools.get(schemaName);
     if (entry) {
+      this.debugLogger.logPoolEvicted(tenantId, schemaName, reason);
       this.pools.delete(schemaName);
       this.tenantIdBySchema.delete(schemaName);
       await this.closePool(entry.pool, tenantId);
@@ -9373,8 +9838,9 @@ var PoolManager = class {
       options: `-c search_path=${schemaName},public`
     });
     pool.on("error", async (err) => {
+      this.debugLogger.logPoolError(tenantId, err);
       void this.config.hooks?.onError?.(tenantId, err);
-      await this.evictPool(tenantId);
+      await this.evictPool(tenantId, "error");
     });
     const db = drizzle(pool, {
       schema: this.config.schemas.tenant
@@ -9392,6 +9858,9 @@ var PoolManager = class {
   disposePoolEntry(entry, schemaName) {
     const tenantId = this.tenantIdBySchema.get(schemaName);
     this.tenantIdBySchema.delete(schemaName);
+    if (tenantId) {
+      this.debugLogger.logPoolEvicted(tenantId, schemaName, "lru_eviction");
+    }
     void this.closePool(entry.pool, tenantId ?? schemaName).then(() => {
       if (tenantId) {
         void this.config.hooks?.onPoolEvicted?.(tenantId);
@@ -9422,7 +9891,7 @@ var PoolManager = class {
     for (const schemaName of toEvict) {
       const tenantId = this.tenantIdBySchema.get(schemaName);
       if (tenantId) {
-        await this.evictPool(tenantId);
+        await this.evictPool(tenantId, "ttl_expired");
       }
     }
   }
@@ -9444,9 +9913,15 @@ function createTenantManager(config) {
     getDb(tenantId) {
       return poolManager.getDb(tenantId);
     },
+    async getDbAsync(tenantId) {
+      return poolManager.getDbAsync(tenantId);
+    },
     getSharedDb() {
       return poolManager.getSharedDb();
     },
+    async getSharedDbAsync() {
+      return poolManager.getSharedDbAsync();
+    },
     getSchemaName(tenantId) {
       return poolManager.getSchemaName(tenantId);
     },
@@ -9459,9 +9934,15 @@ function createTenantManager(config) {
     getActiveTenantIds() {
       return poolManager.getActiveTenantIds();
     },
+    getRetryConfig() {
+      return poolManager.getRetryConfig();
+    },
     async evictPool(tenantId) {
       await poolManager.evictPool(tenantId);
     },
+    async warmup(tenantIds, options) {
+      return poolManager.warmup(tenantIds, options);
+    },
     async dispose() {
       await poolManager.dispose();
     }