drizzle-multitenant 1.0.0

package/dist/index.js

@@ -0,0 +1,935 @@
+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 { 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");
+  }
+}
+
+// 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
+  }
+};
+
+// src/pool.ts
+var PoolManager = class {
+  constructor(config) {
+    this.config = config;
+    const maxPools = config.isolation.maxPools ?? DEFAULT_CONFIG.maxPools;
+    this.pools = new LRUCache({
+      max: maxPools,
+      dispose: (entry, key) => {
+        this.disposePoolEntry(entry, key);
+      },
+      noDisposeOnSet: true
+    });
+  }
+  pools;
+  tenantIdBySchema = /* @__PURE__ */ new Map();
+  sharedPool = null;
+  sharedDb = null;
+  cleanupInterval = null;
+  disposed = false;
+  /**
+   * 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);
+      void this.config.hooks?.onPoolCreated?.(tenantId);
+    }
+    entry.lastAccess = Date.now();
+    return entry.db;
+  }
+  /**
+   * 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 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());
+  }
+  /**
+   * Manually evict a tenant pool
+   */
+  async evictPool(tenantId) {
+    const schemaName = this.config.isolation.schemaNameTemplate(tenantId);
+    const entry = this.pools.get(schemaName);
+    if (entry) {
+      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) => {
+      void this.config.hooks?.onError?.(tenantId, err);
+      await this.evictPool(tenantId);
+    });
+    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);
+    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);
+      }
+    }
+  }
+  /**
+   * 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);
+    },
+    getSharedDb() {
+      return poolManager.getSharedDb();
+    },
+    getSchemaName(tenantId) {
+      return poolManager.getSchemaName(tenantId);
+    },
+    hasPool(tenantId) {
+      return poolManager.hasPool(tenantId);
+    },
+    getPoolCount() {
+      return poolManager.getPoolCount();
+    },
+    getActiveTenantIds() {
+      return poolManager.getActiveTenantIds();
+    },
+    async evictPool(tenantId) {
+      await poolManager.evictPool(tenantId);
+    },
+    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
+  };
+}
+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);
+      await this.ensureMigrationsTable(pool, schemaName);
+      const allMigrations = migrations ?? await this.loadMigrations();
+      const applied = await this.getAppliedMigrations(pool, schemaName);
+      const appliedSet = new Set(applied.map((m) => m.name));
+      const pending = allMigrations.filter((m) => !appliedSet.has(m.name));
+      if (options.dryRun) {
+        return {
+          tenantId,
+          schemaName,
+          success: true,
+          appliedMigrations: pending.map((m) => m.name),
+          durationMs: Date.now() - startTime
+        };
+      }
+      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);
+        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
+      };
+      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"
+        };
+      }
+      const applied = await this.getAppliedMigrations(pool, schemaName);
+      const appliedSet = new Set(applied.map((m) => m.name));
+      const pending = allMigrations.filter((m) => !appliedSet.has(m.name));
+      return {
+        tenantId,
+        schemaName,
+        appliedCount: applied.length,
+        pendingCount: pending.length,
+        pendingMigrations: pending.map((m) => m.name),
+        status: pending.length > 0 ? "behind" : "ok"
+      };
+    } catch (error) {
+      return {
+        tenantId,
+        schemaName,
+        appliedCount: 0,
+        pendingCount: 0,
+        pendingMigrations: [],
+        status: "error",
+        error: error.message
+      };
+    } 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();
+    }
+  }
+  /**
+   * 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;
+      migrations.push({
+        name: basename(file, ".sql"),
+        path: filePath,
+        sql: content,
+        timestamp
+      });
+    }
+    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
+   */
+  async ensureMigrationsTable(pool, schemaName) {
+    await pool.query(`
+      CREATE TABLE IF NOT EXISTS "${schemaName}"."${this.migrationsTable}" (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255) NOT NULL UNIQUE,
+        applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+  }
+  /**
+   * 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) {
+    const result = await pool.query(
+      `SELECT id, name, applied_at FROM "${schemaName}"."${this.migrationsTable}" ORDER BY id`
+    );
+    return result.rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      appliedAt: row.applied_at
+    }));
+  }
+  /**
+   * Apply a migration to a schema
+   */
+  async applyMigration(pool, schemaName, migration) {
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(migration.sql);
+      await client.query(
+        `INSERT INTO "${schemaName}"."${this.migrationsTable}" (name) VALUES ($1)`,
+        [migration.name]
+      );
+      await client.query("COMMIT");
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * 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
+    };
+  }
+};
+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 };
+}
+
+export { CrossSchemaQueryBuilder, DEFAULT_CONFIG, Migrator, buildCrossSchemaSelect, createCrossSchemaQuery, createMigrator, createTenantContext, createTenantManager, crossSchemaRaw, defineConfig, withSharedLookup };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map