drizzle-multitenant 1.1.0 → 1.3.0

package/dist/index.js

@@ -1,2442 +1,154 @@
-import { Pool } from 'pg';
-import { drizzle } from 'drizzle-orm/node-postgres';
-import { LRUCache } from 'lru-cache';
-import { AsyncLocalStorage } from 'async_hooks';
-import { readdir, readFile } from 'fs/promises';
-import { join, basename } from 'path';
-import { createHash } from 'crypto';
-import { sql, getTableName } from 'drizzle-orm';
-
-// src/config.ts
-function defineConfig(config) {
-  validateConfig(config);
-  return config;
-}
-function validateConfig(config) {
-  if (!config.connection.url) {
-    throw new Error("[drizzle-multitenant] connection.url is required");
-  }
-  if (!config.isolation.strategy) {
-    throw new Error("[drizzle-multitenant] isolation.strategy is required");
-  }
-  if (config.isolation.strategy !== "schema") {
-    throw new Error(
-      `[drizzle-multitenant] isolation.strategy "${config.isolation.strategy}" is not yet supported. Only "schema" is currently available.`
-    );
-  }
-  if (!config.isolation.schemaNameTemplate) {
-    throw new Error("[drizzle-multitenant] isolation.schemaNameTemplate is required");
-  }
-  if (typeof config.isolation.schemaNameTemplate !== "function") {
-    throw new Error("[drizzle-multitenant] isolation.schemaNameTemplate must be a function");
-  }
-  if (!config.schemas.tenant) {
-    throw new Error("[drizzle-multitenant] schemas.tenant is required");
-  }
-  if (config.isolation.maxPools !== void 0 && config.isolation.maxPools < 1) {
-    throw new Error("[drizzle-multitenant] isolation.maxPools must be at least 1");
-  }
-  if (config.isolation.poolTtlMs !== void 0 && config.isolation.poolTtlMs < 0) {
-    throw new Error("[drizzle-multitenant] isolation.poolTtlMs must be non-negative");
-  }
-  if (config.connection.retry) {
-    const retry = config.connection.retry;
-    if (retry.maxAttempts !== void 0 && retry.maxAttempts < 1) {
-      throw new Error("[drizzle-multitenant] connection.retry.maxAttempts must be at least 1");
-    }
-    if (retry.initialDelayMs !== void 0 && retry.initialDelayMs < 0) {
-      throw new Error("[drizzle-multitenant] connection.retry.initialDelayMs must be non-negative");
-    }
-    if (retry.maxDelayMs !== void 0 && retry.maxDelayMs < 0) {
-      throw new Error("[drizzle-multitenant] connection.retry.maxDelayMs must be non-negative");
-    }
-    if (retry.backoffMultiplier !== void 0 && retry.backoffMultiplier < 1) {
-      throw new Error("[drizzle-multitenant] connection.retry.backoffMultiplier must be at least 1");
-    }
-    if (retry.initialDelayMs !== void 0 && retry.maxDelayMs !== void 0 && retry.initialDelayMs > retry.maxDelayMs) {
-      throw new Error(
-        "[drizzle-multitenant] connection.retry.initialDelayMs cannot be greater than maxDelayMs"
-      );
-    }
-  }
-}
-
-// src/types.ts
-var DEFAULT_CONFIG = {
-  maxPools: 50,
-  poolTtlMs: 60 * 60 * 1e3,
-  // 1 hour
-  cleanupIntervalMs: 6e4,
-  // 1 minute
-  poolConfig: {
-    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");
-}
-function createRetrier(config) {
-  return (operation) => {
-    return withRetry(operation, config);
-  };
-}
-
-// 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) => {
-        this.disposePoolEntry(entry, key);
-      },
-      noDisposeOnSet: true
-    });
-  }
-  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
-   */
-  getDb(tenantId) {
-    this.ensureNotDisposed();
-    const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    let entry = this.pools.get(schemaName);
-    if (!entry) {
-      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
-   */
-  getSharedDb() {
-    this.ensureNotDisposed();
-    if (!this.sharedDb) {
-      this.sharedPool = new Pool({
-        connectionString: this.config.connection.url,
-        ...DEFAULT_CONFIG.poolConfig,
-        ...this.config.connection.poolConfig
-      });
-      this.sharedPool.on("error", (err) => {
-        void this.config.hooks?.onError?.("shared", err);
-      });
-      this.sharedDb = drizzle(this.sharedPool, {
-        schema: this.config.schemas.shared
-      });
-    }
-    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
-   */
-  getSchemaName(tenantId) {
-    return this.config.isolation.schemaNameTemplate(tenantId);
-  }
-  /**
-   * Check if a pool exists for a tenant
-   */
-  hasPool(tenantId) {
-    const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
-    return this.pools.has(schemaName);
-  }
-  /**
-   * Get count of active pools
-   */
-  getPoolCount() {
-    return this.pools.size;
-  }
-  /**
-   * Get all active tenant IDs
-   */
-  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
-    };
-  }
-  /**
-   * 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
-   */
-  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);
-    }
-  }
-  /**
-   * Start automatic cleanup of idle pools
-   */
-  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);
-    }, cleanupIntervalMs);
-    this.cleanupInterval.unref();
-  }
-  /**
-   * Stop automatic cleanup
-   */
-  stopCleanup() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-  }
-  /**
-   * Dispose all pools and cleanup resources
-   */
-  async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.stopCleanup();
-    const closePromises = [];
-    for (const [schemaName, entry] of this.pools.entries()) {
-      const tenantId = this.tenantIdBySchema.get(schemaName);
-      closePromises.push(this.closePool(entry.pool, tenantId ?? schemaName));
-    }
-    this.pools.clear();
-    this.tenantIdBySchema.clear();
-    if (this.sharedPool) {
-      closePromises.push(this.closePool(this.sharedPool, "shared"));
-      this.sharedPool = null;
-      this.sharedDb = null;
-    }
-    await Promise.all(closePromises);
-  }
-  /**
-   * Create a new pool entry for a tenant
-   */
-  createPoolEntry(tenantId, schemaName) {
-    const pool = new Pool({
-      connectionString: this.config.connection.url,
-      ...DEFAULT_CONFIG.poolConfig,
-      ...this.config.connection.poolConfig,
-      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, "error");
-    });
-    const db = drizzle(pool, {
-      schema: this.config.schemas.tenant
-    });
-    return {
-      db,
-      pool,
-      lastAccess: Date.now(),
-      schemaName
-    };
-  }
-  /**
-   * Dispose a pool entry (called by LRU cache)
-   */
-  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);
-      }
-    });
-  }
-  /**
-   * Close a pool gracefully
-   */
-  async closePool(pool, identifier) {
-    try {
-      await pool.end();
-    } catch (error) {
-      void this.config.hooks?.onError?.(identifier, error);
-    }
-  }
-  /**
-   * 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) {
-      const tenantId = this.tenantIdBySchema.get(schemaName);
-      if (tenantId) {
-        await this.evictPool(tenantId, "ttl_expired");
-      }
-    }
-  }
-  /**
-   * Ensure the manager hasn't been disposed
-   */
-  ensureNotDisposed() {
-    if (this.disposed) {
-      throw new Error("[drizzle-multitenant] TenantManager has been disposed");
-    }
-  }
-};
-
-// src/manager.ts
-function createTenantManager(config) {
-  const poolManager = new PoolManager(config);
-  poolManager.startCleanup();
-  return {
-    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);
-    },
-    hasPool(tenantId) {
-      return poolManager.hasPool(tenantId);
-    },
-    getPoolCount() {
-      return poolManager.getPoolCount();
-    },
-    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 healthCheck(options) {
-      return poolManager.healthCheck(options);
-    },
-    getMetrics() {
-      return poolManager.getMetrics();
-    },
-    async dispose() {
-      await poolManager.dispose();
-    }
-  };
-}
-function createTenantContext(manager) {
-  const storage = new AsyncLocalStorage();
-  function getTenantOrNull() {
-    return storage.getStore();
-  }
-  function getTenant() {
-    const context = getTenantOrNull();
-    if (!context) {
-      throw new Error(
-        "[drizzle-multitenant] No tenant context found. Make sure you are calling this within runWithTenant()."
-      );
-    }
-    return context;
-  }
-  function getTenantId() {
-    return getTenant().tenantId;
-  }
-  function getTenantDb() {
-    const tenantId = getTenantId();
-    return manager.getDb(tenantId);
-  }
-  function getSharedDb() {
-    return manager.getSharedDb();
-  }
-  function isInTenantContext() {
-    return getTenantOrNull() !== void 0;
-  }
-  function runWithTenant(context, callback) {
-    if (!context.tenantId) {
-      throw new Error("[drizzle-multitenant] tenantId is required in context");
-    }
-    return storage.run(context, callback);
-  }
-  return {
-    runWithTenant,
-    getTenant,
-    getTenantOrNull,
-    getTenantId,
-    getTenantDb,
-    getSharedDb,
-    isInTenantContext
-  };
-}
-
-// src/migrator/table-format.ts
-async function detectTableFormat(pool, schemaName, tableName) {
-  const tableExists = await pool.query(
-    `SELECT EXISTS (
+import {Pool}from'pg';import {drizzle}from'drizzle-orm/node-postgres';import {LRUCache}from'lru-cache';import {AsyncLocalStorage}from'async_hooks';import {readdir,readFile}from'fs/promises';import {join,basename}from'path';import {createHash}from'crypto';import {existsSync}from'fs';import {sql,getTableName}from'drizzle-orm';function Se(c){return be(c),c}function be(c){if(!c.connection.url)throw new Error("[drizzle-multitenant] connection.url is required");if(!c.isolation.strategy)throw new Error("[drizzle-multitenant] isolation.strategy is required");if(c.isolation.strategy!=="schema")throw new Error(`[drizzle-multitenant] isolation.strategy "${c.isolation.strategy}" is not yet supported. Only "schema" is currently available.`);if(!c.isolation.schemaNameTemplate)throw new Error("[drizzle-multitenant] isolation.schemaNameTemplate is required");if(typeof c.isolation.schemaNameTemplate!="function")throw new Error("[drizzle-multitenant] isolation.schemaNameTemplate must be a function");if(!c.schemas.tenant)throw new Error("[drizzle-multitenant] schemas.tenant is required");if(c.isolation.maxPools!==void 0&&c.isolation.maxPools<1)throw new Error("[drizzle-multitenant] isolation.maxPools must be at least 1");if(c.isolation.poolTtlMs!==void 0&&c.isolation.poolTtlMs<0)throw new Error("[drizzle-multitenant] isolation.poolTtlMs must be non-negative");if(c.connection.retry){let e=c.connection.retry;if(e.maxAttempts!==void 0&&e.maxAttempts<1)throw new Error("[drizzle-multitenant] connection.retry.maxAttempts must be at least 1");if(e.initialDelayMs!==void 0&&e.initialDelayMs<0)throw new Error("[drizzle-multitenant] connection.retry.initialDelayMs must be non-negative");if(e.maxDelayMs!==void 0&&e.maxDelayMs<0)throw new Error("[drizzle-multitenant] connection.retry.maxDelayMs must be non-negative");if(e.backoffMultiplier!==void 0&&e.backoffMultiplier<1)throw new Error("[drizzle-multitenant] connection.retry.backoffMultiplier must be at least 1");if(e.initialDelayMs!==void 0&&e.maxDelayMs!==void 0&&e.initialDelayMs>e.maxDelayMs)throw new Error("[drizzle-multitenant] connection.retry.initialDelayMs cannot be greater than maxDelayMs")}}var T={maxPools:50,poolTtlMs:36e5,cleanupIntervalMs:6e4,poolConfig:{max:10,idleTimeoutMillis:3e4,connectionTimeoutMillis:5e3},retry:{maxAttempts:3,initialDelayMs:100,maxDelayMs:5e3,backoffMultiplier:2,jitter:true}};var R="[drizzle-multitenant]";var W=class{enabled;logQueries;logPoolEvents;slowQueryThreshold;logger;constructor(e){this.enabled=e?.enabled??false,this.logQueries=e?.logQueries??true,this.logPoolEvents=e?.logPoolEvents??true,this.slowQueryThreshold=e?.slowQueryThreshold??1e3,this.logger=e?.logger??this.defaultLogger;}isEnabled(){return this.enabled}logQuery(e,t,n){if(!this.enabled||!this.logQueries)return;let a=n>=this.slowQueryThreshold,s={type:a?"slow_query":"query",tenantId:e,query:this.truncateQuery(t),durationMs:n};a?this.logger(`${R} tenant=${e} SLOW_QUERY duration=${n}ms query="${this.truncateQuery(t)}"`,s):this.logger(`${R} tenant=${e} query="${this.truncateQuery(t)}" duration=${n}ms`,s);}logPoolCreated(e,t){if(!this.enabled||!this.logPoolEvents)return;let n={type:"pool_created",tenantId:e,schemaName:t};this.logger(`${R} tenant=${e} POOL_CREATED schema=${t}`,n);}logPoolEvicted(e,t,n){if(!this.enabled||!this.logPoolEvents)return;let a={type:"pool_evicted",tenantId:e,schemaName:t,metadata:n?{reason:n}:void 0},r=n?` reason=${n}`:"";this.logger(`${R} tenant=${e} POOL_EVICTED schema=${t}${r}`,a);}logPoolError(e,t){if(!this.enabled||!this.logPoolEvents)return;let n={type:"pool_error",tenantId:e,error:t.message};this.logger(`${R} tenant=${e} POOL_ERROR error="${t.message}"`,n);}logWarmup(e,t,n,a){if(!this.enabled||!this.logPoolEvents)return;let r={type:"warmup",tenantId:e,durationMs:n,metadata:{success:t,alreadyWarm:a}},s=a?"already_warm":t?"success":"failed";this.logger(`${R} tenant=${e} WARMUP status=${s} duration=${n}ms`,r);}logConnectionRetry(e,t,n,a,r){if(!this.enabled||!this.logPoolEvents)return;let s={type:"connection_retry",tenantId:e,error:a.message,metadata:{attempt:t,maxAttempts:n,delayMs:r}};this.logger(`${R} tenant=${e} CONNECTION_RETRY attempt=${t}/${n} delay=${r}ms error="${a.message}"`,s);}logConnectionSuccess(e,t,n){if(!this.enabled||!this.logPoolEvents)return;let a={type:"pool_created",tenantId:e,durationMs:n,metadata:{attempts:t}};t>1&&this.logger(`${R} tenant=${e} CONNECTION_SUCCESS attempts=${t} totalTime=${n}ms`,a);}log(e,t){this.enabled&&this.logger(`${R} ${e}`,t);}defaultLogger(e,t){console.log(e);}truncateQuery(e,t=100){let n=e.replace(/\s+/g," ").trim();return n.length<=t?n:n.substring(0,t-3)+"..."}};function G(c){return new W(c)}var x=class{cache;poolTtlMs;onDispose;constructor(e){this.poolTtlMs=e.poolTtlMs,this.onDispose=e.onDispose,this.cache=new LRUCache({max:e.maxPools,dispose:(t,n)=>{this.handleDispose(n,t);},noDisposeOnSet:true});}get(e){return this.cache.get(e)}set(e,t){this.cache.set(e,t);}has(e){return this.cache.has(e)}delete(e){return this.cache.delete(e)}size(){return this.cache.size}keys(){return Array.from(this.cache.keys())}*entries(){for(let[e,t]of this.cache.entries())yield [e,t];}async clear(){this.cache.clear(),await Promise.resolve();}evictLRU(){let e=Array.from(this.cache.keys());if(e.length===0)return;let t=e[e.length-1];return this.cache.delete(t),t}async evictExpired(){if(!this.poolTtlMs)return [];let e=Date.now(),t=[];for(let[n,a]of this.cache.entries())e-a.lastAccess>this.poolTtlMs&&t.push(n);for(let n of t)this.cache.delete(n);return t}touch(e){let t=this.cache.get(e);t&&(t.lastAccess=Date.now());}getMaxPools(){return this.cache.max}getTtlMs(){return this.poolTtlMs}isExpired(e){return this.poolTtlMs?Date.now()-e.lastAccess>this.poolTtlMs:false}async handleDispose(e,t){this.onDispose&&await this.onDispose(e,t);}};function J(c){let e=c.message.toLowerCase();return !!(e.includes("econnrefused")||e.includes("econnreset")||e.includes("etimedout")||e.includes("enotfound")||e.includes("connection refused")||e.includes("connection reset")||e.includes("connection terminated")||e.includes("connection timed out")||e.includes("timeout expired")||e.includes("socket hang up")||e.includes("too many connections")||e.includes("sorry, too many clients")||e.includes("the database system is starting up")||e.includes("the database system is shutting down")||e.includes("server closed the connection unexpectedly")||e.includes("could not connect to server")||e.includes("ssl connection")||e.includes("ssl handshake"))}function Me(c){return new Promise(e=>setTimeout(e,c))}var E=class{config;constructor(e){this.config={maxAttempts:e?.maxAttempts??T.retry.maxAttempts,initialDelayMs:e?.initialDelayMs??T.retry.initialDelayMs,maxDelayMs:e?.maxDelayMs??T.retry.maxDelayMs,backoffMultiplier:e?.backoffMultiplier??T.retry.backoffMultiplier,jitter:e?.jitter??T.retry.jitter,isRetryable:e?.isRetryable??J,onRetry:e?.onRetry};}async withRetry(e,t){let n=t?{...this.config,...t}:this.config,a=Date.now(),r=null;for(let s=0;s<n.maxAttempts;s++)try{return {result:await e(),attempts:s+1,totalTimeMs:Date.now()-a}}catch(i){r=i;let o=s>=n.maxAttempts-1,m=n.isRetryable??this.isRetryable;if(o||!m(r))throw r;let l=this.calculateDelay(s,n);n.onRetry?.(s+1,r,l),await Me(l);}throw r??new Error("Retry failed with no error")}calculateDelay(e,t){let n=t?{...this.config,...t}:this.config,a=n.initialDelayMs*Math.pow(n.backoffMultiplier,e),r=Math.min(a,n.maxDelayMs);if(n.jitter){let s=1+Math.random()*.25;return Math.floor(r*s)}return Math.floor(r)}isRetryable(e){return (this.config.isRetryable??J)(e)}getConfig(){return {...this.config}}getMaxAttempts(){return this.config.maxAttempts}};var P=class{constructor(e){this.deps=e;}async checkHealth(e={}){let t=Date.now(),{ping:n=true,pingTimeoutMs:a=5e3,includeShared:r=true,tenantIds:s}=e,i=[],o="ok",m,l,h=this.getPoolsToCheck(s).map(async({schemaName:S,tenantId:N,entry:M})=>this.checkPoolHealth(N,S,M,n,a));i.push(...await Promise.all(h));let d=this.deps.getSharedPool();if(r&&d){let S=await this.checkSharedDbHealth(d,n,a);o=S.status,m=S.responseTimeMs,l=S.error;}let g=i.filter(S=>S.status==="degraded").length,w=i.filter(S=>S.status==="unhealthy").length,b={healthy:w===0&&o!=="unhealthy",pools:i,sharedDb:o,totalPools:i.length,degradedPools:g,unhealthyPools:w,timestamp:new Date().toISOString(),durationMs:Date.now()-t};return m!==void 0&&(b.sharedDbResponseTimeMs=m),l!==void 0&&(b.sharedDbError=l),b}getPoolsToCheck(e){let t=[];if(e&&e.length>0)for(let n of e){let a=this.deps.getSchemaName(n),r=this.deps.getPoolEntry(a);r&&t.push({schemaName:a,tenantId:n,entry:r});}else for(let[n,a]of this.deps.getPoolEntries()){let r=this.deps.getTenantIdBySchema(n)??n;t.push({schemaName:n,tenantId:r,entry:a});}return t}async checkPoolHealth(e,t,n,a,r){let s=n.pool,i=s.totalCount,o=s.idleCount,m=s.waitingCount,l="ok",u,h;if(m>0&&(l="degraded"),a){let g=await this.executePingQuery(s,r);u=g.responseTimeMs,g.success?g.responseTimeMs&&g.responseTimeMs>r/2&&l==="ok"&&(l="degraded"):(l="unhealthy",h=g.error);}let d={tenantId:e,schemaName:t,status:l,totalConnections:i,idleConnections:o,waitingRequests:m};return u!==void 0&&(d.responseTimeMs=u),h!==void 0&&(d.error=h),d}async checkSharedDbHealth(e,t,n){let a="ok",r,s;if(e.waitingCount>0&&(a="degraded"),t){let m=await this.executePingQuery(e,n);r=m.responseTimeMs,m.success?m.responseTimeMs&&m.responseTimeMs>n/2&&a==="ok"&&(a="degraded"):(a="unhealthy",s=m.error);}let o={status:a};return r!==void 0&&(o.responseTimeMs=r),s!==void 0&&(o.error=s),o}async executePingQuery(e,t){let n=Date.now();try{let a=new Promise((s,i)=>{setTimeout(()=>i(new Error("Health check ping timeout")),t);}),r=e.query("SELECT 1");return await Promise.race([r,a]),{success:!0,responseTimeMs:Date.now()-n}}catch(a){return {success:false,responseTimeMs:Date.now()-n,error:a.message}}}determineOverallHealth(e,t="ok"){return e.filter(a=>a.status==="unhealthy").length===0&&t!=="unhealthy"}};var k=class{constructor(e){this.config=e;let t=e.isolation.maxPools??T.maxPools,n=e.isolation.poolTtlMs??T.poolTtlMs;this.debugLogger=G(e.debug),this.retryHandler=new E(e.connection.retry),this.poolCache=new x({maxPools:t,poolTtlMs:n,onDispose:(a,r)=>{this.disposePoolEntry(r,a);}}),this.healthChecker=new P({getPoolEntries:()=>this.poolCache.entries(),getTenantIdBySchema:a=>this.tenantIdBySchema.get(a),getPoolEntry:a=>this.poolCache.get(a),getSchemaName:a=>this.config.isolation.schemaNameTemplate(a),getSharedPool:()=>this.sharedPool});}poolCache;tenantIdBySchema=new Map;pendingConnections=new Map;sharedPool=null;sharedDb=null;sharedDbPending=null;cleanupInterval=null;disposed=false;debugLogger;retryHandler;healthChecker;getDb(e){this.ensureNotDisposed();let t=this.config.isolation.schemaNameTemplate(e),n=this.poolCache.get(t);return n||(n=this.createPoolEntry(e,t),this.poolCache.set(t,n),this.tenantIdBySchema.set(t,e),this.debugLogger.logPoolCreated(e,t),this.config.hooks?.onPoolCreated?.(e)),this.poolCache.touch(t),n.db}async getDbAsync(e){this.ensureNotDisposed();let t=this.config.isolation.schemaNameTemplate(e),n=this.poolCache.get(t);if(n)return this.poolCache.touch(t),n.db;let a=this.pendingConnections.get(t);if(a)return n=await a,this.poolCache.touch(t),n.db;let r=this.connectWithRetry(e,t);this.pendingConnections.set(t,r);try{return n=await r,this.poolCache.set(t,n),this.tenantIdBySchema.set(t,e),this.debugLogger.logPoolCreated(e,t),this.config.hooks?.onPoolCreated?.(e),this.poolCache.touch(t),n.db}finally{this.pendingConnections.delete(t);}}async connectWithRetry(e,t){let n=this.retryHandler.getConfig(),a=n.maxAttempts,r=await this.retryHandler.withRetry(async()=>{let s=this.createPoolEntry(e,t);try{return await s.pool.query("SELECT 1"),s}catch(i){try{await s.pool.end();}catch{}throw i}},{onRetry:(s,i,o)=>{this.debugLogger.logConnectionRetry(e,s,a,i,o),n.onRetry?.(s,i,o);}});return this.debugLogger.logConnectionSuccess(e,r.attempts,r.totalTimeMs),r.result}getSharedDb(){return this.ensureNotDisposed(),this.sharedDb||(this.sharedPool=new Pool({connectionString:this.config.connection.url,...T.poolConfig,...this.config.connection.poolConfig}),this.sharedPool.on("error",e=>{this.config.hooks?.onError?.("shared",e);}),this.sharedDb=drizzle(this.sharedPool,{schema:this.config.schemas.shared})),this.sharedDb}async getSharedDbAsync(){if(this.ensureNotDisposed(),this.sharedDb)return this.sharedDb;if(this.sharedDbPending)return this.sharedDbPending;this.sharedDbPending=this.connectSharedWithRetry();try{return await this.sharedDbPending}finally{this.sharedDbPending=null;}}async connectSharedWithRetry(){let e=this.retryHandler.getConfig(),t=e.maxAttempts,n=await this.retryHandler.withRetry(async()=>{let a=new Pool({connectionString:this.config.connection.url,...T.poolConfig,...this.config.connection.poolConfig});try{return await a.query("SELECT 1"),a.on("error",r=>{this.config.hooks?.onError?.("shared",r);}),this.sharedPool=a,this.sharedDb=drizzle(a,{schema:this.config.schemas.shared}),this.sharedDb}catch(r){try{await a.end();}catch{}throw r}},{onRetry:(a,r,s)=>{this.debugLogger.logConnectionRetry("shared",a,t,r,s),e.onRetry?.(a,r,s);}});return this.debugLogger.logConnectionSuccess("shared",n.attempts,n.totalTimeMs),n.result}getSchemaName(e){return this.config.isolation.schemaNameTemplate(e)}hasPool(e){let t=this.config.isolation.schemaNameTemplate(e);return this.poolCache.has(t)}getPoolCount(){return this.poolCache.size()}getActiveTenantIds(){return Array.from(this.tenantIdBySchema.values())}getRetryConfig(){return this.retryHandler.getConfig()}async warmup(e,t={}){this.ensureNotDisposed();let n=Date.now(),{concurrency:a=10,ping:r=true,onProgress:s}=t,i=[];for(let o=0;o<e.length;o+=a){let m=e.slice(o,o+a),l=await Promise.all(m.map(async u=>{let h=Date.now();s?.(u,"starting");try{let d=this.hasPool(u);r?await this.getDbAsync(u):this.getDb(u);let g=Date.now()-h;return s?.(u,"completed"),this.debugLogger.logWarmup(u,!0,g,d),{tenantId:u,success:!0,alreadyWarm:d,durationMs:g}}catch(d){let g=Date.now()-h;return s?.(u,"failed"),this.debugLogger.logWarmup(u,false,g,false),{tenantId:u,success:false,alreadyWarm:false,durationMs:g,error:d.message}}}));i.push(...l);}return {total:i.length,succeeded:i.filter(o=>o.success).length,failed:i.filter(o=>!o.success).length,alreadyWarm:i.filter(o=>o.alreadyWarm).length,durationMs:Date.now()-n,details:i}}getMetrics(){this.ensureNotDisposed();let e=this.config.isolation.maxPools??T.maxPools,t=[];for(let[n,a]of this.poolCache.entries()){let r=this.tenantIdBySchema.get(n)??n,s=a.pool;t.push({tenantId:r,schemaName:n,connections:{total:s.totalCount,idle:s.idleCount,waiting:s.waitingCount},lastAccessedAt:new Date(a.lastAccess).toISOString()});}return {pools:{total:t.length,maxPools:e,tenants:t},shared:{initialized:this.sharedPool!==null,connections:this.sharedPool?{total:this.sharedPool.totalCount,idle:this.sharedPool.idleCount,waiting:this.sharedPool.waitingCount}:null},timestamp:new Date().toISOString()}}async healthCheck(e={}){return this.ensureNotDisposed(),this.healthChecker.checkHealth(e)}async evictPool(e,t="manual"){let n=this.config.isolation.schemaNameTemplate(e),a=this.poolCache.get(n);a&&(this.debugLogger.logPoolEvicted(e,n,t),this.poolCache.delete(n),this.tenantIdBySchema.delete(n),await this.closePool(a.pool,e));}startCleanup(){if(this.cleanupInterval)return;let e=T.cleanupIntervalMs;this.cleanupInterval=setInterval(()=>{this.cleanupIdlePools();},e),this.cleanupInterval.unref();}stopCleanup(){this.cleanupInterval&&(clearInterval(this.cleanupInterval),this.cleanupInterval=null);}async dispose(){if(this.disposed)return;this.disposed=true,this.stopCleanup();let e=[];for(let[t,n]of this.poolCache.entries()){let a=this.tenantIdBySchema.get(t);e.push(this.closePool(n.pool,a??t));}await this.poolCache.clear(),this.tenantIdBySchema.clear(),this.sharedPool&&(e.push(this.closePool(this.sharedPool,"shared")),this.sharedPool=null,this.sharedDb=null),await Promise.all(e);}createPoolEntry(e,t){let n=new Pool({connectionString:this.config.connection.url,...T.poolConfig,...this.config.connection.poolConfig,options:`-c search_path=${t},public`});return n.on("error",async r=>{this.debugLogger.logPoolError(e,r),this.config.hooks?.onError?.(e,r),await this.evictPool(e,"error");}),{db:drizzle(n,{schema:this.config.schemas.tenant}),pool:n,lastAccess:Date.now(),schemaName:t}}disposePoolEntry(e,t){let n=this.tenantIdBySchema.get(t);this.tenantIdBySchema.delete(t),n&&this.debugLogger.logPoolEvicted(n,t,"lru_eviction"),this.closePool(e.pool,n??t).then(()=>{n&&this.config.hooks?.onPoolEvicted?.(n);});}async closePool(e,t){try{await e.end();}catch(n){this.config.hooks?.onError?.(t,n);}}async cleanupIdlePools(){let e=await this.poolCache.evictExpired();for(let t of e){let n=this.tenantIdBySchema.get(t);n&&(this.debugLogger.logPoolEvicted(n,t,"ttl_expired"),this.tenantIdBySchema.delete(t));}}ensureNotDisposed(){if(this.disposed)throw new Error("[drizzle-multitenant] TenantManager has been disposed")}};function Re(c){let e=new k(c);return e.startCleanup(),{getDb(t){return e.getDb(t)},async getDbAsync(t){return e.getDbAsync(t)},getSharedDb(){return e.getSharedDb()},async getSharedDbAsync(){return e.getSharedDbAsync()},getSchemaName(t){return e.getSchemaName(t)},hasPool(t){return e.hasPool(t)},getPoolCount(){return e.getPoolCount()},getActiveTenantIds(){return e.getActiveTenantIds()},getRetryConfig(){return e.getRetryConfig()},async evictPool(t){await e.evictPool(t);},async warmup(t,n){return e.warmup(t,n)},async healthCheck(t){return e.healthCheck(t)},getMetrics(){return e.getMetrics()},async dispose(){await e.dispose();}}}function De(c){let e=new AsyncLocalStorage;function t(){return e.getStore()}function n(){let m=t();if(!m)throw new Error("[drizzle-multitenant] No tenant context found. Make sure you are calling this within runWithTenant().");return m}function a(){return n().tenantId}function r(){let m=a();return c.getDb(m)}function s(){return c.getSharedDb()}function i(){return t()!==void 0}function o(m,l){if(!m.tenantId)throw new Error("[drizzle-multitenant] tenantId is required in context");return e.run(m,l)}return {runWithTenant:o,getTenant:n,getTenantOrNull:t,getTenantId:a,getTenantDb:r,getSharedDb:s,isInTenantContext:i}}async function Y(c,e,t){if(!(await c.query(`SELECT EXISTS (
       SELECT 1 FROM information_schema.tables
       WHERE table_schema = $1 AND table_name = $2
-    ) as exists`,
-    [schemaName, tableName]
-  );
-  if (!tableExists.rows[0]?.exists) {
-    return null;
-  }
-  const columnsResult = await pool.query(
-    `SELECT column_name, data_type
+    ) as exists`,[e,t])).rows[0]?.exists)return null;let a=await c.query(`SELECT column_name, data_type
      FROM information_schema.columns
-     WHERE table_schema = $1 AND table_name = $2`,
-    [schemaName, tableName]
-  );
-  const columnMap = new Map(
-    columnsResult.rows.map((r) => [r.column_name, r.data_type])
-  );
-  if (columnMap.has("name")) {
-    return {
-      format: "name",
-      tableName,
-      columns: {
-        identifier: "name",
-        timestamp: columnMap.has("applied_at") ? "applied_at" : "created_at",
-        timestampType: "timestamp"
-      }
-    };
-  }
-  if (columnMap.has("hash")) {
-    const createdAtType = columnMap.get("created_at");
-    if (createdAtType === "bigint") {
-      return {
-        format: "drizzle-kit",
-        tableName,
-        columns: {
-          identifier: "hash",
-          timestamp: "created_at",
-          timestampType: "bigint"
-        }
-      };
-    }
-    return {
-      format: "hash",
-      tableName,
-      columns: {
-        identifier: "hash",
-        timestamp: "created_at",
-        timestampType: "timestamp"
-      }
-    };
-  }
-  return null;
-}
-function getFormatConfig(format, tableName = "__drizzle_migrations") {
-  switch (format) {
-    case "name":
-      return {
-        format: "name",
-        tableName,
-        columns: {
-          identifier: "name",
-          timestamp: "applied_at",
-          timestampType: "timestamp"
-        }
-      };
-    case "hash":
-      return {
-        format: "hash",
-        tableName,
-        columns: {
-          identifier: "hash",
-          timestamp: "created_at",
-          timestampType: "timestamp"
-        }
-      };
-    case "drizzle-kit":
-      return {
-        format: "drizzle-kit",
-        tableName,
-        columns: {
-          identifier: "hash",
-          timestamp: "created_at",
-          timestampType: "bigint"
-        }
-      };
-  }
-}
-
-// src/migrator/migrator.ts
-var DEFAULT_MIGRATIONS_TABLE = "__drizzle_migrations";
-var Migrator = class {
-  constructor(tenantConfig, migratorConfig) {
-    this.tenantConfig = tenantConfig;
-    this.migratorConfig = migratorConfig;
-    this.migrationsTable = migratorConfig.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE;
-  }
-  migrationsTable;
-  /**
-   * Migrate all tenants in parallel
-   */
-  async migrateAll(options = {}) {
-    const {
-      concurrency = 10,
-      onProgress,
-      onError,
-      dryRun = false
-    } = options;
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const migrations = await this.loadMigrations();
-    const results = [];
-    let aborted = false;
-    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
-      const batch = tenantIds.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map(async (tenantId) => {
-          if (aborted) {
-            return this.createSkippedResult(tenantId);
-          }
-          try {
-            onProgress?.(tenantId, "starting");
-            const result = await this.migrateTenant(tenantId, migrations, { dryRun, onProgress });
-            onProgress?.(tenantId, result.success ? "completed" : "failed");
-            return result;
-          } catch (error) {
-            onProgress?.(tenantId, "failed");
-            const action = onError?.(tenantId, error);
-            if (action === "abort") {
-              aborted = true;
-            }
-            return this.createErrorResult(tenantId, error);
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    if (aborted) {
-      const remaining = tenantIds.slice(results.length);
-      for (const tenantId of remaining) {
-        results.push(this.createSkippedResult(tenantId));
-      }
-    }
-    return this.aggregateResults(results);
-  }
-  /**
-   * Migrate a single tenant
-   */
-  async migrateTenant(tenantId, migrations, options = {}) {
-    const startTime = Date.now();
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const appliedMigrations = [];
-    const pool = await this.createPool(schemaName);
-    try {
-      await this.migratorConfig.hooks?.beforeTenant?.(tenantId);
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      await this.ensureMigrationsTable(pool, schemaName, format);
-      const allMigrations = migrations ?? await this.loadMigrations();
-      const applied = await this.getAppliedMigrations(pool, schemaName, format);
-      const appliedSet = new Set(applied.map((m) => m.identifier));
-      const pending = allMigrations.filter(
-        (m) => !this.isMigrationApplied(m, appliedSet, format)
-      );
-      if (options.dryRun) {
-        return {
-          tenantId,
-          schemaName,
-          success: true,
-          appliedMigrations: pending.map((m) => m.name),
-          durationMs: Date.now() - startTime,
-          format: format.format
-        };
-      }
-      for (const migration of pending) {
-        const migrationStart = Date.now();
-        options.onProgress?.(tenantId, "migrating", migration.name);
-        await this.migratorConfig.hooks?.beforeMigration?.(tenantId, migration.name);
-        await this.applyMigration(pool, schemaName, migration, format);
-        await this.migratorConfig.hooks?.afterMigration?.(
-          tenantId,
-          migration.name,
-          Date.now() - migrationStart
-        );
-        appliedMigrations.push(migration.name);
-      }
-      const result = {
-        tenantId,
-        schemaName,
-        success: true,
-        appliedMigrations,
-        durationMs: Date.now() - startTime,
-        format: format.format
-      };
-      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } catch (error) {
-      const result = {
-        tenantId,
-        schemaName,
-        success: false,
-        appliedMigrations,
-        error: error.message,
-        durationMs: Date.now() - startTime
-      };
-      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Migrate specific tenants
-   */
-  async migrateTenants(tenantIds, options = {}) {
-    const migrations = await this.loadMigrations();
-    const results = [];
-    const { concurrency = 10, onProgress, onError } = options;
-    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) => {
-          try {
-            onProgress?.(tenantId, "starting");
-            const result = await this.migrateTenant(tenantId, migrations, { dryRun: options.dryRun ?? false, onProgress });
-            onProgress?.(tenantId, result.success ? "completed" : "failed");
-            return result;
-          } catch (error) {
-            onProgress?.(tenantId, "failed");
-            onError?.(tenantId, error);
-            return this.createErrorResult(tenantId, error);
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    return this.aggregateResults(results);
-  }
-  /**
-   * Get migration status for all tenants
-   */
-  async getStatus() {
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const migrations = await this.loadMigrations();
-    const statuses = [];
-    for (const tenantId of tenantIds) {
-      statuses.push(await this.getTenantStatus(tenantId, migrations));
-    }
-    return statuses;
-  }
-  /**
-   * Get migration status for a specific tenant
-   */
-  async getTenantStatus(tenantId, migrations) {
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = await this.createPool(schemaName);
-    try {
-      const allMigrations = migrations ?? await this.loadMigrations();
-      const tableExists = await this.migrationsTableExists(pool, schemaName);
-      if (!tableExists) {
-        return {
-          tenantId,
-          schemaName,
-          appliedCount: 0,
-          pendingCount: allMigrations.length,
-          pendingMigrations: allMigrations.map((m) => m.name),
-          status: allMigrations.length > 0 ? "behind" : "ok",
-          format: null
-          // New tenant, no table yet
-        };
-      }
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      const applied = await this.getAppliedMigrations(pool, schemaName, format);
-      const appliedSet = new Set(applied.map((m) => m.identifier));
-      const pending = allMigrations.filter(
-        (m) => !this.isMigrationApplied(m, appliedSet, format)
-      );
-      return {
-        tenantId,
-        schemaName,
-        appliedCount: applied.length,
-        pendingCount: pending.length,
-        pendingMigrations: pending.map((m) => m.name),
-        status: pending.length > 0 ? "behind" : "ok",
-        format: format.format
-      };
-    } catch (error) {
-      return {
-        tenantId,
-        schemaName,
-        appliedCount: 0,
-        pendingCount: 0,
-        pendingMigrations: [],
-        status: "error",
-        error: error.message,
-        format: null
-      };
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Create a new tenant schema and optionally apply migrations
-   */
-  async createTenant(tenantId, options = {}) {
-    const { migrate = true } = options;
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = new Pool({
-      connectionString: this.tenantConfig.connection.url,
-      ...this.tenantConfig.connection.poolConfig
-    });
-    try {
-      await pool.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
-      if (migrate) {
-        await this.migrateTenant(tenantId);
-      }
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Drop a tenant schema
-   */
-  async dropTenant(tenantId, options = {}) {
-    const { cascade = true } = options;
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = new Pool({
-      connectionString: this.tenantConfig.connection.url,
-      ...this.tenantConfig.connection.poolConfig
-    });
-    try {
-      const cascadeSql = cascade ? "CASCADE" : "RESTRICT";
-      await pool.query(`DROP SCHEMA IF EXISTS "${schemaName}" ${cascadeSql}`);
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Check if a tenant schema exists
-   */
-  async tenantExists(tenantId) {
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = new Pool({
-      connectionString: this.tenantConfig.connection.url,
-      ...this.tenantConfig.connection.poolConfig
-    });
-    try {
-      const result = await pool.query(
-        `SELECT 1 FROM information_schema.schemata WHERE schema_name = $1`,
-        [schemaName]
-      );
-      return result.rowCount !== null && result.rowCount > 0;
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Mark migrations as applied without executing SQL
-   * Useful for syncing tracking state with already-applied migrations
-   */
-  async markAsApplied(tenantId, options = {}) {
-    const startTime = Date.now();
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const markedMigrations = [];
-    const pool = await this.createPool(schemaName);
-    try {
-      await this.migratorConfig.hooks?.beforeTenant?.(tenantId);
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      await this.ensureMigrationsTable(pool, schemaName, format);
-      const allMigrations = await this.loadMigrations();
-      const applied = await this.getAppliedMigrations(pool, schemaName, format);
-      const appliedSet = new Set(applied.map((m) => m.identifier));
-      const pending = allMigrations.filter(
-        (m) => !this.isMigrationApplied(m, appliedSet, format)
-      );
-      for (const migration of pending) {
-        const migrationStart = Date.now();
-        options.onProgress?.(tenantId, "migrating", migration.name);
-        await this.migratorConfig.hooks?.beforeMigration?.(tenantId, migration.name);
-        await this.recordMigration(pool, schemaName, migration, format);
-        await this.migratorConfig.hooks?.afterMigration?.(
-          tenantId,
-          migration.name,
-          Date.now() - migrationStart
-        );
-        markedMigrations.push(migration.name);
-      }
-      const result = {
-        tenantId,
-        schemaName,
-        success: true,
-        appliedMigrations: markedMigrations,
-        durationMs: Date.now() - startTime,
-        format: format.format
-      };
-      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } catch (error) {
-      const result = {
-        tenantId,
-        schemaName,
-        success: false,
-        appliedMigrations: markedMigrations,
-        error: error.message,
-        durationMs: Date.now() - startTime
-      };
-      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Mark migrations as applied for all tenants without executing SQL
-   * Useful for syncing tracking state with already-applied migrations
-   */
-  async markAllAsApplied(options = {}) {
-    const {
-      concurrency = 10,
-      onProgress,
-      onError
-    } = options;
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const results = [];
-    let aborted = false;
-    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
-      const batch = tenantIds.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map(async (tenantId) => {
-          if (aborted) {
-            return this.createSkippedResult(tenantId);
-          }
-          try {
-            onProgress?.(tenantId, "starting");
-            const result = await this.markAsApplied(tenantId, { onProgress });
-            onProgress?.(tenantId, result.success ? "completed" : "failed");
-            return result;
-          } catch (error) {
-            onProgress?.(tenantId, "failed");
-            const action = onError?.(tenantId, error);
-            if (action === "abort") {
-              aborted = true;
-            }
-            return this.createErrorResult(tenantId, error);
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    if (aborted) {
-      const remaining = tenantIds.slice(results.length);
-      for (const tenantId of remaining) {
-        results.push(this.createSkippedResult(tenantId));
-      }
-    }
-    return this.aggregateResults(results);
-  }
-  /**
-   * Get sync status for all tenants
-   * Detects divergences between migrations on disk and tracking in database
-   */
-  async getSyncStatus() {
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const migrations = await this.loadMigrations();
-    const statuses = [];
-    for (const tenantId of tenantIds) {
-      statuses.push(await this.getTenantSyncStatus(tenantId, migrations));
-    }
-    return {
-      total: statuses.length,
-      inSync: statuses.filter((s) => s.inSync && !s.error).length,
-      outOfSync: statuses.filter((s) => !s.inSync && !s.error).length,
-      error: statuses.filter((s) => !!s.error).length,
-      details: statuses
-    };
-  }
-  /**
-   * Get sync status for a specific tenant
-   */
-  async getTenantSyncStatus(tenantId, migrations) {
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const pool = await this.createPool(schemaName);
-    try {
-      const allMigrations = migrations ?? await this.loadMigrations();
-      const migrationNames = new Set(allMigrations.map((m) => m.name));
-      const migrationHashes = new Set(allMigrations.map((m) => m.hash));
-      const tableExists = await this.migrationsTableExists(pool, schemaName);
-      if (!tableExists) {
-        return {
-          tenantId,
-          schemaName,
-          missing: allMigrations.map((m) => m.name),
-          orphans: [],
-          inSync: allMigrations.length === 0,
-          format: null
-        };
-      }
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      const applied = await this.getAppliedMigrations(pool, schemaName, format);
-      const appliedIdentifiers = new Set(applied.map((m) => m.identifier));
-      const missing = allMigrations.filter((m) => !this.isMigrationApplied(m, appliedIdentifiers, format)).map((m) => m.name);
-      const orphans = applied.filter((m) => {
-        if (format.columns.identifier === "name") {
-          return !migrationNames.has(m.identifier);
-        }
-        return !migrationHashes.has(m.identifier) && !migrationNames.has(m.identifier);
-      }).map((m) => m.identifier);
-      return {
-        tenantId,
-        schemaName,
-        missing,
-        orphans,
-        inSync: missing.length === 0 && orphans.length === 0,
-        format: format.format
-      };
-    } catch (error) {
-      return {
-        tenantId,
-        schemaName,
-        missing: [],
-        orphans: [],
-        inSync: false,
-        format: null,
-        error: error.message
-      };
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Mark missing migrations as applied for a tenant
-   */
-  async markMissing(tenantId) {
-    const startTime = Date.now();
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const markedMigrations = [];
-    const pool = await this.createPool(schemaName);
-    try {
-      const syncStatus = await this.getTenantSyncStatus(tenantId);
-      if (syncStatus.error) {
-        return {
-          tenantId,
-          schemaName,
-          success: false,
-          markedMigrations: [],
-          removedOrphans: [],
-          error: syncStatus.error,
-          durationMs: Date.now() - startTime
-        };
-      }
-      if (syncStatus.missing.length === 0) {
-        return {
-          tenantId,
-          schemaName,
-          success: true,
-          markedMigrations: [],
-          removedOrphans: [],
-          durationMs: Date.now() - startTime
-        };
-      }
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      await this.ensureMigrationsTable(pool, schemaName, format);
-      const allMigrations = await this.loadMigrations();
-      const missingSet = new Set(syncStatus.missing);
-      for (const migration of allMigrations) {
-        if (missingSet.has(migration.name)) {
-          await this.recordMigration(pool, schemaName, migration, format);
-          markedMigrations.push(migration.name);
-        }
-      }
-      return {
-        tenantId,
-        schemaName,
-        success: true,
-        markedMigrations,
-        removedOrphans: [],
-        durationMs: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        tenantId,
-        schemaName,
-        success: false,
-        markedMigrations,
-        removedOrphans: [],
-        error: error.message,
-        durationMs: Date.now() - startTime
-      };
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Mark missing migrations as applied for all tenants
-   */
-  async markAllMissing(options = {}) {
-    const { concurrency = 10, onProgress, onError } = options;
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const results = [];
-    let aborted = false;
-    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
-      const batch = tenantIds.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map(async (tenantId) => {
-          if (aborted) {
-            return this.createSkippedSyncResult(tenantId);
-          }
-          try {
-            onProgress?.(tenantId, "starting");
-            const result = await this.markMissing(tenantId);
-            onProgress?.(tenantId, result.success ? "completed" : "failed");
-            return result;
-          } catch (error) {
-            onProgress?.(tenantId, "failed");
-            const action = onError?.(tenantId, error);
-            if (action === "abort") {
-              aborted = true;
-            }
-            return this.createErrorSyncResult(tenantId, error);
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    return this.aggregateSyncResults(results);
-  }
-  /**
-   * Remove orphan migration records for a tenant
-   */
-  async cleanOrphans(tenantId) {
-    const startTime = Date.now();
-    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-    const removedOrphans = [];
-    const pool = await this.createPool(schemaName);
-    try {
-      const syncStatus = await this.getTenantSyncStatus(tenantId);
-      if (syncStatus.error) {
-        return {
-          tenantId,
-          schemaName,
-          success: false,
-          markedMigrations: [],
-          removedOrphans: [],
-          error: syncStatus.error,
-          durationMs: Date.now() - startTime
-        };
-      }
-      if (syncStatus.orphans.length === 0) {
-        return {
-          tenantId,
-          schemaName,
-          success: true,
-          markedMigrations: [],
-          removedOrphans: [],
-          durationMs: Date.now() - startTime
-        };
-      }
-      const format = await this.getOrDetectFormat(pool, schemaName);
-      const identifierColumn = format.columns.identifier;
-      for (const orphan of syncStatus.orphans) {
-        await pool.query(
-          `DELETE FROM "${schemaName}"."${format.tableName}" WHERE "${identifierColumn}" = $1`,
-          [orphan]
-        );
-        removedOrphans.push(orphan);
-      }
-      return {
-        tenantId,
-        schemaName,
-        success: true,
-        markedMigrations: [],
-        removedOrphans,
-        durationMs: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        tenantId,
-        schemaName,
-        success: false,
-        markedMigrations: [],
-        removedOrphans,
-        error: error.message,
-        durationMs: Date.now() - startTime
-      };
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Remove orphan migration records for all tenants
-   */
-  async cleanAllOrphans(options = {}) {
-    const { concurrency = 10, onProgress, onError } = options;
-    const tenantIds = await this.migratorConfig.tenantDiscovery();
-    const results = [];
-    let aborted = false;
-    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
-      const batch = tenantIds.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map(async (tenantId) => {
-          if (aborted) {
-            return this.createSkippedSyncResult(tenantId);
-          }
-          try {
-            onProgress?.(tenantId, "starting");
-            const result = await this.cleanOrphans(tenantId);
-            onProgress?.(tenantId, result.success ? "completed" : "failed");
-            return result;
-          } catch (error) {
-            onProgress?.(tenantId, "failed");
-            const action = onError?.(tenantId, error);
-            if (action === "abort") {
-              aborted = true;
-            }
-            return this.createErrorSyncResult(tenantId, error);
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    return this.aggregateSyncResults(results);
-  }
-  /**
-   * Load migration files from the migrations folder
-   */
-  async loadMigrations() {
-    const files = await readdir(this.migratorConfig.migrationsFolder);
-    const migrations = [];
-    for (const file of files) {
-      if (!file.endsWith(".sql")) continue;
-      const filePath = join(this.migratorConfig.migrationsFolder, file);
-      const content = await readFile(filePath, "utf-8");
-      const match = file.match(/^(\d+)_/);
-      const timestamp = match?.[1] ? parseInt(match[1], 10) : 0;
-      const hash = createHash("sha256").update(content).digest("hex");
-      migrations.push({
-        name: basename(file, ".sql"),
-        path: filePath,
-        sql: content,
-        timestamp,
-        hash
-      });
-    }
-    return migrations.sort((a, b) => a.timestamp - b.timestamp);
-  }
-  /**
-   * Create a pool for a specific schema
-   */
-  async createPool(schemaName) {
-    return new Pool({
-      connectionString: this.tenantConfig.connection.url,
-      ...this.tenantConfig.connection.poolConfig,
-      options: `-c search_path="${schemaName}",public`
-    });
-  }
-  /**
-   * Ensure migrations table exists with the correct format
-   */
-  async ensureMigrationsTable(pool, schemaName, format) {
-    const { identifier, timestamp, timestampType } = format.columns;
-    const identifierCol = identifier === "name" ? "name VARCHAR(255) NOT NULL UNIQUE" : "hash TEXT NOT NULL";
-    const timestampCol = timestampType === "bigint" ? `${timestamp} BIGINT NOT NULL` : `${timestamp} TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP`;
-    await pool.query(`
-      CREATE TABLE IF NOT EXISTS "${schemaName}"."${format.tableName}" (
+     WHERE table_schema = $1 AND table_name = $2`,[e,t]),r=new Map(a.rows.map(s=>[s.column_name,s.data_type]));return r.has("name")?{format:"name",tableName:t,columns:{identifier:"name",timestamp:r.has("applied_at")?"applied_at":"created_at",timestampType:"timestamp"}}:r.has("hash")?r.get("created_at")==="bigint"?{format:"drizzle-kit",tableName:t,columns:{identifier:"hash",timestamp:"created_at",timestampType:"bigint"}}:{format:"hash",tableName:t,columns:{identifier:"hash",timestamp:"created_at",timestampType:"timestamp"}}:null}function _(c,e="__drizzle_migrations"){switch(c){case "name":return {format:"name",tableName:e,columns:{identifier:"name",timestamp:"applied_at",timestampType:"timestamp"}};case "hash":return {format:"hash",tableName:e,columns:{identifier:"hash",timestamp:"created_at",timestampType:"timestamp"}};case "drizzle-kit":return {format:"drizzle-kit",tableName:e,columns:{identifier:"hash",timestamp:"created_at",timestampType:"bigint"}}}}var xe="__drizzle_migrations",O=class{constructor(e,t){this.config=e;this.migrationsTable=t??xe;}migrationsTable;getSchemaName(e){return this.config.isolation.schemaNameTemplate(e)}async createPool(e){return new Pool({connectionString:this.config.connection.url,...this.config.connection.poolConfig,options:`-c search_path="${e}",public`})}async createRootPool(){return new Pool({connectionString:this.config.connection.url,...this.config.connection.poolConfig})}async createSchema(e){let t=this.getSchemaName(e),n=await this.createRootPool();try{await n.query(`CREATE SCHEMA IF NOT EXISTS "${t}"`);}finally{await n.end();}}async dropSchema(e,t={}){let{cascade:n=true}=t,a=this.getSchemaName(e),r=await this.createRootPool();try{let s=n?"CASCADE":"RESTRICT";await r.query(`DROP SCHEMA IF EXISTS "${a}" ${s}`);}finally{await r.end();}}async schemaExists(e){let t=this.getSchemaName(e),n=await this.createRootPool();try{let a=await n.query("SELECT 1 FROM information_schema.schemata WHERE schema_name = $1",[t]);return a.rowCount!==null&&a.rowCount>0}finally{await n.end();}}async listSchemas(e){let t=await this.createRootPool();try{let n=e?"SELECT schema_name FROM information_schema.schemata WHERE schema_name LIKE $1 ORDER BY schema_name":"SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast') ORDER BY schema_name";return (await t.query(n,e?[e]:[])).rows.map(r=>r.schema_name)}finally{await t.end();}}async ensureMigrationsTable(e,t,n){let{identifier:a,timestamp:r,timestampType:s}=n.columns,i=a==="name"?"name VARCHAR(255) NOT NULL UNIQUE":"hash TEXT NOT NULL",o=s==="bigint"?`${r} BIGINT NOT NULL`:`${r} TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP`;await e.query(`
+      CREATE TABLE IF NOT EXISTS "${t}"."${n.tableName}" (
         id SERIAL PRIMARY KEY,
-        ${identifierCol},
-        ${timestampCol}
+        ${i},
+        ${o}
       )
-    `);
-  }
-  /**
-   * Check if migrations table exists
-   */
-  async migrationsTableExists(pool, schemaName) {
-    const result = await pool.query(
-      `SELECT 1 FROM information_schema.tables
-       WHERE table_schema = $1 AND table_name = $2`,
-      [schemaName, this.migrationsTable]
-    );
-    return result.rowCount !== null && result.rowCount > 0;
-  }
-  /**
-   * Get applied migrations for a schema
-   */
-  async getAppliedMigrations(pool, schemaName, format) {
-    const identifierColumn = format.columns.identifier;
-    const timestampColumn = format.columns.timestamp;
-    const result = await pool.query(
-      `SELECT id, "${identifierColumn}" as identifier, "${timestampColumn}" as applied_at
-       FROM "${schemaName}"."${format.tableName}"
-       ORDER BY id`
-    );
-    return result.rows.map((row) => {
-      const appliedAt = format.columns.timestampType === "bigint" ? new Date(Number(row.applied_at)) : new Date(row.applied_at);
-      return {
-        id: row.id,
-        identifier: row.identifier,
-        // Set name or hash based on format
-        ...format.columns.identifier === "name" ? { name: row.identifier } : { hash: row.identifier },
-        appliedAt
-      };
-    });
-  }
-  /**
-   * Check if a migration has been applied
-   */
-  isMigrationApplied(migration, appliedIdentifiers, format) {
-    if (format.columns.identifier === "name") {
-      return appliedIdentifiers.has(migration.name);
-    }
-    return appliedIdentifiers.has(migration.hash) || appliedIdentifiers.has(migration.name);
-  }
-  /**
-   * Get or detect the format for a schema
-   * Returns the configured format or auto-detects from existing table
-   */
-  async getOrDetectFormat(pool, schemaName) {
-    const configuredFormat = this.migratorConfig.tableFormat ?? "auto";
-    if (configuredFormat !== "auto") {
-      return getFormatConfig(configuredFormat, this.migrationsTable);
-    }
-    const detected = await detectTableFormat(pool, schemaName, this.migrationsTable);
-    if (detected) {
-      return detected;
-    }
-    const defaultFormat = this.migratorConfig.defaultFormat ?? "name";
-    return getFormatConfig(defaultFormat, this.migrationsTable);
-  }
-  /**
-   * Apply a migration to a schema
-   */
-  async applyMigration(pool, schemaName, migration, format) {
-    const client = await pool.connect();
-    try {
-      await client.query("BEGIN");
-      await client.query(migration.sql);
-      const { identifier, timestamp, timestampType } = format.columns;
-      const identifierValue = identifier === "name" ? migration.name : migration.hash;
-      const timestampValue = timestampType === "bigint" ? Date.now() : /* @__PURE__ */ new Date();
-      await client.query(
-        `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
-        [identifierValue, timestampValue]
-      );
-      await client.query("COMMIT");
-    } catch (error) {
-      await client.query("ROLLBACK");
-      throw error;
-    } finally {
-      client.release();
-    }
-  }
-  /**
-   * Record a migration as applied without executing SQL
-   * Used by markAsApplied to sync tracking state
-   */
-  async recordMigration(pool, schemaName, migration, format) {
-    const { identifier, timestamp, timestampType } = format.columns;
-    const identifierValue = identifier === "name" ? migration.name : migration.hash;
-    const timestampValue = timestampType === "bigint" ? Date.now() : /* @__PURE__ */ new Date();
-    await pool.query(
-      `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
-      [identifierValue, timestampValue]
-    );
-  }
-  /**
-   * Create a skipped result
-   */
-  createSkippedResult(tenantId) {
-    return {
-      tenantId,
-      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
-      success: false,
-      appliedMigrations: [],
-      error: "Skipped due to abort",
-      durationMs: 0
-    };
-  }
-  /**
-   * Create an error result
-   */
-  createErrorResult(tenantId, error) {
-    return {
-      tenantId,
-      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
-      success: false,
-      appliedMigrations: [],
-      error: error.message,
-      durationMs: 0
-    };
-  }
-  /**
-   * Aggregate migration results
-   */
-  aggregateResults(results) {
-    return {
-      total: results.length,
-      succeeded: results.filter((r) => r.success).length,
-      failed: results.filter((r) => !r.success && r.error !== "Skipped due to abort").length,
-      skipped: results.filter((r) => r.error === "Skipped due to abort").length,
-      details: results
-    };
-  }
-  /**
-   * Create a skipped sync result
-   */
-  createSkippedSyncResult(tenantId) {
-    return {
-      tenantId,
-      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
-      success: false,
-      markedMigrations: [],
-      removedOrphans: [],
-      error: "Skipped due to abort",
-      durationMs: 0
-    };
-  }
-  /**
-   * Create an error sync result
-   */
-  createErrorSyncResult(tenantId, error) {
-    return {
-      tenantId,
-      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
-      success: false,
-      markedMigrations: [],
-      removedOrphans: [],
-      error: error.message,
-      durationMs: 0
-    };
-  }
-  /**
-   * Aggregate sync results
-   */
-  aggregateSyncResults(results) {
-    return {
-      total: results.length,
-      succeeded: results.filter((r) => r.success).length,
-      failed: results.filter((r) => !r.success).length,
-      details: results
-    };
-  }
-};
-function createMigrator(tenantConfig, migratorConfig) {
-  return new Migrator(tenantConfig, migratorConfig);
-}
-var CrossSchemaQueryBuilder = class {
-  constructor(context) {
-    this.context = context;
-  }
-  fromTable = null;
-  joins = [];
-  selectFields = {};
-  whereCondition = null;
-  orderByFields = [];
-  limitValue = null;
-  offsetValue = null;
-  /**
-   * Set the main table to query from
-   */
-  from(source, table) {
-    const schemaName = this.getSchemaName(source);
-    this.fromTable = { table, source, schemaName };
-    return this;
-  }
-  /**
-   * Add an inner join
-   */
-  innerJoin(source, table, condition) {
-    return this.addJoin(source, table, condition, "inner");
-  }
-  /**
-   * Add a left join
-   */
-  leftJoin(source, table, condition) {
-    return this.addJoin(source, table, condition, "left");
-  }
-  /**
-   * Add a right join
-   */
-  rightJoin(source, table, condition) {
-    return this.addJoin(source, table, condition, "right");
-  }
-  /**
-   * Add a full outer join
-   */
-  fullJoin(source, table, condition) {
-    return this.addJoin(source, table, condition, "full");
-  }
-  /**
-   * Select specific fields
-   */
-  select(fields) {
-    this.selectFields = fields;
-    return this;
-  }
-  /**
-   * Add a where condition
-   */
-  where(condition) {
-    this.whereCondition = condition;
-    return this;
-  }
-  /**
-   * Add order by
-   */
-  orderBy(...fields) {
-    this.orderByFields = fields;
-    return this;
-  }
-  /**
-   * Set limit
-   */
-  limit(value) {
-    this.limitValue = value;
-    return this;
-  }
-  /**
-   * Set offset
-   */
-  offset(value) {
-    this.offsetValue = value;
-    return this;
-  }
-  /**
-   * Execute the query and return typed results
-   */
-  async execute() {
-    if (!this.fromTable) {
-      throw new Error("[drizzle-multitenant] No table specified. Use .from() first.");
-    }
-    const sqlQuery = this.buildSql();
-    const result = await this.context.tenantDb.execute(sqlQuery);
-    return result.rows;
-  }
-  /**
-   * Build the SQL query
-   */
-  buildSql() {
-    if (!this.fromTable) {
-      throw new Error("[drizzle-multitenant] No table specified");
-    }
-    const parts = [];
-    const selectParts = Object.entries(this.selectFields).map(([alias, column]) => {
-      const columnName = column.name;
-      return sql`${sql.raw(`"${columnName}"`)} as ${sql.raw(`"${alias}"`)}`;
-    });
-    if (selectParts.length === 0) {
-      parts.push(sql`SELECT *`);
-    } else {
-      parts.push(sql`SELECT ${sql.join(selectParts, sql`, `)}`);
-    }
-    const fromTableRef = this.getFullTableName(this.fromTable.schemaName, this.fromTable.table);
-    parts.push(sql` FROM ${sql.raw(fromTableRef)}`);
-    for (const join2 of this.joins) {
-      const joinTableRef = this.getFullTableName(join2.schemaName, join2.table);
-      const joinType = this.getJoinKeyword(join2.type);
-      parts.push(sql` ${sql.raw(joinType)} ${sql.raw(joinTableRef)} ON ${join2.condition}`);
-    }
-    if (this.whereCondition) {
-      parts.push(sql` WHERE ${this.whereCondition}`);
-    }
-    if (this.orderByFields.length > 0) {
-      parts.push(sql` ORDER BY ${sql.join(this.orderByFields, sql`, `)}`);
-    }
-    if (this.limitValue !== null) {
-      parts.push(sql` LIMIT ${sql.raw(this.limitValue.toString())}`);
-    }
-    if (this.offsetValue !== null) {
-      parts.push(sql` OFFSET ${sql.raw(this.offsetValue.toString())}`);
-    }
-    return sql.join(parts, sql``);
-  }
-  /**
-   * Add a join to the query
-   */
-  addJoin(source, table, condition, type) {
-    const schemaName = this.getSchemaName(source);
-    this.joins.push({ table, source, schemaName, condition, type });
-    return this;
-  }
-  /**
-   * Get schema name for a source
-   */
-  getSchemaName(source) {
-    if (source === "tenant") {
-      return this.context.tenantSchema ?? "tenant";
-    }
-    return this.context.sharedSchema ?? "public";
-  }
-  /**
-   * Get fully qualified table name
-   */
-  getFullTableName(schemaName, table) {
-    const tableName = getTableName(table);
-    return `"${schemaName}"."${tableName}"`;
-  }
-  /**
-   * Get SQL keyword for join type
-   */
-  getJoinKeyword(type) {
-    switch (type) {
-      case "inner":
-        return "INNER JOIN";
-      case "left":
-        return "LEFT JOIN";
-      case "right":
-        return "RIGHT JOIN";
-      case "full":
-        return "FULL OUTER JOIN";
-    }
-  }
-};
-function createCrossSchemaQuery(context) {
-  return new CrossSchemaQueryBuilder(context);
-}
-async function withSharedLookup(config) {
-  const {
-    tenantDb,
-    tenantTable,
-    sharedTable,
-    foreignKey,
-    sharedKey = "id",
-    sharedFields,
-    where: whereCondition
-  } = config;
-  const tenantTableName = getTableName(tenantTable);
-  const sharedTableName = getTableName(sharedTable);
-  const sharedFieldList = sharedFields.map((field) => `s."${String(field)}"`).join(", ");
-  const queryParts = [
-    `SELECT t.*, ${sharedFieldList}`,
-    `FROM "${tenantTableName}" t`,
-    `LEFT JOIN "public"."${sharedTableName}" s ON t."${String(foreignKey)}" = s."${String(sharedKey)}"`
-  ];
-  if (whereCondition) {
-    queryParts.push("WHERE");
-  }
-  const sqlQuery = sql.raw(queryParts.join(" "));
-  const result = await tenantDb.execute(sqlQuery);
-  return result.rows;
-}
-async function crossSchemaRaw(db, options) {
-  const { tenantSchema, sharedSchema, sql: rawSql } = options;
-  const processedSql = rawSql.replace(/\$tenant\./g, `"${tenantSchema}".`).replace(/\$shared\./g, `"${sharedSchema}".`);
-  const query = sql.raw(processedSql);
-  const result = await db.execute(query);
-  return result.rows;
-}
-function buildCrossSchemaSelect(fields, tenantSchema, _sharedSchema) {
-  const columns = Object.entries(fields).map(([alias, column]) => {
-    const columnName = column.name;
-    return `"${columnName}" as "${alias}"`;
-  });
-  const getSchema = () => {
-    return tenantSchema;
-  };
-  return { columns, getSchema };
-}
-function extractTablesFromSchema(schema) {
-  const tables = /* @__PURE__ */ new Set();
-  for (const value of Object.values(schema)) {
-    if (value && typeof value === "object" && "_" in value) {
-      const branded = value;
-      if (branded._?.brand === "Table") {
-        tables.add(value);
-      }
-    }
-  }
-  return tables;
-}
-function isSharedTable(table, sharedTables) {
-  return sharedTables.has(table);
-}
-var WithSharedQueryBuilder = class {
-  constructor(tenantDb, sharedTables, tenantSchemaName, sharedSchemaName = "public") {
-    this.tenantDb = tenantDb;
-    this.sharedTables = sharedTables;
-    this.tenantSchemaName = tenantSchemaName;
-    this.sharedSchemaName = sharedSchemaName;
-  }
-  fromTable = null;
-  joins = [];
-  selectFields = {};
-  whereCondition = null;
-  orderByFields = [];
-  limitValue = null;
-  offsetValue = null;
-  /**
-   * Set the main table to query from
-   * Automatically detects if it's a tenant or shared table
-   */
-  from(table) {
-    const isShared = isSharedTable(table, this.sharedTables);
-    this.fromTable = {
-      table,
-      isShared,
-      schemaName: isShared ? this.sharedSchemaName : this.tenantSchemaName
-    };
-    return this;
-  }
-  /**
-   * Add a left join with automatic schema detection
-   */
-  leftJoin(table, condition) {
-    return this.addJoin(table, condition, "left");
-  }
-  /**
-   * Add an inner join with automatic schema detection
-   */
-  innerJoin(table, condition) {
-    return this.addJoin(table, condition, "inner");
-  }
-  /**
-   * Add a right join with automatic schema detection
-   */
-  rightJoin(table, condition) {
-    return this.addJoin(table, condition, "right");
-  }
-  /**
-   * Add a full outer join with automatic schema detection
-   */
-  fullJoin(table, condition) {
-    return this.addJoin(table, condition, "full");
-  }
-  /**
-   * Select specific fields
-   */
-  select(fields) {
-    this.selectFields = fields;
-    return this;
-  }
-  /**
-   * Add a WHERE condition
-   */
-  where(condition) {
-    this.whereCondition = condition;
-    return this;
-  }
-  /**
-   * Add ORDER BY
-   */
-  orderBy(...fields) {
-    this.orderByFields = fields;
-    return this;
-  }
-  /**
-   * Set LIMIT
-   */
-  limit(value) {
-    this.limitValue = value;
-    return this;
-  }
-  /**
-   * Set OFFSET
-   */
-  offset(value) {
-    this.offsetValue = value;
-    return this;
-  }
-  /**
-   * Execute the query and return typed results
-   */
-  async execute() {
-    if (!this.fromTable) {
-      throw new Error("[drizzle-multitenant] No table specified. Use .from() first.");
-    }
-    const sqlQuery = this.buildSql();
-    const result = await this.tenantDb.execute(sqlQuery);
-    return result.rows;
-  }
-  /**
-   * Add a join to the query
-   */
-  addJoin(table, condition, type) {
-    const isShared = isSharedTable(table, this.sharedTables);
-    this.joins.push({
-      table,
-      isShared,
-      schemaName: isShared ? this.sharedSchemaName : this.tenantSchemaName,
-      condition,
-      type
-    });
-    return this;
-  }
-  /**
-   * Build the SQL query
-   */
-  buildSql() {
-    if (!this.fromTable) {
-      throw new Error("[drizzle-multitenant] No table specified");
-    }
-    const parts = [];
-    const selectParts = Object.entries(this.selectFields).map(([alias, column]) => {
-      const columnName = column.name;
-      const tableName = this.getTableAliasForColumn(column);
-      if (tableName) {
-        return sql`${sql.raw(`"${tableName}"."${columnName}"`)} as ${sql.raw(`"${alias}"`)}`;
-      }
-      return sql`${sql.raw(`"${columnName}"`)} as ${sql.raw(`"${alias}"`)}`;
-    });
-    if (selectParts.length === 0) {
-      parts.push(sql`SELECT *`);
-    } else {
-      parts.push(sql`SELECT ${sql.join(selectParts, sql`, `)}`);
-    }
-    const fromTableName = getTableName(this.fromTable.table);
-    const fromTableRef = `"${this.fromTable.schemaName}"."${fromTableName}"`;
-    parts.push(sql` FROM ${sql.raw(fromTableRef)} "${sql.raw(fromTableName)}"`);
-    for (const join2 of this.joins) {
-      const joinTableName = getTableName(join2.table);
-      const joinTableRef = `"${join2.schemaName}"."${joinTableName}"`;
-      const joinKeyword = this.getJoinKeyword(join2.type);
-      parts.push(
-        sql` ${sql.raw(joinKeyword)} ${sql.raw(joinTableRef)} "${sql.raw(joinTableName)}" ON ${join2.condition}`
-      );
-    }
-    if (this.whereCondition) {
-      parts.push(sql` WHERE ${this.whereCondition}`);
-    }
-    if (this.orderByFields.length > 0) {
-      parts.push(sql` ORDER BY ${sql.join(this.orderByFields, sql`, `)}`);
-    }
-    if (this.limitValue !== null) {
-      parts.push(sql` LIMIT ${sql.raw(this.limitValue.toString())}`);
-    }
-    if (this.offsetValue !== null) {
-      parts.push(sql` OFFSET ${sql.raw(this.offsetValue.toString())}`);
-    }
-    return sql.join(parts, sql``);
-  }
-  /**
-   * Get table alias for a column (used in SELECT)
-   */
-  getTableAliasForColumn(column) {
-    const columnTable = column.table;
-    if (columnTable) {
-      return getTableName(columnTable);
-    }
-    return null;
-  }
-  /**
-   * Get SQL keyword for join type
-   */
-  getJoinKeyword(type) {
-    switch (type) {
-      case "inner":
-        return "INNER JOIN";
-      case "left":
-        return "LEFT JOIN";
-      case "right":
-        return "RIGHT JOIN";
-      case "full":
-        return "FULL OUTER JOIN";
-    }
-  }
-};
-function withShared(tenantDb, _sharedDb, schemas, options) {
-  const sharedTables = extractTablesFromSchema(schemas.shared);
-  return new WithSharedQueryBuilder(
-    tenantDb,
-    sharedTables,
-    options?.tenantSchema ?? "tenant",
-    options?.sharedSchema ?? "public"
-  );
-}
-
-export { CrossSchemaQueryBuilder, DEFAULT_CONFIG, Migrator, WithSharedQueryBuilder, buildCrossSchemaSelect, calculateDelay, createCrossSchemaQuery, createMigrator, createRetrier, createTenantContext, createTenantManager, crossSchemaRaw, defineConfig, isRetryableError, withRetry, withShared, withSharedLookup };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+    `);}async migrationsTableExists(e,t){let n=await e.query(`SELECT 1 FROM information_schema.tables
+       WHERE table_schema = $1 AND table_name = $2`,[t,this.migrationsTable]);return n.rowCount!==null&&n.rowCount>0}getMigrationsTableName(){return this.migrationsTable}};async function ee(c,e,t){return (await c.query(`SELECT
+      column_name,
+      data_type,
+      udt_name,
+      is_nullable,
+      column_default,
+      character_maximum_length,
+      numeric_precision,
+      numeric_scale,
+      ordinal_position
+     FROM information_schema.columns
+     WHERE table_schema = $1 AND table_name = $2
+     ORDER BY ordinal_position`,[e,t])).rows.map(a=>({name:a.column_name,dataType:a.data_type,udtName:a.udt_name,isNullable:a.is_nullable==="YES",columnDefault:a.column_default,characterMaximumLength:a.character_maximum_length,numericPrecision:a.numeric_precision,numericScale:a.numeric_scale,ordinalPosition:a.ordinal_position}))}function Z(c){return c===null?null:c.replace(/^'(.+)'::.+$/,"$1").replace(/^(.+)::.+$/,"$1").trim()}function te(c,e){let t=[],n=new Map(c.map(r=>[r.name,r])),a=new Map(e.map(r=>[r.name,r]));for(let r of c){let s=a.get(r.name);if(!s){t.push({column:r.name,type:"missing",expected:r.dataType,description:`Column "${r.name}" (${r.dataType}) is missing`});continue}r.udtName!==s.udtName&&t.push({column:r.name,type:"type_mismatch",expected:r.udtName,actual:s.udtName,description:`Column "${r.name}" type mismatch: expected "${r.udtName}", got "${s.udtName}"`}),r.isNullable!==s.isNullable&&t.push({column:r.name,type:"nullable_mismatch",expected:r.isNullable,actual:s.isNullable,description:`Column "${r.name}" nullable mismatch: expected ${r.isNullable?"NULL":"NOT NULL"}, got ${s.isNullable?"NULL":"NOT NULL"}`});let i=Z(r.columnDefault),o=Z(s.columnDefault);i!==o&&t.push({column:r.name,type:"default_mismatch",expected:r.columnDefault,actual:s.columnDefault,description:`Column "${r.name}" default mismatch: expected "${r.columnDefault??"none"}", got "${s.columnDefault??"none"}"`});}for(let r of e)n.has(r.name)||t.push({column:r.name,type:"extra",actual:r.dataType,description:`Extra column "${r.name}" (${r.dataType}) not in reference`});return t}async function ne(c,e,t){let n=await c.query(`SELECT indexname, indexdef
+     FROM pg_indexes
+     WHERE schemaname = $1 AND tablename = $2
+     ORDER BY indexname`,[e,t]),a=await c.query(`SELECT
+      i.relname as indexname,
+      a.attname as column_name,
+      ix.indisunique as is_unique,
+      ix.indisprimary as is_primary
+     FROM pg_class t
+     JOIN pg_index ix ON t.oid = ix.indrelid
+     JOIN pg_class i ON i.oid = ix.indexrelid
+     JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+     JOIN pg_namespace n ON n.oid = t.relnamespace
+     WHERE n.nspname = $1 AND t.relname = $2
+     ORDER BY i.relname, a.attnum`,[e,t]),r=new Map;for(let s of a.rows){let i=r.get(s.indexname);i?i.columns.push(s.column_name):r.set(s.indexname,{columns:[s.column_name],isUnique:s.is_unique,isPrimary:s.is_primary});}return n.rows.map(s=>{let i=r.get(s.indexname);return {name:s.indexname,columns:i?.columns??[],isUnique:i?.isUnique??false,isPrimary:i?.isPrimary??false,definition:s.indexdef}})}function re(c,e){let t=[],n=new Map(c.map(r=>[r.name,r])),a=new Map(e.map(r=>[r.name,r]));for(let r of c){let s=a.get(r.name);if(!s){t.push({index:r.name,type:"missing",expected:r.definition,description:`Index "${r.name}" is missing`});continue}let i=r.columns.sort().join(","),o=s.columns.sort().join(",");(i!==o||r.isUnique!==s.isUnique)&&t.push({index:r.name,type:"definition_mismatch",expected:r.definition,actual:s.definition,description:`Index "${r.name}" definition differs`});}for(let r of e)n.has(r.name)||t.push({index:r.name,type:"extra",actual:r.definition,description:`Extra index "${r.name}" not in reference`});return t}async function ae(c,e,t){let n=await c.query(`SELECT
+      tc.constraint_name,
+      tc.constraint_type,
+      kcu.column_name,
+      ccu.table_schema as foreign_table_schema,
+      ccu.table_name as foreign_table_name,
+      ccu.column_name as foreign_column_name,
+      cc.check_clause
+     FROM information_schema.table_constraints tc
+     LEFT JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     LEFT JOIN information_schema.constraint_column_usage ccu
+       ON tc.constraint_name = ccu.constraint_name
+       AND tc.constraint_type = 'FOREIGN KEY'
+     LEFT JOIN information_schema.check_constraints cc
+       ON tc.constraint_name = cc.constraint_name
+       AND tc.constraint_type = 'CHECK'
+     WHERE tc.table_schema = $1 AND tc.table_name = $2
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,[e,t]),a=new Map;for(let r of n.rows){let s=a.get(r.constraint_name);if(s)r.column_name&&!s.columns.includes(r.column_name)&&s.columns.push(r.column_name),r.foreign_column_name&&s.foreignColumns&&!s.foreignColumns.includes(r.foreign_column_name)&&s.foreignColumns.push(r.foreign_column_name);else {let i={name:r.constraint_name,type:r.constraint_type,columns:r.column_name?[r.column_name]:[]};r.foreign_table_name&&(i.foreignTable=r.foreign_table_name),r.foreign_column_name&&(i.foreignColumns=[r.foreign_column_name]),r.check_clause&&(i.checkExpression=r.check_clause),a.set(r.constraint_name,i);}}return Array.from(a.values())}function se(c,e){let t=[],n=new Map(c.map(r=>[r.name,r])),a=new Map(e.map(r=>[r.name,r]));for(let r of c){let s=a.get(r.name);if(!s){t.push({constraint:r.name,type:"missing",expected:`${r.type} on (${r.columns.join(", ")})`,description:`Constraint "${r.name}" (${r.type}) is missing`});continue}let i=r.columns.sort().join(","),o=s.columns.sort().join(",");(r.type!==s.type||i!==o)&&t.push({constraint:r.name,type:"definition_mismatch",expected:`${r.type} on (${r.columns.join(", ")})`,actual:`${s.type} on (${s.columns.join(", ")})`,description:`Constraint "${r.name}" definition differs`});}for(let r of e)n.has(r.name)||t.push({constraint:r.name,type:"extra",actual:`${r.type} on (${r.columns.join(", ")})`,description:`Extra constraint "${r.name}" (${r.type}) not in reference`});return t}var Ee="__drizzle_migrations",$=class{constructor(e,t,n){this.tenantConfig=e;this.schemaManager=t;this.driftConfig=n;this.migrationsTable=n.migrationsTable??Ee;}migrationsTable;getSchemaName(e){return this.tenantConfig.isolation.schemaNameTemplate(e)}async createPool(e){return this.schemaManager.createPool(e)}async detectDrift(e={}){let t=Date.now(),{concurrency:n=10,includeIndexes:a=true,includeConstraints:r=true,excludeTables:s=[this.migrationsTable],onProgress:i}=e,o=e.tenantIds??await this.driftConfig.tenantDiscovery();if(o.length===0)return {referenceTenant:"",total:0,noDrift:0,withDrift:0,error:0,details:[],timestamp:new Date().toISOString(),durationMs:Date.now()-t};let m=e.referenceTenant??o[0];i?.(m,"starting"),i?.(m,"introspecting");let l=await this.introspectSchema(m,{includeIndexes:a,includeConstraints:r,excludeTables:s});if(!l)return {referenceTenant:m,total:o.length,noDrift:0,withDrift:0,error:o.length,details:o.map(d=>({tenantId:d,schemaName:this.getSchemaName(d),hasDrift:false,tables:[],issueCount:0,error:d===m?"Failed to introspect reference tenant":"Reference tenant introspection failed"})),timestamp:new Date().toISOString(),durationMs:Date.now()-t};i?.(m,"completed");let u=o.filter(d=>d!==m),h=[];h.push({tenantId:m,schemaName:l.schemaName,hasDrift:false,tables:[],issueCount:0});for(let d=0;d<u.length;d+=n){let g=u.slice(d,d+n),w=await Promise.all(g.map(async y=>{try{i?.(y,"starting"),i?.(y,"introspecting");let b=await this.introspectSchema(y,{includeIndexes:a,includeConstraints:r,excludeTables:s});if(!b)return i?.(y,"failed"),{tenantId:y,schemaName:this.getSchemaName(y),hasDrift:!1,tables:[],issueCount:0,error:"Failed to introspect schema"};i?.(y,"comparing");let S=this.compareSchemas(l,b,{includeIndexes:a,includeConstraints:r});return i?.(y,"completed"),S}catch(b){return i?.(y,"failed"),{tenantId:y,schemaName:this.getSchemaName(y),hasDrift:false,tables:[],issueCount:0,error:b.message}}}));h.push(...w);}return {referenceTenant:m,total:h.length,noDrift:h.filter(d=>!d.hasDrift&&!d.error).length,withDrift:h.filter(d=>d.hasDrift&&!d.error).length,error:h.filter(d=>!!d.error).length,details:h,timestamp:new Date().toISOString(),durationMs:Date.now()-t}}async compareTenant(e,t,n={}){let{includeIndexes:a=true,includeConstraints:r=true,excludeTables:s=[this.migrationsTable]}=n,i=await this.introspectSchema(t,{includeIndexes:a,includeConstraints:r,excludeTables:s});if(!i)return {tenantId:e,schemaName:this.getSchemaName(e),hasDrift:false,tables:[],issueCount:0,error:"Failed to introspect reference tenant"};let o=await this.introspectSchema(e,{includeIndexes:a,includeConstraints:r,excludeTables:s});return o?this.compareSchemas(i,o,{includeIndexes:a,includeConstraints:r}):{tenantId:e,schemaName:this.getSchemaName(e),hasDrift:false,tables:[],issueCount:0,error:"Failed to introspect tenant schema"}}async introspectSchema(e,t={}){let n=this.getSchemaName(e),a=await this.createPool(n);try{let r=await this.introspectTables(a,n,t);return {tenantId:e,schemaName:n,tables:r,introspectedAt:new Date}}catch{return null}finally{await a.end();}}compareSchemas(e,t,n={}){let{includeIndexes:a=true,includeConstraints:r=true}=n,s=[],i=0,o=new Map(e.tables.map(l=>[l.name,l])),m=new Map(t.tables.map(l=>[l.name,l]));for(let l of e.tables){let u=m.get(l.name);if(!u){s.push({table:l.name,status:"missing",columns:l.columns.map(y=>({column:y.name,type:"missing",expected:y.dataType,description:`Column "${y.name}" (${y.dataType}) is missing`})),indexes:[],constraints:[]}),i+=l.columns.length;continue}let h=te(l.columns,u.columns),d=a?re(l.indexes,u.indexes):[],g=r?se(l.constraints,u.constraints):[],w=h.length+d.length+g.length;i+=w,w>0&&s.push({table:l.name,status:"drifted",columns:h,indexes:d,constraints:g});}for(let l of t.tables)o.has(l.name)||(s.push({table:l.name,status:"extra",columns:l.columns.map(u=>({column:u.name,type:"extra",actual:u.dataType,description:`Extra column "${u.name}" (${u.dataType}) not in reference`})),indexes:[],constraints:[]}),i+=l.columns.length);return {tenantId:t.tenantId,schemaName:t.schemaName,hasDrift:i>0,tables:s,issueCount:i}}async introspectTables(e,t,n){let{includeIndexes:a=true,includeConstraints:r=true,excludeTables:s=[]}=n,i=await e.query(`SELECT table_name
+       FROM information_schema.tables
+       WHERE table_schema = $1
+         AND table_type = 'BASE TABLE'
+       ORDER BY table_name`,[t]),o=[];for(let m of i.rows){if(s.includes(m.table_name))continue;let l=await ee(e,t,m.table_name),u=a?await ne(e,t,m.table_name):[],h=r?await ae(e,t,m.table_name):[];o.push({name:m.table_name,columns:l,indexes:u,constraints:h});}return o}};var A=class{constructor(e,t){this.config=e;this.deps=t;}async seedTenant(e,t){let n=Date.now(),a=this.deps.schemaNameTemplate(e),r=await this.deps.createPool(a);try{let s=drizzle(r,{schema:this.deps.tenantSchema});return await t(s,e),{tenantId:e,schemaName:a,success:!0,durationMs:Date.now()-n}}catch(s){return {tenantId:e,schemaName:a,success:false,error:s.message,durationMs:Date.now()-n}}finally{await r.end();}}async seedAll(e,t={}){let{concurrency:n=10,onProgress:a,onError:r}=t,s=await this.config.tenantDiscovery(),i=[],o=false;for(let m=0;m<s.length&&!o;m+=n){let l=s.slice(m,m+n),u=await Promise.all(l.map(async h=>{if(o)return this.createSkippedResult(h);try{a?.(h,"starting"),a?.(h,"seeding");let d=await this.seedTenant(h,e);return a?.(h,d.success?"completed":"failed"),d}catch(d){return a?.(h,"failed"),r?.(h,d)==="abort"&&(o=true),this.createErrorResult(h,d)}}));i.push(...u);}if(o){let m=s.slice(i.length);for(let l of m)i.push(this.createSkippedResult(l));}return this.aggregateResults(i)}async seedTenants(e,t,n={}){let{concurrency:a=10,onProgress:r,onError:s}=n,i=[];for(let o=0;o<e.length;o+=a){let m=e.slice(o,o+a),l=await Promise.all(m.map(async u=>{try{r?.(u,"starting"),r?.(u,"seeding");let h=await this.seedTenant(u,t);return r?.(u,h.success?"completed":"failed"),h}catch(h){return r?.(u,"failed"),s?.(u,h),this.createErrorResult(u,h)}}));i.push(...l);}return this.aggregateResults(i)}createSkippedResult(e){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,error:"Skipped due to abort",durationMs:0}}createErrorResult(e,t){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,error:t.message,durationMs:0}}aggregateResults(e){return {total:e.length,succeeded:e.filter(t=>t.success).length,failed:e.filter(t=>!t.success&&t.error!=="Skipped due to abort").length,skipped:e.filter(t=>t.error==="Skipped due to abort").length,details:e}}};var Ne="public",v=class{constructor(e,t){this.config=e;this.deps=t;this.schemaName=e.schemaName??Ne;}schemaName;async seed(e){let t=Date.now(),n=await this.deps.createPool();try{this.config.hooks?.onStart?.();let a=drizzle(n,{schema:this.deps.sharedSchema});return await e(a),this.config.hooks?.onComplete?.(),{schemaName:this.schemaName,success:!0,durationMs:Date.now()-t}}catch(a){return this.config.hooks?.onError?.(a),{schemaName:this.schemaName,success:false,error:a.message,durationMs:Date.now()-t}}finally{await n.end();}}};var F=class{constructor(e,t){this.config=e;this.deps=t;}async getSyncStatus(){let e=await this.config.tenantDiscovery(),t=await this.deps.loadMigrations(),n=[];for(let a of e)n.push(await this.getTenantSyncStatus(a,t));return {total:n.length,inSync:n.filter(a=>a.inSync&&!a.error).length,outOfSync:n.filter(a=>!a.inSync&&!a.error).length,error:n.filter(a=>!!a.error).length,details:n}}async getTenantSyncStatus(e,t){let n=this.deps.schemaNameTemplate(e),a=await this.deps.createPool(n);try{let r=t??await this.deps.loadMigrations(),s=new Set(r.map(g=>g.name)),i=new Set(r.map(g=>g.hash));if(!await this.deps.migrationsTableExists(a,n))return {tenantId:e,schemaName:n,missing:r.map(g=>g.name),orphans:[],inSync:r.length===0,format:null};let m=await this.deps.getOrDetectFormat(a,n),l=await this.getAppliedMigrations(a,n,m),u=new Set(l.map(g=>g.identifier)),h=r.filter(g=>!this.isMigrationApplied(g,u,m)).map(g=>g.name),d=l.filter(g=>(m.columns.identifier==="name"||!i.has(g.identifier))&&!s.has(g.identifier)).map(g=>g.identifier);return {tenantId:e,schemaName:n,missing:h,orphans:d,inSync:h.length===0&&d.length===0,format:m.format}}catch(r){return {tenantId:e,schemaName:n,missing:[],orphans:[],inSync:false,format:null,error:r.message}}finally{await a.end();}}async markMissing(e){let t=Date.now(),n=this.deps.schemaNameTemplate(e),a=[],r=await this.deps.createPool(n);try{let s=await this.getTenantSyncStatus(e);if(s.error)return {tenantId:e,schemaName:n,success:!1,markedMigrations:[],removedOrphans:[],error:s.error,durationMs:Date.now()-t};if(s.missing.length===0)return {tenantId:e,schemaName:n,success:!0,markedMigrations:[],removedOrphans:[],durationMs:Date.now()-t};let i=await this.deps.getOrDetectFormat(r,n);await this.deps.ensureMigrationsTable(r,n,i);let o=await this.deps.loadMigrations(),m=new Set(s.missing);for(let l of o)m.has(l.name)&&(await this.recordMigration(r,n,l,i),a.push(l.name));return {tenantId:e,schemaName:n,success:!0,markedMigrations:a,removedOrphans:[],durationMs:Date.now()-t}}catch(s){return {tenantId:e,schemaName:n,success:false,markedMigrations:a,removedOrphans:[],error:s.message,durationMs:Date.now()-t}}finally{await r.end();}}async markAllMissing(e={}){let{concurrency:t=10,onProgress:n,onError:a}=e,r=await this.config.tenantDiscovery(),s=[],i=false;for(let o=0;o<r.length&&!i;o+=t){let m=r.slice(o,o+t),l=await Promise.all(m.map(async u=>{if(i)return this.createSkippedSyncResult(u);try{n?.(u,"starting");let h=await this.markMissing(u);return n?.(u,h.success?"completed":"failed"),h}catch(h){return n?.(u,"failed"),a?.(u,h)==="abort"&&(i=true),this.createErrorSyncResult(u,h)}}));s.push(...l);}return this.aggregateSyncResults(s)}async cleanOrphans(e){let t=Date.now(),n=this.deps.schemaNameTemplate(e),a=[],r=await this.deps.createPool(n);try{let s=await this.getTenantSyncStatus(e);if(s.error)return {tenantId:e,schemaName:n,success:!1,markedMigrations:[],removedOrphans:[],error:s.error,durationMs:Date.now()-t};if(s.orphans.length===0)return {tenantId:e,schemaName:n,success:!0,markedMigrations:[],removedOrphans:[],durationMs:Date.now()-t};let i=await this.deps.getOrDetectFormat(r,n),o=i.columns.identifier;for(let m of s.orphans)await r.query(`DELETE FROM "${n}"."${i.tableName}" WHERE "${o}" = $1`,[m]),a.push(m);return {tenantId:e,schemaName:n,success:!0,markedMigrations:[],removedOrphans:a,durationMs:Date.now()-t}}catch(s){return {tenantId:e,schemaName:n,success:false,markedMigrations:[],removedOrphans:a,error:s.message,durationMs:Date.now()-t}}finally{await r.end();}}async cleanAllOrphans(e={}){let{concurrency:t=10,onProgress:n,onError:a}=e,r=await this.config.tenantDiscovery(),s=[],i=false;for(let o=0;o<r.length&&!i;o+=t){let m=r.slice(o,o+t),l=await Promise.all(m.map(async u=>{if(i)return this.createSkippedSyncResult(u);try{n?.(u,"starting");let h=await this.cleanOrphans(u);return n?.(u,h.success?"completed":"failed"),h}catch(h){return n?.(u,"failed"),a?.(u,h)==="abort"&&(i=true),this.createErrorSyncResult(u,h)}}));s.push(...l);}return this.aggregateSyncResults(s)}async getAppliedMigrations(e,t,n){let a=n.columns.identifier,r=n.columns.timestamp;return (await e.query(`SELECT id, "${a}" as identifier, "${r}" as applied_at
+       FROM "${t}"."${n.tableName}"
+       ORDER BY id`)).rows.map(i=>{let o=n.columns.timestampType==="bigint"?new Date(Number(i.applied_at)):new Date(i.applied_at);return {identifier:i.identifier,appliedAt:o}})}isMigrationApplied(e,t,n){return n.columns.identifier==="name"?t.has(e.name):t.has(e.hash)||t.has(e.name)}async recordMigration(e,t,n,a){let{identifier:r,timestamp:s,timestampType:i}=a.columns,o=r==="name"?n.name:n.hash,m=i==="bigint"?Date.now():new Date;await e.query(`INSERT INTO "${t}"."${a.tableName}" ("${r}", "${s}") VALUES ($1, $2)`,[o,m]);}createSkippedSyncResult(e){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,markedMigrations:[],removedOrphans:[],error:"Skipped due to abort",durationMs:0}}createErrorSyncResult(e,t){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,markedMigrations:[],removedOrphans:[],error:t.message,durationMs:0}}aggregateSyncResults(e){return {total:e.length,succeeded:e.filter(t=>t.success).length,failed:e.filter(t=>!t.success).length,details:e}}};var L=class{constructor(e,t){this.config=e;this.deps=t;}async migrateTenant(e,t,n={}){let a=Date.now(),r=this.deps.schemaNameTemplate(e),s=[],i=await this.deps.createPool(r);try{await this.config.hooks?.beforeTenant?.(e);let o=await this.deps.getOrDetectFormat(i,r);await this.deps.ensureMigrationsTable(i,r,o);let m=t??await this.deps.loadMigrations(),l=await this.getAppliedMigrations(i,r,o),u=new Set(l.map(g=>g.identifier)),h=m.filter(g=>!this.isMigrationApplied(g,u,o));if(n.dryRun)return {tenantId:e,schemaName:r,success:!0,appliedMigrations:h.map(g=>g.name),durationMs:Date.now()-a,format:o.format};for(let g of h){let w=Date.now();n.onProgress?.(e,"migrating",g.name),await this.config.hooks?.beforeMigration?.(e,g.name),await this.applyMigration(i,r,g,o),await this.config.hooks?.afterMigration?.(e,g.name,Date.now()-w),s.push(g.name);}let d={tenantId:e,schemaName:r,success:!0,appliedMigrations:s,durationMs:Date.now()-a,format:o.format};return await this.config.hooks?.afterTenant?.(e,d),d}catch(o){let m={tenantId:e,schemaName:r,success:false,appliedMigrations:s,error:o.message,durationMs:Date.now()-a};return await this.config.hooks?.afterTenant?.(e,m),m}finally{await i.end();}}async markAsApplied(e,t={}){let n=Date.now(),a=this.deps.schemaNameTemplate(e),r=[],s=await this.deps.createPool(a);try{await this.config.hooks?.beforeTenant?.(e);let i=await this.deps.getOrDetectFormat(s,a);await this.deps.ensureMigrationsTable(s,a,i);let o=await this.deps.loadMigrations(),m=await this.getAppliedMigrations(s,a,i),l=new Set(m.map(d=>d.identifier)),u=o.filter(d=>!this.isMigrationApplied(d,l,i));for(let d of u){let g=Date.now();t.onProgress?.(e,"migrating",d.name),await this.config.hooks?.beforeMigration?.(e,d.name),await this.recordMigration(s,a,d,i),await this.config.hooks?.afterMigration?.(e,d.name,Date.now()-g),r.push(d.name);}let h={tenantId:e,schemaName:a,success:!0,appliedMigrations:r,durationMs:Date.now()-n,format:i.format};return await this.config.hooks?.afterTenant?.(e,h),h}catch(i){let o={tenantId:e,schemaName:a,success:false,appliedMigrations:r,error:i.message,durationMs:Date.now()-n};return await this.config.hooks?.afterTenant?.(e,o),o}finally{await s.end();}}async getTenantStatus(e,t){let n=this.deps.schemaNameTemplate(e),a=await this.deps.createPool(n);try{let r=t??await this.deps.loadMigrations();if(!await this.deps.migrationsTableExists(a,n))return {tenantId:e,schemaName:n,appliedCount:0,pendingCount:r.length,pendingMigrations:r.map(u=>u.name),status:r.length>0?"behind":"ok",format:null};let i=await this.deps.getOrDetectFormat(a,n),o=await this.getAppliedMigrations(a,n,i),m=new Set(o.map(u=>u.identifier)),l=r.filter(u=>!this.isMigrationApplied(u,m,i));return {tenantId:e,schemaName:n,appliedCount:o.length,pendingCount:l.length,pendingMigrations:l.map(u=>u.name),status:l.length>0?"behind":"ok",format:i.format}}catch(r){return {tenantId:e,schemaName:n,appliedCount:0,pendingCount:0,pendingMigrations:[],status:"error",error:r.message,format:null}}finally{await a.end();}}async executeMigration(e,t,n,a,r){r?.markOnly?(r.onProgress?.("recording"),await this.recordMigration(e,t,n,a)):(r?.onProgress?.("applying"),await this.applyMigration(e,t,n,a));}async executeMigrations(e,t,n,a,r){let s=[];for(let i of n)await this.executeMigration(e,t,i,a,r),s.push(i.name);return s}async recordMigration(e,t,n,a){let{identifier:r,timestamp:s,timestampType:i}=a.columns,o=r==="name"?n.name:n.hash,m=i==="bigint"?Date.now():new Date;await e.query(`INSERT INTO "${t}"."${a.tableName}" ("${r}", "${s}") VALUES ($1, $2)`,[o,m]);}async getAppliedMigrations(e,t,n){let a=n.columns.identifier,r=n.columns.timestamp;return (await e.query(`SELECT id, "${a}" as identifier, "${r}" as applied_at
+       FROM "${t}"."${n.tableName}"
+       ORDER BY id`)).rows.map(i=>{let o=n.columns.timestampType==="bigint"?new Date(Number(i.applied_at)):new Date(i.applied_at);return {identifier:i.identifier,...n.columns.identifier==="name"?{name:i.identifier}:{hash:i.identifier},appliedAt:o}})}async getPendingMigrations(e,t,n,a){let r=await this.getAppliedMigrations(e,t,a),s=new Set(r.map(i=>i.identifier));return n.filter(i=>!this.isMigrationApplied(i,s,a))}isMigrationApplied(e,t,n){return n.columns.identifier==="name"?t.has(e.name):t.has(e.hash)||t.has(e.name)}async applyMigration(e,t,n,a){let r=await e.connect();try{await r.query("BEGIN"),await r.query(n.sql);let{identifier:s,timestamp:i,timestampType:o}=a.columns,m=s==="name"?n.name:n.hash,l=o==="bigint"?Date.now():new Date;await r.query(`INSERT INTO "${t}"."${a.tableName}" ("${s}", "${i}") VALUES ($1, $2)`,[m,l]),await r.query("COMMIT");}catch(s){throw await r.query("ROLLBACK"),s}finally{r.release();}}};var I=class{constructor(e,t,n){this.config=e;this.executor=t;this.loadMigrations=n;}async migrateAll(e={}){let{concurrency:t=10,onProgress:n,onError:a,dryRun:r=false}=e,s=await this.config.tenantDiscovery(),i=await this.loadMigrations(),o=[],m=false;for(let l=0;l<s.length&&!m;l+=t){let u=s.slice(l,l+t),h=await Promise.all(u.map(async d=>{if(m)return this.createSkippedResult(d);try{n?.(d,"starting");let g=await this.executor.migrateTenant(d,i,{dryRun:r,onProgress:n});return n?.(d,g.success?"completed":"failed"),g}catch(g){return n?.(d,"failed"),a?.(d,g)==="abort"&&(m=true),this.createErrorResult(d,g)}}));o.push(...h);}if(m){let l=s.slice(o.length);for(let u of l)o.push(this.createSkippedResult(u));}return this.aggregateResults(o)}async migrateTenants(e,t={}){let n=await this.loadMigrations(),a=[],{concurrency:r=10,onProgress:s,onError:i,dryRun:o=false}=t;for(let m=0;m<e.length;m+=r){let l=e.slice(m,m+r),u=await Promise.all(l.map(async h=>{try{s?.(h,"starting");let d=await this.executor.migrateTenant(h,n,{dryRun:o,onProgress:s});return s?.(h,d.success?"completed":"failed"),d}catch(d){return s?.(h,"failed"),i?.(h,d),this.createErrorResult(h,d)}}));a.push(...u);}return this.aggregateResults(a)}async markAllAsApplied(e={}){let{concurrency:t=10,onProgress:n,onError:a}=e,r=await this.config.tenantDiscovery(),s=[],i=false;for(let o=0;o<r.length&&!i;o+=t){let m=r.slice(o,o+t),l=await Promise.all(m.map(async u=>{if(i)return this.createSkippedResult(u);try{n?.(u,"starting");let h=await this.executor.markAsApplied(u,{onProgress:n});return n?.(u,h.success?"completed":"failed"),h}catch(h){return n?.(u,"failed"),a?.(u,h)==="abort"&&(i=true),this.createErrorResult(u,h)}}));s.push(...l);}if(i){let o=r.slice(s.length);for(let m of o)s.push(this.createSkippedResult(m));}return this.aggregateResults(s)}async getStatus(){let e=await this.config.tenantDiscovery(),t=await this.loadMigrations(),n=[];for(let a of e)n.push(await this.executor.getTenantStatus(a,t));return n}createSkippedResult(e){return {tenantId:e,schemaName:"",success:false,appliedMigrations:[],error:"Skipped due to abort",durationMs:0}}createErrorResult(e,t){return {tenantId:e,schemaName:"",success:false,appliedMigrations:[],error:t.message,durationMs:0}}aggregateResults(e){return {total:e.length,succeeded:e.filter(t=>t.success).length,failed:e.filter(t=>!t.success&&t.error!=="Skipped due to abort").length,skipped:e.filter(t=>t.error==="Skipped due to abort").length,details:e}}};async function ie(c,e,t=[]){let n=t.length>0?t.map((r,s)=>`$${s+2}`).join(", "):"''::text";return (await c.query(`SELECT table_name
+     FROM information_schema.tables
+     WHERE table_schema = $1
+       AND table_type = 'BASE TABLE'
+       AND table_name NOT IN (${n})
+     ORDER BY table_name`,[e,...t])).rows.map(r=>r.table_name)}async function ke(c,e,t){return (await c.query(`SELECT
+      column_name,
+      data_type,
+      udt_name,
+      is_nullable,
+      column_default,
+      character_maximum_length,
+      numeric_precision,
+      numeric_scale
+     FROM information_schema.columns
+     WHERE table_schema = $1 AND table_name = $2
+     ORDER BY ordinal_position`,[e,t])).rows.map(a=>({columnName:a.column_name,dataType:a.data_type,udtName:a.udt_name,isNullable:a.is_nullable==="YES",columnDefault:a.column_default,characterMaximumLength:a.character_maximum_length,numericPrecision:a.numeric_precision,numericScale:a.numeric_scale}))}async function Oe(c,e,t){let a=(await ke(c,e,t)).map(r=>{let s=r.udtName;r.dataType==="character varying"&&r.characterMaximumLength?s=`varchar(${r.characterMaximumLength})`:r.dataType==="character"&&r.characterMaximumLength?s=`char(${r.characterMaximumLength})`:r.dataType==="numeric"&&r.numericPrecision?s=`numeric(${r.numericPrecision}${r.numericScale?`, ${r.numericScale}`:""})`:r.dataType==="ARRAY"&&(s=r.udtName.replace(/^_/,"")+"[]");let i=`"${r.columnName}" ${s}`;if(r.isNullable||(i+=" NOT NULL"),r.columnDefault){let o=r.columnDefault.replace(new RegExp(`"?${e}"?\\.`,"g"),"");i+=` DEFAULT ${o}`;}return i});return `CREATE TABLE IF NOT EXISTS "${t}" (
+  ${a.join(`,
+  `)}
+)`}async function $e(c,e,t,n){return (await c.query(`SELECT indexname, indexdef
+     FROM pg_indexes
+     WHERE schemaname = $1 AND tablename = $2
+       AND indexname NOT LIKE '%_pkey'`,[e,n])).rows.map(r=>r.indexdef.replace(new RegExp(`ON "${e}"\\."`,"g"),`ON "${t}"."`).replace(new RegExp(`"${e}"\\."`,"g"),`"${t}"."`))}async function Ae(c,e,t){let n=await c.query(`SELECT
+      tc.constraint_name,
+      kcu.column_name
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     WHERE tc.table_schema = $1
+       AND tc.table_name = $2
+       AND tc.constraint_type = 'PRIMARY KEY'
+     ORDER BY kcu.ordinal_position`,[e,t]);if(n.rows.length===0)return null;let a=n.rows.map(s=>`"${s.column_name}"`).join(", "),r=n.rows[0].constraint_name;return `ALTER TABLE "${t}" ADD CONSTRAINT "${r}" PRIMARY KEY (${a})`}async function ve(c,e,t,n){let a=await c.query(`SELECT
+      tc.constraint_name,
+      kcu.column_name,
+      ccu.table_name as foreign_table_name,
+      ccu.column_name as foreign_column_name,
+      rc.update_rule,
+      rc.delete_rule
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     JOIN information_schema.constraint_column_usage ccu
+       ON tc.constraint_name = ccu.constraint_name
+       AND tc.table_schema = ccu.table_schema
+     JOIN information_schema.referential_constraints rc
+       ON tc.constraint_name = rc.constraint_name
+       AND tc.table_schema = rc.constraint_schema
+     WHERE tc.table_schema = $1
+       AND tc.table_name = $2
+       AND tc.constraint_type = 'FOREIGN KEY'
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,[e,n]),r=new Map;for(let s of a.rows){let i=r.get(s.constraint_name);i?(i.columns.push(s.column_name),i.foreignColumns.push(s.foreign_column_name)):r.set(s.constraint_name,{columns:[s.column_name],foreignTable:s.foreign_table_name,foreignColumns:[s.foreign_column_name],updateRule:s.update_rule,deleteRule:s.delete_rule});}return Array.from(r.entries()).map(([s,i])=>{let o=i.columns.map(u=>`"${u}"`).join(", "),m=i.foreignColumns.map(u=>`"${u}"`).join(", "),l=`ALTER TABLE "${t}"."${n}" `;return l+=`ADD CONSTRAINT "${s}" FOREIGN KEY (${o}) `,l+=`REFERENCES "${t}"."${i.foreignTable}" (${m})`,i.updateRule!=="NO ACTION"&&(l+=` ON UPDATE ${i.updateRule}`),i.deleteRule!=="NO ACTION"&&(l+=` ON DELETE ${i.deleteRule}`),l})}async function Fe(c,e,t){let n=await c.query(`SELECT
+      tc.constraint_name,
+      kcu.column_name
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.key_column_usage kcu
+       ON tc.constraint_name = kcu.constraint_name
+       AND tc.table_schema = kcu.table_schema
+     WHERE tc.table_schema = $1
+       AND tc.table_name = $2
+       AND tc.constraint_type = 'UNIQUE'
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,[e,t]),a=new Map;for(let r of n.rows){let s=a.get(r.constraint_name);s?s.push(r.column_name):a.set(r.constraint_name,[r.column_name]);}return Array.from(a.entries()).map(([r,s])=>{let i=s.map(o=>`"${o}"`).join(", ");return `ALTER TABLE "${t}" ADD CONSTRAINT "${r}" UNIQUE (${i})`})}async function Le(c,e,t){return (await c.query(`SELECT
+      tc.constraint_name,
+      cc.check_clause
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.check_constraints cc
+       ON tc.constraint_name = cc.constraint_name
+       AND tc.constraint_schema = cc.constraint_schema
+     WHERE tc.table_schema = $1
+       AND tc.table_name = $2
+       AND tc.constraint_type = 'CHECK'
+       AND tc.constraint_name NOT LIKE '%_not_null'`,[e,t])).rows.map(a=>`ALTER TABLE "${t}" ADD CONSTRAINT "${a.constraint_name}" CHECK (${a.check_clause})`)}async function Ie(c,e,t){let n=await c.query(`SELECT count(*) FROM "${e}"."${t}"`);return parseInt(n.rows[0].count,10)}async function oe(c,e,t,n){let[a,r,s,i,o,m,l]=await Promise.all([Oe(c,e,n),$e(c,e,t,n),Ae(c,e,n),Fe(c,e,n),Le(c,e,n),ve(c,e,t,n),Ie(c,e,n)]);return {name:n,createDdl:a,indexDdls:r,constraintDdls:[...s?[s]:[],...i,...o,...m],rowCount:l}}async function He(c,e,t){return (await c.query(`SELECT column_name
+     FROM information_schema.columns
+     WHERE table_schema = $1 AND table_name = $2
+     ORDER BY ordinal_position`,[e,t])).rows.map(a=>a.column_name)}function qe(c){return c===null?"NULL":typeof c=="string"?`'${c.replace(/'/g,"''")}'`:typeof c=="boolean"?c?"TRUE":"FALSE":String(c)}async function je(c,e,t,n,a){let r=await He(c,e,n);if(r.length===0)return 0;let s=a?.[n]??{},i=r.map(u=>{if(u in s){let h=s[u];return `${qe(h)} as "${u}"`}return `"${u}"`}),o=r.map(u=>`"${u}"`).join(", "),m=i.join(", ");return (await c.query(`INSERT INTO "${t}"."${n}" (${o})
+     SELECT ${m}
+     FROM "${e}"."${n}"`)).rowCount??0}async function ze(c,e,t){let n=await c.query(`SELECT DISTINCT
+      tc.table_name,
+      ccu.table_name as foreign_table_name
+     FROM information_schema.table_constraints tc
+     JOIN information_schema.constraint_column_usage ccu
+       ON tc.constraint_name = ccu.constraint_name
+       AND tc.table_schema = ccu.table_schema
+     WHERE tc.table_schema = $1
+       AND tc.constraint_type = 'FOREIGN KEY'
+       AND tc.table_name != ccu.table_name`,[e]),a=new Map,r=new Set(t);for(let l of t)a.set(l,new Set);for(let l of n.rows)r.has(l.table_name)&&r.has(l.foreign_table_name)&&a.get(l.table_name).add(l.foreign_table_name);let s=[],i=new Map,o=[];for(let l of t)i.set(l,0);for(let[l,u]of a)for(let h of u)i.set(h,(i.get(h)??0)+1);for(let[l,u]of i)u===0&&o.push(l);for(;o.length>0;){let l=o.shift();s.push(l);for(let[u,h]of a)if(h.has(l)){h.delete(l);let d=(i.get(u)??0)-1;i.set(u,d),d===0&&o.push(u);}}let m=t.filter(l=>!s.includes(l));return [...s,...m]}async function ce(c,e,t,n,a,r){let s=0,i=await ze(c,e,n);await c.query("SET session_replication_role = replica");try{for(let o=0;o<i.length;o++){let m=i[o];r?.("copying_data",{table:m,progress:o+1,total:i.length});let l=await je(c,e,t,m,a);s+=l;}}finally{await c.query("SET session_replication_role = DEFAULT");}return s}var Be="__drizzle_migrations",H=class{constructor(e,t){this.deps=t;this.migrationsTable=e.migrationsTable??Be;}migrationsTable;async cloneTenant(e,t,n={}){let a=Date.now(),{includeData:r=false,anonymize:s,excludeTables:i=[],onProgress:o}=n,m=this.deps.schemaNameTemplate(e),l=this.deps.schemaNameTemplate(t),u=[this.migrationsTable,...i],h=null,d=null;try{if(o?.("starting"),!await this.deps.schemaExists(e))return this.createErrorResult(e,t,l,`Source tenant "${e}" does not exist`,a);if(await this.deps.schemaExists(t))return this.createErrorResult(e,t,l,`Target tenant "${t}" already exists`,a);o?.("introspecting"),h=await this.deps.createPool(m);let y=await ie(h,m,u);if(y.length===0)return o?.("creating_schema"),await this.deps.createSchema(t),o?.("completed"),{sourceTenant:e,targetTenant:t,targetSchema:l,success:!0,tables:[],durationMs:Date.now()-a};let b=await Promise.all(y.map(M=>oe(h,m,l,M)));await h.end(),h=null,o?.("creating_schema"),await this.deps.createSchema(t),d=await this.deps.createRootPool(),o?.("creating_tables");for(let M of b)await d.query(`SET search_path TO "${l}"; ${M.createDdl}`);o?.("creating_constraints");for(let M of b)for(let D of M.constraintDdls.filter(C=>!C.includes("FOREIGN KEY")))try{await d.query(`SET search_path TO "${l}"; ${D}`);}catch{}o?.("creating_indexes");for(let M of b)for(let D of M.indexDdls)try{await d.query(D);}catch{}let S=0;r&&(o?.("copying_data"),S=await ce(d,m,l,y,s?.enabled?s.rules:void 0,o));for(let M of b)for(let D of M.constraintDdls.filter(C=>C.includes("FOREIGN KEY")))try{await d.query(D);}catch{}o?.("completed");let N={sourceTenant:e,targetTenant:t,targetSchema:l,success:!0,tables:y,durationMs:Date.now()-a};return r&&(N.rowsCopied=S),N}catch(g){return n.onError?.(g),o?.("failed"),this.createErrorResult(e,t,l,g.message,a)}finally{h&&await h.end().catch(()=>{}),d&&await d.end().catch(()=>{});}}createErrorResult(e,t,n,a,r){return {sourceTenant:e,targetTenant:t,targetSchema:n,success:false,error:a,tables:[],durationMs:Date.now()-r}}};var We="public",q=class{constructor(e,t){this.config=e;this.deps=t;this.schemaName=e.schemaName??We;}schemaName;async migrate(e={}){let t=Date.now(),n=[],a=await this.deps.createPool();try{e.onProgress?.("starting"),await this.config.hooks?.beforeMigration?.();let r=await this.deps.getOrDetectFormat(a,this.schemaName);await this.deps.ensureMigrationsTable(a,this.schemaName,r);let s=await this.deps.loadMigrations(),i=await this.getAppliedMigrations(a,r),o=new Set(i.map(l=>l.identifier)),m=s.filter(l=>!this.isMigrationApplied(l,o,r));if(e.dryRun)return {schemaName:this.schemaName,success:!0,appliedMigrations:m.map(l=>l.name),durationMs:Date.now()-t,format:r.format};for(let l of m){let u=Date.now();e.onProgress?.("migrating",l.name),await this.applyMigration(a,l,r),await this.config.hooks?.afterMigration?.(l.name,Date.now()-u),n.push(l.name);}return e.onProgress?.("completed"),{schemaName:this.schemaName,success:!0,appliedMigrations:n,durationMs:Date.now()-t,format:r.format}}catch(r){return e.onProgress?.("failed"),{schemaName:this.schemaName,success:false,appliedMigrations:n,error:r.message,durationMs:Date.now()-t}}finally{await a.end();}}async markAsApplied(e={}){let t=Date.now(),n=[],a=await this.deps.createPool();try{e.onProgress?.("starting");let r=await this.deps.getOrDetectFormat(a,this.schemaName);await this.deps.ensureMigrationsTable(a,this.schemaName,r);let s=await this.deps.loadMigrations(),i=await this.getAppliedMigrations(a,r),o=new Set(i.map(l=>l.identifier)),m=s.filter(l=>!this.isMigrationApplied(l,o,r));for(let l of m)e.onProgress?.("migrating",l.name),await this.recordMigration(a,l,r),n.push(l.name);return e.onProgress?.("completed"),{schemaName:this.schemaName,success:!0,appliedMigrations:n,durationMs:Date.now()-t,format:r.format}}catch(r){return e.onProgress?.("failed"),{schemaName:this.schemaName,success:false,appliedMigrations:n,error:r.message,durationMs:Date.now()-t}}finally{await a.end();}}async getStatus(){let e=await this.deps.createPool();try{let t=await this.deps.loadMigrations();if(!await this.deps.migrationsTableExists(e,this.schemaName))return {schemaName:this.schemaName,appliedCount:0,pendingCount:t.length,pendingMigrations:t.map(o=>o.name),status:t.length>0?"behind":"ok",format:null};let a=await this.deps.getOrDetectFormat(e,this.schemaName),r=await this.getAppliedMigrations(e,a),s=new Set(r.map(o=>o.identifier)),i=t.filter(o=>!this.isMigrationApplied(o,s,a));return {schemaName:this.schemaName,appliedCount:r.length,pendingCount:i.length,pendingMigrations:i.map(o=>o.name),status:i.length>0?"behind":"ok",format:a.format}}catch(t){return {schemaName:this.schemaName,appliedCount:0,pendingCount:0,pendingMigrations:[],status:"error",error:t.message,format:null}}finally{await e.end();}}async getAppliedMigrations(e,t){let n=t.columns.identifier,a=t.columns.timestamp;return (await e.query(`SELECT id, "${n}" as identifier, "${a}" as applied_at
+       FROM "${this.schemaName}"."${t.tableName}"
+       ORDER BY id`)).rows.map(s=>{let i=t.columns.timestampType==="bigint"?new Date(Number(s.applied_at)):new Date(s.applied_at);return {identifier:s.identifier,...t.columns.identifier==="name"?{name:s.identifier}:{hash:s.identifier},appliedAt:i}})}isMigrationApplied(e,t,n){return n.columns.identifier==="name"?t.has(e.name):t.has(e.hash)||t.has(e.name)}async applyMigration(e,t,n){let a=await e.connect();try{await a.query("BEGIN"),await a.query(t.sql);let{identifier:r,timestamp:s,timestampType:i}=n.columns,o=r==="name"?t.name:t.hash,m=i==="bigint"?Date.now():new Date;await a.query(`INSERT INTO "${this.schemaName}"."${n.tableName}" ("${r}", "${s}") VALUES ($1, $2)`,[o,m]),await a.query("COMMIT");}catch(r){throw await a.query("ROLLBACK"),r}finally{a.release();}}async recordMigration(e,t,n){let{identifier:a,timestamp:r,timestampType:s}=n.columns,i=a==="name"?t.name:t.hash,o=s==="bigint"?Date.now():new Date;await e.query(`INSERT INTO "${this.schemaName}"."${n.tableName}" ("${a}", "${r}") VALUES ($1, $2)`,[i,o]);}};var Ue="__drizzle_migrations",ge="__drizzle_shared_migrations",j=class{constructor(e,t){this.migratorConfig=t;if(this.migrationsTable=t.migrationsTable??Ue,this.schemaManager=new O(e,this.migrationsTable),this.driftDetector=new $(e,this.schemaManager,{migrationsTable:this.migrationsTable,tenantDiscovery:t.tenantDiscovery}),this.seeder=new A({tenantDiscovery:t.tenantDiscovery},{createPool:this.schemaManager.createPool.bind(this.schemaManager),schemaNameTemplate:e.isolation.schemaNameTemplate,tenantSchema:e.schemas.tenant}),this.syncManager=new F({tenantDiscovery:t.tenantDiscovery,migrationsFolder:t.migrationsFolder,migrationsTable:this.migrationsTable},{createPool:this.schemaManager.createPool.bind(this.schemaManager),schemaNameTemplate:e.isolation.schemaNameTemplate,migrationsTableExists:this.schemaManager.migrationsTableExists.bind(this.schemaManager),ensureMigrationsTable:this.schemaManager.ensureMigrationsTable.bind(this.schemaManager),getOrDetectFormat:this.getOrDetectFormat.bind(this),loadMigrations:this.loadMigrations.bind(this)}),this.migrationExecutor=new L({hooks:t.hooks},{createPool:this.schemaManager.createPool.bind(this.schemaManager),schemaNameTemplate:e.isolation.schemaNameTemplate,migrationsTableExists:this.schemaManager.migrationsTableExists.bind(this.schemaManager),ensureMigrationsTable:this.schemaManager.ensureMigrationsTable.bind(this.schemaManager),getOrDetectFormat:this.getOrDetectFormat.bind(this),loadMigrations:this.loadMigrations.bind(this)}),this.batchExecutor=new I({tenantDiscovery:t.tenantDiscovery},this.migrationExecutor,this.loadMigrations.bind(this)),this.cloner=new H({migrationsTable:this.migrationsTable},{createPool:this.schemaManager.createPool.bind(this.schemaManager),createRootPool:this.schemaManager.createRootPool.bind(this.schemaManager),schemaNameTemplate:e.isolation.schemaNameTemplate,schemaExists:this.schemaManager.schemaExists.bind(this.schemaManager),createSchema:this.schemaManager.createSchema.bind(this.schemaManager)}),t.sharedMigrationsFolder&&existsSync(t.sharedMigrationsFolder)){let n=t.sharedMigrationsTable??ge,a=t.sharedHooks,r={schemaName:"public",migrationsTable:n};(a?.beforeMigration||a?.afterApply)&&(r.hooks={},a.beforeMigration&&(r.hooks.beforeMigration=a.beforeMigration),a.afterApply&&(r.hooks.afterMigration=a.afterApply)),this.sharedMigrationExecutor=new q(r,{createPool:this.schemaManager.createRootPool.bind(this.schemaManager),migrationsTableExists:this.schemaManager.migrationsTableExists.bind(this.schemaManager),ensureMigrationsTable:this.schemaManager.ensureMigrationsTable.bind(this.schemaManager),getOrDetectFormat:this.getOrDetectSharedFormat.bind(this),loadMigrations:this.loadSharedMigrations.bind(this)});}else this.sharedMigrationExecutor=null;e.schemas.shared?this.sharedSeeder=new v({schemaName:"public"},{createPool:this.schemaManager.createRootPool.bind(this.schemaManager),sharedSchema:e.schemas.shared}):this.sharedSeeder=null;}migrationsTable;schemaManager;driftDetector;seeder;syncManager;migrationExecutor;batchExecutor;cloner;sharedMigrationExecutor;sharedSeeder;async migrateAll(e={}){return this.batchExecutor.migrateAll(e)}async migrateTenant(e,t,n={}){return this.migrationExecutor.migrateTenant(e,t,n)}async migrateTenants(e,t={}){return this.batchExecutor.migrateTenants(e,t)}async getStatus(){return this.batchExecutor.getStatus()}async getTenantStatus(e,t){return this.migrationExecutor.getTenantStatus(e,t)}async createTenant(e,t={}){let{migrate:n=true}=t;await this.schemaManager.createSchema(e),n&&await this.migrateTenant(e);}async dropTenant(e,t={}){await this.schemaManager.dropSchema(e,t);}async tenantExists(e){return this.schemaManager.schemaExists(e)}async cloneTenant(e,t,n={}){return this.cloner.cloneTenant(e,t,n)}async markAsApplied(e,t={}){return this.migrationExecutor.markAsApplied(e,t)}async markAllAsApplied(e={}){return this.batchExecutor.markAllAsApplied(e)}async getSyncStatus(){return this.syncManager.getSyncStatus()}async getTenantSyncStatus(e,t){return this.syncManager.getTenantSyncStatus(e,t)}async markMissing(e){return this.syncManager.markMissing(e)}async markAllMissing(e={}){return this.syncManager.markAllMissing(e)}async cleanOrphans(e){return this.syncManager.cleanOrphans(e)}async cleanAllOrphans(e={}){return this.syncManager.cleanAllOrphans(e)}async seedTenant(e,t){return this.seeder.seedTenant(e,t)}async seedAll(e,t={}){return this.seeder.seedAll(e,t)}async seedTenants(e,t,n={}){return this.seeder.seedTenants(e,t,n)}hasSharedSeeding(){return this.sharedSeeder!==null}async seedShared(e){return this.sharedSeeder?this.sharedSeeder.seed(e):{schemaName:"public",success:false,error:"Shared schema not configured. Set schemas.shared in tenant config.",durationMs:0}}async seedAllWithShared(e,t,n={}){let a=await this.seedShared(e),r=await this.seedAll(t,n);return {shared:a,tenants:r}}async loadMigrations(){let e=await readdir(this.migratorConfig.migrationsFolder),t=[];for(let n of e){if(!n.endsWith(".sql"))continue;let a=join(this.migratorConfig.migrationsFolder,n),r=await readFile(a,"utf-8"),s=n.match(/^(\d+)_/),i=s?.[1]?parseInt(s[1],10):0,o=createHash("sha256").update(r).digest("hex");t.push({name:basename(n,".sql"),path:a,sql:r,timestamp:i,hash:o});}return t.sort((n,a)=>n.timestamp-a.timestamp)}async getOrDetectFormat(e,t){let n=this.migratorConfig.tableFormat??"auto";if(n!=="auto")return _(n,this.migrationsTable);let a=await Y(e,t,this.migrationsTable);if(a)return a;let r=this.migratorConfig.defaultFormat??"name";return _(r,this.migrationsTable)}async loadSharedMigrations(){if(!this.migratorConfig.sharedMigrationsFolder)return [];let e=await readdir(this.migratorConfig.sharedMigrationsFolder),t=[];for(let n of e){if(!n.endsWith(".sql"))continue;let a=join(this.migratorConfig.sharedMigrationsFolder,n),r=await readFile(a,"utf-8"),s=n.match(/^(\d+)_/),i=s?.[1]?parseInt(s[1],10):0,o=createHash("sha256").update(r).digest("hex");t.push({name:basename(n,".sql"),path:a,sql:r,timestamp:i,hash:o});}return t.sort((n,a)=>n.timestamp-a.timestamp)}async getOrDetectSharedFormat(e,t){let n=this.migratorConfig.sharedMigrationsTable??ge,a=this.migratorConfig.tableFormat??"auto";if(a!=="auto")return _(a,n);let r=await Y(e,t,n);if(r)return r;let s=this.migratorConfig.defaultFormat??"name";return _(s,n)}hasSharedMigrations(){return this.sharedMigrationExecutor!==null}async migrateShared(e={}){return this.sharedMigrationExecutor?this.sharedMigrationExecutor.migrate(e):{schemaName:"public",success:false,appliedMigrations:[],error:"Shared migrations not configured. Set sharedMigrationsFolder in migrator config.",durationMs:0}}async getSharedStatus(){return this.sharedMigrationExecutor?this.sharedMigrationExecutor.getStatus():{schemaName:"public",appliedCount:0,pendingCount:0,pendingMigrations:[],status:"error",error:"Shared migrations not configured. Set sharedMigrationsFolder in migrator config.",format:null}}async markSharedAsApplied(e={}){return this.sharedMigrationExecutor?this.sharedMigrationExecutor.markAsApplied(e):{schemaName:"public",success:false,appliedMigrations:[],error:"Shared migrations not configured. Set sharedMigrationsFolder in migrator config.",durationMs:0}}async migrateAllWithShared(e={}){let{sharedOptions:t,...n}=e,a=await this.migrateShared(t??{}),r=await this.migrateAll(n);return {shared:a,tenants:r}}async getSchemaDrift(e={}){return this.driftDetector.detectDrift(e)}async getTenantSchemaDrift(e,t,n={}){return this.driftDetector.compareTenant(e,t,n)}async introspectTenantSchema(e,t={}){return this.driftDetector.introspectSchema(e,t)}};function Qe(c,e){return new j(c,e)}var z=class{constructor(e){this.context=e;}fromTable=null;joins=[];selectFields={};whereCondition=null;orderByFields=[];limitValue=null;offsetValue=null;from(e,t){let n=this.getSchemaName(e);return this.fromTable={table:t,source:e,schemaName:n},this}innerJoin(e,t,n){return this.addJoin(e,t,n,"inner")}leftJoin(e,t,n){return this.addJoin(e,t,n,"left")}rightJoin(e,t,n){return this.addJoin(e,t,n,"right")}fullJoin(e,t,n){return this.addJoin(e,t,n,"full")}select(e){return this.selectFields=e,this}where(e){return this.whereCondition=e,this}orderBy(...e){return this.orderByFields=e,this}limit(e){return this.limitValue=e,this}offset(e){return this.offsetValue=e,this}async execute(){if(!this.fromTable)throw new Error("[drizzle-multitenant] No table specified. Use .from() first.");let e=this.buildSql();return (await this.context.tenantDb.execute(e)).rows}buildSql(){if(!this.fromTable)throw new Error("[drizzle-multitenant] No table specified");let e=[],t=Object.entries(this.selectFields).map(([a,r])=>{let s=r.name;return sql`${sql.raw(`"${s}"`)} as ${sql.raw(`"${a}"`)}`});t.length===0?e.push(sql`SELECT *`):e.push(sql`SELECT ${sql.join(t,sql`, `)}`);let n=this.getFullTableName(this.fromTable.schemaName,this.fromTable.table);e.push(sql` FROM ${sql.raw(n)}`);for(let a of this.joins){let r=this.getFullTableName(a.schemaName,a.table),s=this.getJoinKeyword(a.type);e.push(sql` ${sql.raw(s)} ${sql.raw(r)} ON ${a.condition}`);}return this.whereCondition&&e.push(sql` WHERE ${this.whereCondition}`),this.orderByFields.length>0&&e.push(sql` ORDER BY ${sql.join(this.orderByFields,sql`, `)}`),this.limitValue!==null&&e.push(sql` LIMIT ${sql.raw(this.limitValue.toString())}`),this.offsetValue!==null&&e.push(sql` OFFSET ${sql.raw(this.offsetValue.toString())}`),sql.join(e,sql``)}addJoin(e,t,n,a){let r=this.getSchemaName(e);return this.joins.push({table:t,source:e,schemaName:r,condition:n,type:a}),this}getSchemaName(e){return e==="tenant"?this.context.tenantSchema??"tenant":this.context.sharedSchema??"public"}getFullTableName(e,t){let n=getTableName(t);return `"${e}"."${n}"`}getJoinKeyword(e){switch(e){case "inner":return "INNER JOIN";case "left":return "LEFT JOIN";case "right":return "RIGHT JOIN";case "full":return "FULL OUTER JOIN"}}};function Ye(c){return new z(c)}async function Ve(c){let{tenantDb:e,tenantTable:t,sharedTable:n,foreignKey:a,sharedKey:r="id",sharedFields:s,where:i}=c,o=getTableName(t),m=getTableName(n),u=[`SELECT t.*, ${s.map(g=>`s."${String(g)}"`).join(", ")}`,`FROM "${o}" t`,`LEFT JOIN "public"."${m}" s ON t."${String(a)}" = s."${String(r)}"`];i&&u.push("WHERE");let h=sql.raw(u.join(" "));return (await e.execute(h)).rows}async function Ke(c,e){let{tenantSchema:t,sharedSchema:n,sql:a}=e,r=a.replace(/\$tenant\./g,`"${t}".`).replace(/\$shared\./g,`"${n}".`),s=sql.raw(r);return (await c.execute(s)).rows}function Ge(c,e,t){return {columns:Object.entries(c).map(([r,s])=>`"${s.name}" as "${r}"`),getSchema:()=>e}}function Xe(c){let e=new Set;for(let t of Object.values(c))t&&typeof t=="object"&&"_"in t&&t._?.brand==="Table"&&e.add(t);return e}function pe(c,e){return e.has(c)}var B=class{constructor(e,t,n,a="public"){this.tenantDb=e;this.sharedTables=t;this.tenantSchemaName=n;this.sharedSchemaName=a;}fromTable=null;joins=[];selectFields={};whereCondition=null;orderByFields=[];limitValue=null;offsetValue=null;from(e){let t=pe(e,this.sharedTables);return this.fromTable={table:e,isShared:t,schemaName:t?this.sharedSchemaName:this.tenantSchemaName},this}leftJoin(e,t){return this.addJoin(e,t,"left")}innerJoin(e,t){return this.addJoin(e,t,"inner")}rightJoin(e,t){return this.addJoin(e,t,"right")}fullJoin(e,t){return this.addJoin(e,t,"full")}select(e){return this.selectFields=e,this}where(e){return this.whereCondition=e,this}orderBy(...e){return this.orderByFields=e,this}limit(e){return this.limitValue=e,this}offset(e){return this.offsetValue=e,this}async execute(){if(!this.fromTable)throw new Error("[drizzle-multitenant] No table specified. Use .from() first.");let e=this.buildSql();return (await this.tenantDb.execute(e)).rows}addJoin(e,t,n){let a=pe(e,this.sharedTables);return this.joins.push({table:e,isShared:a,schemaName:a?this.sharedSchemaName:this.tenantSchemaName,condition:t,type:n}),this}buildSql(){if(!this.fromTable)throw new Error("[drizzle-multitenant] No table specified");let e=[],t=Object.entries(this.selectFields).map(([r,s])=>{let i=s.name,o=this.getTableAliasForColumn(s);return o?sql`${sql.raw(`"${o}"."${i}"`)} as ${sql.raw(`"${r}"`)}`:sql`${sql.raw(`"${i}"`)} as ${sql.raw(`"${r}"`)}`});t.length===0?e.push(sql`SELECT *`):e.push(sql`SELECT ${sql.join(t,sql`, `)}`);let n=getTableName(this.fromTable.table),a=`"${this.fromTable.schemaName}"."${n}"`;e.push(sql` FROM ${sql.raw(a)} "${sql.raw(n)}"`);for(let r of this.joins){let s=getTableName(r.table),i=`"${r.schemaName}"."${s}"`,o=this.getJoinKeyword(r.type);e.push(sql` ${sql.raw(o)} ${sql.raw(i)} "${sql.raw(s)}" ON ${r.condition}`);}return this.whereCondition&&e.push(sql` WHERE ${this.whereCondition}`),this.orderByFields.length>0&&e.push(sql` ORDER BY ${sql.join(this.orderByFields,sql`, `)}`),this.limitValue!==null&&e.push(sql` LIMIT ${sql.raw(this.limitValue.toString())}`),this.offsetValue!==null&&e.push(sql` OFFSET ${sql.raw(this.offsetValue.toString())}`),sql.join(e,sql``)}getTableAliasForColumn(e){let t=e.table;return t?getTableName(t):null}getJoinKeyword(e){switch(e){case "inner":return "INNER JOIN";case "left":return "LEFT JOIN";case "right":return "RIGHT JOIN";case "full":return "FULL OUTER JOIN"}}};function Ze(c,e,t,n){let a=Xe(t.shared);return new B(c,a,n?.tenantSchema??"tenant",n?.sharedSchema??"public")}function fe(c){let e=c.message.toLowerCase();return !!(e.includes("econnrefused")||e.includes("econnreset")||e.includes("etimedout")||e.includes("enotfound")||e.includes("connection refused")||e.includes("connection reset")||e.includes("connection terminated")||e.includes("connection timed out")||e.includes("timeout expired")||e.includes("socket hang up")||e.includes("too many connections")||e.includes("sorry, too many clients")||e.includes("the database system is starting up")||e.includes("the database system is shutting down")||e.includes("server closed the connection unexpectedly")||e.includes("could not connect to server")||e.includes("ssl connection")||e.includes("ssl handshake"))}function ye(c,e){let t=e.initialDelayMs*Math.pow(e.backoffMultiplier,c),n=Math.min(t,e.maxDelayMs);if(e.jitter){let a=1+Math.random()*.25;return Math.floor(n*a)}return Math.floor(n)}function et(c){return new Promise(e=>setTimeout(e,c))}async function Te(c,e){let t={maxAttempts:e?.maxAttempts??T.retry.maxAttempts,initialDelayMs:e?.initialDelayMs??T.retry.initialDelayMs,maxDelayMs:e?.maxDelayMs??T.retry.maxDelayMs,backoffMultiplier:e?.backoffMultiplier??T.retry.backoffMultiplier,jitter:e?.jitter??T.retry.jitter,isRetryable:e?.isRetryable??fe,onRetry:e?.onRetry},n=Date.now(),a=null;for(let r=0;r<t.maxAttempts;r++)try{return {result:await c(),attempts:r+1,totalTimeMs:Date.now()-n}}catch(s){if(a=s,r>=t.maxAttempts-1||!t.isRetryable(a))throw a;let o=ye(r,t);t.onRetry?.(r+1,a,o),await et(o);}throw a??new Error("Retry failed with no error")}function tt(c){return e=>Te(e,c)}export{z as CrossSchemaQueryBuilder,T as DEFAULT_CONFIG,j as Migrator,B as WithSharedQueryBuilder,Ge as buildCrossSchemaSelect,ye as calculateDelay,Ye as createCrossSchemaQuery,Qe as createMigrator,tt as createRetrier,De as createTenantContext,Re as createTenantManager,Ke as crossSchemaRaw,Se as defineConfig,fe as isRetryableError,Te as withRetry,Ze as withShared,Ve as withSharedLookup};