drizzle-multitenant 1.2.0 → 1.3.1

package/dist/migrator/index.js

@@ -1,348 +1,16 @@
-import { readdir, readFile } from 'fs/promises';
-import { join, basename } from 'path';
-import { createHash } from 'crypto';
-import { Pool } from 'pg';
-import { drizzle } from 'drizzle-orm/node-postgres';
-
-// src/migrator/migrator.ts
-
-// src/migrator/table-format.ts
-var DEFAULT_FORMAT = {
-  format: "name",
-  tableName: "__drizzle_migrations",
-  columns: {
-    identifier: "name",
-    timestamp: "applied_at",
-    timestampType: "timestamp"
-  }
-};
-var DRIZZLE_KIT_FORMAT = {
-  format: "drizzle-kit",
-  tableName: "__drizzle_migrations",
-  columns: {
-    identifier: "hash",
-    timestamp: "created_at",
-    timestampType: "bigint"
-  }
-};
-async function detectTableFormat(pool, schemaName, tableName) {
-  const tableExists = await pool.query(
-    `SELECT EXISTS (
+import {readdir,readFile}from'fs/promises';import {join,basename}from'path';import {createHash}from'crypto';import {existsSync}from'fs';import {Pool}from'pg';import {drizzle}from'drizzle-orm/node-postgres';var ne={format:"name",tableName:"__drizzle_migrations",columns:{identifier:"name",timestamp:"applied_at",timestampType:"timestamp"}},ae={format:"drizzle-kit",tableName:"__drizzle_migrations",columns:{identifier:"hash",timestamp:"created_at",timestampType:"bigint"}};async function N(m,e,n){if(!(await m.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,n])).rows[0]?.exists)return null;let r=await m.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"
-        }
-      };
-  }
-}
-var DEFAULT_MIGRATIONS_TABLE = "__drizzle_migrations";
-var SchemaManager = class {
-  constructor(config, migrationsTable) {
-    this.config = config;
-    this.migrationsTable = migrationsTable ?? DEFAULT_MIGRATIONS_TABLE;
-  }
-  migrationsTable;
-  /**
-   * Get the schema name for a tenant ID using the configured template
-   *
-   * @param tenantId - The tenant identifier
-   * @returns The PostgreSQL schema name
-   *
-   * @example
-   * ```typescript
-   * const schemaName = schemaManager.getSchemaName('tenant-123');
-   * // Returns: 'tenant_tenant-123' (depends on schemaNameTemplate)
-   * ```
-   */
-  getSchemaName(tenantId) {
-    return this.config.isolation.schemaNameTemplate(tenantId);
-  }
-  /**
-   * Create a PostgreSQL pool for a specific schema
-   *
-   * The pool is configured with `search_path` set to the schema,
-   * allowing queries to run in tenant isolation.
-   *
-   * @param schemaName - The PostgreSQL schema name
-   * @returns A configured Pool instance
-   *
-   * @example
-   * ```typescript
-   * const pool = await schemaManager.createPool('tenant_123');
-   * try {
-   *   await pool.query('SELECT * FROM users'); // Queries tenant_123.users
-   * } finally {
-   *   await pool.end();
-   * }
-   * ```
-   */
-  async createPool(schemaName) {
-    return new Pool({
-      connectionString: this.config.connection.url,
-      ...this.config.connection.poolConfig,
-      options: `-c search_path="${schemaName}",public`
-    });
-  }
-  /**
-   * Create a PostgreSQL pool without schema-specific search_path
-   *
-   * Used for operations that need to work across schemas or
-   * before a schema exists (like creating the schema itself).
-   *
-   * @returns A Pool instance connected to the database
-   */
-  async createRootPool() {
-    return new Pool({
-      connectionString: this.config.connection.url,
-      ...this.config.connection.poolConfig
-    });
-  }
-  /**
-   * Create a new tenant schema in the database
-   *
-   * @param tenantId - The tenant identifier
-   * @returns Promise that resolves when schema is created
-   *
-   * @example
-   * ```typescript
-   * await schemaManager.createSchema('new-tenant');
-   * ```
-   */
-  async createSchema(tenantId) {
-    const schemaName = this.getSchemaName(tenantId);
-    const pool = await this.createRootPool();
-    try {
-      await pool.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Drop a tenant schema from the database
-   *
-   * @param tenantId - The tenant identifier
-   * @param options - Drop options (cascade, force)
-   * @returns Promise that resolves when schema is dropped
-   *
-   * @example
-   * ```typescript
-   * // Drop with CASCADE (removes all objects)
-   * await schemaManager.dropSchema('old-tenant', { cascade: true });
-   *
-   * // Drop with RESTRICT (fails if objects exist)
-   * await schemaManager.dropSchema('old-tenant', { cascade: false });
-   * ```
-   */
-  async dropSchema(tenantId, options = {}) {
-    const { cascade = true } = options;
-    const schemaName = this.getSchemaName(tenantId);
-    const pool = await this.createRootPool();
-    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 in the database
-   *
-   * @param tenantId - The tenant identifier
-   * @returns True if schema exists, false otherwise
-   *
-   * @example
-   * ```typescript
-   * if (await schemaManager.schemaExists('tenant-123')) {
-   *   console.log('Tenant schema exists');
-   * }
-   * ```
-   */
-  async schemaExists(tenantId) {
-    const schemaName = this.getSchemaName(tenantId);
-    const pool = await this.createRootPool();
-    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();
-    }
-  }
-  /**
-   * List all schemas matching a pattern
-   *
-   * @param pattern - SQL LIKE pattern to filter schemas (optional)
-   * @returns Array of schema names
-   *
-   * @example
-   * ```typescript
-   * // List all tenant schemas
-   * const schemas = await schemaManager.listSchemas('tenant_%');
-   * ```
-   */
-  async listSchemas(pattern) {
-    const pool = await this.createRootPool();
-    try {
-      const query = pattern ? `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`;
-      const result = await pool.query(
-        query,
-        pattern ? [pattern] : []
-      );
-      return result.rows.map((row) => row.schema_name);
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Ensure the migrations table exists with the correct format
-   *
-   * Creates the migrations tracking table if it doesn't exist,
-   * using the appropriate column types based on the format.
-   *
-   * @param pool - Database pool to use
-   * @param schemaName - The schema to create the table in
-   * @param format - The detected/configured table format
-   *
-   * @example
-   * ```typescript
-   * const pool = await schemaManager.createPool('tenant_123');
-   * await schemaManager.ensureMigrationsTable(pool, 'tenant_123', 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,n]),t=new Map(r.rows.map(i=>[i.column_name,i.data_type]));return t.has("name")?{format:"name",tableName:n,columns:{identifier:"name",timestamp:t.has("applied_at")?"applied_at":"created_at",timestampType:"timestamp"}}:t.has("hash")?t.get("created_at")==="bigint"?{format:"drizzle-kit",tableName:n,columns:{identifier:"hash",timestamp:"created_at",timestampType:"bigint"}}:{format:"hash",tableName:n,columns:{identifier:"hash",timestamp:"created_at",timestampType:"timestamp"}}:null}function w(m,e="__drizzle_migrations"){switch(m){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 re="__drizzle_migrations",D=class{constructor(e,n){this.config=e;this.migrationsTable=n??re;}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 n=this.getSchemaName(e),a=await this.createRootPool();try{await a.query(`CREATE SCHEMA IF NOT EXISTS "${n}"`);}finally{await a.end();}}async dropSchema(e,n={}){let{cascade:a=true}=n,r=this.getSchemaName(e),t=await this.createRootPool();try{let i=a?"CASCADE":"RESTRICT";await t.query(`DROP SCHEMA IF EXISTS "${r}" ${i}`);}finally{await t.end();}}async schemaExists(e){let n=this.getSchemaName(e),a=await this.createRootPool();try{let r=await a.query("SELECT 1 FROM information_schema.schemata WHERE schema_name = $1",[n]);return r.rowCount!==null&&r.rowCount>0}finally{await a.end();}}async listSchemas(e){let n=await this.createRootPool();try{let a=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 n.query(a,e?[e]:[])).rows.map(t=>t.schema_name)}finally{await n.end();}}async ensureMigrationsTable(e,n,a){let{identifier:r,timestamp:t,timestampType:i}=a.columns,s=r==="name"?"name VARCHAR(255) NOT NULL UNIQUE":"hash TEXT NOT NULL",o=i==="bigint"?`${t} BIGINT NOT NULL`:`${t} TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP`;await e.query(`
+      CREATE TABLE IF NOT EXISTS "${n}"."${a.tableName}" (
         id SERIAL PRIMARY KEY,
-        ${identifierCol},
-        ${timestampCol}
+        ${s},
+        ${o}
       )
-    `);
-  }
-  /**
-   * Check if the migrations table exists in a schema
-   *
-   * @param pool - Database pool to use
-   * @param schemaName - The schema to check
-   * @returns True if migrations table exists
-   *
-   * @example
-   * ```typescript
-   * const pool = await schemaManager.createPool('tenant_123');
-   * if (await schemaManager.migrationsTableExists(pool, 'tenant_123')) {
-   *   console.log('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 the configured migrations table name
-   *
-   * @returns The migrations table name
-   */
-  getMigrationsTableName() {
-    return this.migrationsTable;
-  }
-};
-function createSchemaManager(config, migrationsTable) {
-  return new SchemaManager(config, migrationsTable);
-}
-
-// src/migrator/drift/column-analyzer.ts
-async function introspectColumns(pool, schemaName, tableName) {
-  const result = await pool.query(
-    `SELECT
+    `);}async migrationsTableExists(e,n){let a=await e.query(`SELECT 1 FROM information_schema.tables
+       WHERE table_schema = $1 AND table_name = $2`,[n,this.migrationsTable]);return a.rowCount!==null&&a.rowCount>0}getMigrationsTableName(){return this.migrationsTable}};function ie(m,e){return new D(m,e)}async function v(m,e,n){return (await m.query(`SELECT
       column_name,
       data_type,
       udt_name,
@@ -354,94 +22,10 @@ async function introspectColumns(pool, schemaName, tableName) {
       ordinal_position
      FROM information_schema.columns
      WHERE table_schema = $1 AND table_name = $2
-     ORDER BY ordinal_position`,
-    [schemaName, tableName]
-  );
-  return result.rows.map((row) => ({
-    name: row.column_name,
-    dataType: row.data_type,
-    udtName: row.udt_name,
-    isNullable: row.is_nullable === "YES",
-    columnDefault: row.column_default,
-    characterMaximumLength: row.character_maximum_length,
-    numericPrecision: row.numeric_precision,
-    numericScale: row.numeric_scale,
-    ordinalPosition: row.ordinal_position
-  }));
-}
-function normalizeDefault(value) {
-  if (value === null) return null;
-  return value.replace(/^'(.+)'::.+$/, "$1").replace(/^(.+)::.+$/, "$1").trim();
-}
-function compareColumns(reference, target) {
-  const drifts = [];
-  const refColMap = new Map(reference.map((c) => [c.name, c]));
-  const targetColMap = new Map(target.map((c) => [c.name, c]));
-  for (const refCol of reference) {
-    const targetCol = targetColMap.get(refCol.name);
-    if (!targetCol) {
-      drifts.push({
-        column: refCol.name,
-        type: "missing",
-        expected: refCol.dataType,
-        description: `Column "${refCol.name}" (${refCol.dataType}) is missing`
-      });
-      continue;
-    }
-    if (refCol.udtName !== targetCol.udtName) {
-      drifts.push({
-        column: refCol.name,
-        type: "type_mismatch",
-        expected: refCol.udtName,
-        actual: targetCol.udtName,
-        description: `Column "${refCol.name}" type mismatch: expected "${refCol.udtName}", got "${targetCol.udtName}"`
-      });
-    }
-    if (refCol.isNullable !== targetCol.isNullable) {
-      drifts.push({
-        column: refCol.name,
-        type: "nullable_mismatch",
-        expected: refCol.isNullable,
-        actual: targetCol.isNullable,
-        description: `Column "${refCol.name}" nullable mismatch: expected ${refCol.isNullable ? "NULL" : "NOT NULL"}, got ${targetCol.isNullable ? "NULL" : "NOT NULL"}`
-      });
-    }
-    const normalizedRefDefault = normalizeDefault(refCol.columnDefault);
-    const normalizedTargetDefault = normalizeDefault(targetCol.columnDefault);
-    if (normalizedRefDefault !== normalizedTargetDefault) {
-      drifts.push({
-        column: refCol.name,
-        type: "default_mismatch",
-        expected: refCol.columnDefault,
-        actual: targetCol.columnDefault,
-        description: `Column "${refCol.name}" default mismatch: expected "${refCol.columnDefault ?? "none"}", got "${targetCol.columnDefault ?? "none"}"`
-      });
-    }
-  }
-  for (const targetCol of target) {
-    if (!refColMap.has(targetCol.name)) {
-      drifts.push({
-        column: targetCol.name,
-        type: "extra",
-        actual: targetCol.dataType,
-        description: `Extra column "${targetCol.name}" (${targetCol.dataType}) not in reference`
-      });
-    }
-  }
-  return drifts;
-}
-
-// src/migrator/drift/index-analyzer.ts
-async function introspectIndexes(pool, schemaName, tableName) {
-  const indexResult = await pool.query(
-    `SELECT indexname, indexdef
+     ORDER BY ordinal_position`,[e,n])).rows.map(r=>({name:r.column_name,dataType:r.data_type,udtName:r.udt_name,isNullable:r.is_nullable==="YES",columnDefault:r.column_default,characterMaximumLength:r.character_maximum_length,numericPrecision:r.numeric_precision,numericScale:r.numeric_scale,ordinalPosition:r.ordinal_position}))}function L(m){return m===null?null:m.replace(/^'(.+)'::.+$/,"$1").replace(/^(.+)::.+$/,"$1").trim()}function q(m,e){let n=[],a=new Map(m.map(t=>[t.name,t])),r=new Map(e.map(t=>[t.name,t]));for(let t of m){let i=r.get(t.name);if(!i){n.push({column:t.name,type:"missing",expected:t.dataType,description:`Column "${t.name}" (${t.dataType}) is missing`});continue}t.udtName!==i.udtName&&n.push({column:t.name,type:"type_mismatch",expected:t.udtName,actual:i.udtName,description:`Column "${t.name}" type mismatch: expected "${t.udtName}", got "${i.udtName}"`}),t.isNullable!==i.isNullable&&n.push({column:t.name,type:"nullable_mismatch",expected:t.isNullable,actual:i.isNullable,description:`Column "${t.name}" nullable mismatch: expected ${t.isNullable?"NULL":"NOT NULL"}, got ${i.isNullable?"NULL":"NOT NULL"}`});let s=L(t.columnDefault),o=L(i.columnDefault);s!==o&&n.push({column:t.name,type:"default_mismatch",expected:t.columnDefault,actual:i.columnDefault,description:`Column "${t.name}" default mismatch: expected "${t.columnDefault??"none"}", got "${i.columnDefault??"none"}"`});}for(let t of e)a.has(t.name)||n.push({column:t.name,type:"extra",actual:t.dataType,description:`Extra column "${t.name}" (${t.dataType}) not in reference`});return n}async function j(m,e,n){let a=await m.query(`SELECT indexname, indexdef
      FROM pg_indexes
      WHERE schemaname = $1 AND tablename = $2
-     ORDER BY indexname`,
-    [schemaName, tableName]
-  );
-  const indexDetails = await pool.query(
-    `SELECT
+     ORDER BY indexname`,[e,n]),r=await m.query(`SELECT
       i.relname as indexname,
       a.attname as column_name,
       ix.indisunique as is_unique,
@@ -452,77 +36,7 @@ async function introspectIndexes(pool, schemaName, tableName) {
      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`,
-    [schemaName, tableName]
-  );
-  const indexColumnsMap = /* @__PURE__ */ new Map();
-  for (const row of indexDetails.rows) {
-    const existing = indexColumnsMap.get(row.indexname);
-    if (existing) {
-      existing.columns.push(row.column_name);
-    } else {
-      indexColumnsMap.set(row.indexname, {
-        columns: [row.column_name],
-        isUnique: row.is_unique,
-        isPrimary: row.is_primary
-      });
-    }
-  }
-  return indexResult.rows.map((row) => {
-    const details = indexColumnsMap.get(row.indexname);
-    return {
-      name: row.indexname,
-      columns: details?.columns ?? [],
-      isUnique: details?.isUnique ?? false,
-      isPrimary: details?.isPrimary ?? false,
-      definition: row.indexdef
-    };
-  });
-}
-function compareIndexes(reference, target) {
-  const drifts = [];
-  const refIndexMap = new Map(reference.map((i) => [i.name, i]));
-  const targetIndexMap = new Map(target.map((i) => [i.name, i]));
-  for (const refIndex of reference) {
-    const targetIndex = targetIndexMap.get(refIndex.name);
-    if (!targetIndex) {
-      drifts.push({
-        index: refIndex.name,
-        type: "missing",
-        expected: refIndex.definition,
-        description: `Index "${refIndex.name}" is missing`
-      });
-      continue;
-    }
-    const refCols = refIndex.columns.sort().join(",");
-    const targetCols = targetIndex.columns.sort().join(",");
-    if (refCols !== targetCols || refIndex.isUnique !== targetIndex.isUnique) {
-      drifts.push({
-        index: refIndex.name,
-        type: "definition_mismatch",
-        expected: refIndex.definition,
-        actual: targetIndex.definition,
-        description: `Index "${refIndex.name}" definition differs`
-      });
-    }
-  }
-  for (const targetIndex of target) {
-    if (!refIndexMap.has(targetIndex.name)) {
-      drifts.push({
-        index: targetIndex.name,
-        type: "extra",
-        actual: targetIndex.definition,
-        description: `Extra index "${targetIndex.name}" not in reference`
-      });
-    }
-  }
-  return drifts;
-}
-
-// src/migrator/drift/constraint-analyzer.ts
-async function introspectConstraints(pool, schemaName, tableName) {
-  const result = await pool.query(
-    `SELECT
+     ORDER BY i.relname, a.attnum`,[e,n]),t=new Map;for(let i of r.rows){let s=t.get(i.indexname);s?s.columns.push(i.column_name):t.set(i.indexname,{columns:[i.column_name],isUnique:i.is_unique,isPrimary:i.is_primary});}return a.rows.map(i=>{let s=t.get(i.indexname);return {name:i.indexname,columns:s?.columns??[],isUnique:s?.isUnique??false,isPrimary:s?.isPrimary??false,definition:i.indexdef}})}function I(m,e){let n=[],a=new Map(m.map(t=>[t.name,t])),r=new Map(e.map(t=>[t.name,t]));for(let t of m){let i=r.get(t.name);if(!i){n.push({index:t.name,type:"missing",expected:t.definition,description:`Index "${t.name}" is missing`});continue}let s=t.columns.sort().join(","),o=i.columns.sort().join(",");(s!==o||t.isUnique!==i.isUnique)&&n.push({index:t.name,type:"definition_mismatch",expected:t.definition,actual:i.definition,description:`Index "${t.name}" definition differs`});}for(let t of e)a.has(t.name)||n.push({index:t.name,type:"extra",actual:t.definition,description:`Extra index "${t.name}" not in reference`});return n}async function B(m,e,n){let a=await m.query(`SELECT
       tc.constraint_name,
       tc.constraint_type,
       kcu.column_name,
@@ -541,1710 +55,20 @@ async function introspectConstraints(pool, schemaName, tableName) {
        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`,
-    [schemaName, tableName]
-  );
-  const constraintMap = /* @__PURE__ */ new Map();
-  for (const row of result.rows) {
-    const existing = constraintMap.get(row.constraint_name);
-    if (existing) {
-      if (row.column_name && !existing.columns.includes(row.column_name)) {
-        existing.columns.push(row.column_name);
-      }
-      if (row.foreign_column_name && existing.foreignColumns && !existing.foreignColumns.includes(row.foreign_column_name)) {
-        existing.foreignColumns.push(row.foreign_column_name);
-      }
-    } else {
-      const constraint = {
-        name: row.constraint_name,
-        type: row.constraint_type,
-        columns: row.column_name ? [row.column_name] : []
-      };
-      if (row.foreign_table_name) {
-        constraint.foreignTable = row.foreign_table_name;
-      }
-      if (row.foreign_column_name) {
-        constraint.foreignColumns = [row.foreign_column_name];
-      }
-      if (row.check_clause) {
-        constraint.checkExpression = row.check_clause;
-      }
-      constraintMap.set(row.constraint_name, constraint);
-    }
-  }
-  return Array.from(constraintMap.values());
-}
-function compareConstraints(reference, target) {
-  const drifts = [];
-  const refConstraintMap = new Map(reference.map((c) => [c.name, c]));
-  const targetConstraintMap = new Map(target.map((c) => [c.name, c]));
-  for (const refConstraint of reference) {
-    const targetConstraint = targetConstraintMap.get(refConstraint.name);
-    if (!targetConstraint) {
-      drifts.push({
-        constraint: refConstraint.name,
-        type: "missing",
-        expected: `${refConstraint.type} on (${refConstraint.columns.join(", ")})`,
-        description: `Constraint "${refConstraint.name}" (${refConstraint.type}) is missing`
-      });
-      continue;
-    }
-    const refCols = refConstraint.columns.sort().join(",");
-    const targetCols = targetConstraint.columns.sort().join(",");
-    if (refConstraint.type !== targetConstraint.type || refCols !== targetCols) {
-      drifts.push({
-        constraint: refConstraint.name,
-        type: "definition_mismatch",
-        expected: `${refConstraint.type} on (${refConstraint.columns.join(", ")})`,
-        actual: `${targetConstraint.type} on (${targetConstraint.columns.join(", ")})`,
-        description: `Constraint "${refConstraint.name}" definition differs`
-      });
-    }
-  }
-  for (const targetConstraint of target) {
-    if (!refConstraintMap.has(targetConstraint.name)) {
-      drifts.push({
-        constraint: targetConstraint.name,
-        type: "extra",
-        actual: `${targetConstraint.type} on (${targetConstraint.columns.join(", ")})`,
-        description: `Extra constraint "${targetConstraint.name}" (${targetConstraint.type}) not in reference`
-      });
-    }
-  }
-  return drifts;
-}
-
-// src/migrator/drift/drift-detector.ts
-var DEFAULT_MIGRATIONS_TABLE2 = "__drizzle_migrations";
-var DriftDetector = class {
-  constructor(tenantConfig, schemaManager, driftConfig) {
-    this.tenantConfig = tenantConfig;
-    this.schemaManager = schemaManager;
-    this.driftConfig = driftConfig;
-    this.migrationsTable = driftConfig.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE2;
-  }
-  migrationsTable;
-  /**
-   * Get the schema name for a tenant ID
-   */
-  getSchemaName(tenantId) {
-    return this.tenantConfig.isolation.schemaNameTemplate(tenantId);
-  }
-  /**
-   * Create a pool for a schema
-   */
-  async createPool(schemaName) {
-    return this.schemaManager.createPool(schemaName);
-  }
-  /**
-   * Detect schema drift across all tenants.
-   *
-   * Compares each tenant's schema against a reference tenant (first tenant by default).
-   * Returns a comprehensive report of all differences found.
-   *
-   * @param options - Detection options
-   * @returns Schema drift status with details for each tenant
-   *
-   * @example
-   * ```typescript
-   * // Basic usage - compare all tenants against the first one
-   * const status = await detector.detectDrift();
-   *
-   * // Use a specific tenant as reference
-   * const status = await detector.detectDrift({
-   *   referenceTenant: 'golden-tenant',
-   * });
-   *
-   * // Check specific tenants only
-   * const status = await detector.detectDrift({
-   *   tenantIds: ['tenant-1', 'tenant-2'],
-   * });
-   *
-   * // Skip index and constraint comparison for faster checks
-   * const status = await detector.detectDrift({
-   *   includeIndexes: false,
-   *   includeConstraints: false,
-   * });
-   * ```
-   */
-  async detectDrift(options = {}) {
-    const startTime = Date.now();
-    const {
-      concurrency = 10,
-      includeIndexes = true,
-      includeConstraints = true,
-      excludeTables = [this.migrationsTable],
-      onProgress
-    } = options;
-    const tenantIds = options.tenantIds ?? await this.driftConfig.tenantDiscovery();
-    if (tenantIds.length === 0) {
-      return {
-        referenceTenant: "",
-        total: 0,
-        noDrift: 0,
-        withDrift: 0,
-        error: 0,
-        details: [],
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        durationMs: Date.now() - startTime
-      };
-    }
-    const referenceTenant = options.referenceTenant ?? tenantIds[0];
-    onProgress?.(referenceTenant, "starting");
-    onProgress?.(referenceTenant, "introspecting");
-    const referenceSchema = await this.introspectSchema(referenceTenant, {
-      includeIndexes,
-      includeConstraints,
-      excludeTables
-    });
-    if (!referenceSchema) {
-      return {
-        referenceTenant,
-        total: tenantIds.length,
-        noDrift: 0,
-        withDrift: 0,
-        error: tenantIds.length,
-        details: tenantIds.map((id) => ({
-          tenantId: id,
-          schemaName: this.getSchemaName(id),
-          hasDrift: false,
-          tables: [],
-          issueCount: 0,
-          error: id === referenceTenant ? "Failed to introspect reference tenant" : "Reference tenant introspection failed"
-        })),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        durationMs: Date.now() - startTime
-      };
-    }
-    onProgress?.(referenceTenant, "completed");
-    const tenantsToCheck = tenantIds.filter((id) => id !== referenceTenant);
-    const results = [];
-    results.push({
-      tenantId: referenceTenant,
-      schemaName: referenceSchema.schemaName,
-      hasDrift: false,
-      tables: [],
-      issueCount: 0
-    });
-    for (let i = 0; i < tenantsToCheck.length; i += concurrency) {
-      const batch = tenantsToCheck.slice(i, i + concurrency);
-      const batchResults = await Promise.all(
-        batch.map(async (tenantId) => {
-          try {
-            onProgress?.(tenantId, "starting");
-            onProgress?.(tenantId, "introspecting");
-            const tenantSchema = await this.introspectSchema(tenantId, {
-              includeIndexes,
-              includeConstraints,
-              excludeTables
-            });
-            if (!tenantSchema) {
-              onProgress?.(tenantId, "failed");
-              return {
-                tenantId,
-                schemaName: this.getSchemaName(tenantId),
-                hasDrift: false,
-                tables: [],
-                issueCount: 0,
-                error: "Failed to introspect schema"
-              };
-            }
-            onProgress?.(tenantId, "comparing");
-            const drift = this.compareSchemas(referenceSchema, tenantSchema, {
-              includeIndexes,
-              includeConstraints
-            });
-            onProgress?.(tenantId, "completed");
-            return drift;
-          } catch (error) {
-            onProgress?.(tenantId, "failed");
-            return {
-              tenantId,
-              schemaName: this.getSchemaName(tenantId),
-              hasDrift: false,
-              tables: [],
-              issueCount: 0,
-              error: error.message
-            };
-          }
-        })
-      );
-      results.push(...batchResults);
-    }
-    return {
-      referenceTenant,
-      total: results.length,
-      noDrift: results.filter((r) => !r.hasDrift && !r.error).length,
-      withDrift: results.filter((r) => r.hasDrift && !r.error).length,
-      error: results.filter((r) => !!r.error).length,
-      details: results,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      durationMs: Date.now() - startTime
-    };
-  }
-  /**
-   * Compare a specific tenant against a reference tenant.
-   *
-   * @param tenantId - Tenant to check
-   * @param referenceTenantId - Tenant to use as reference
-   * @param options - Introspection options
-   * @returns Drift details for the tenant
-   *
-   * @example
-   * ```typescript
-   * const drift = await detector.compareTenant('tenant-123', 'golden-tenant');
-   * if (drift.hasDrift) {
-   *   console.log(`Found ${drift.issueCount} issues`);
-   * }
-   * ```
-   */
-  async compareTenant(tenantId, referenceTenantId, options = {}) {
-    const {
-      includeIndexes = true,
-      includeConstraints = true,
-      excludeTables = [this.migrationsTable]
-    } = options;
-    const referenceSchema = await this.introspectSchema(referenceTenantId, {
-      includeIndexes,
-      includeConstraints,
-      excludeTables
-    });
-    if (!referenceSchema) {
-      return {
-        tenantId,
-        schemaName: this.getSchemaName(tenantId),
-        hasDrift: false,
-        tables: [],
-        issueCount: 0,
-        error: "Failed to introspect reference tenant"
-      };
-    }
-    const tenantSchema = await this.introspectSchema(tenantId, {
-      includeIndexes,
-      includeConstraints,
-      excludeTables
-    });
-    if (!tenantSchema) {
-      return {
-        tenantId,
-        schemaName: this.getSchemaName(tenantId),
-        hasDrift: false,
-        tables: [],
-        issueCount: 0,
-        error: "Failed to introspect tenant schema"
-      };
-    }
-    return this.compareSchemas(referenceSchema, tenantSchema, {
-      includeIndexes,
-      includeConstraints
-    });
-  }
-  /**
-   * Introspect a tenant's schema structure.
-   *
-   * Retrieves all tables, columns, indexes, and constraints
-   * for a tenant's schema.
-   *
-   * @param tenantId - Tenant to introspect
-   * @param options - Introspection options
-   * @returns Schema structure or null if introspection fails
-   *
-   * @example
-   * ```typescript
-   * const schema = await detector.introspectSchema('tenant-123');
-   * if (schema) {
-   *   console.log(`Found ${schema.tables.length} tables`);
-   *   for (const table of schema.tables) {
-   *     console.log(`  ${table.name}: ${table.columns.length} columns`);
-   *   }
-   * }
-   * ```
-   */
-  async introspectSchema(tenantId, options = {}) {
-    const schemaName = this.getSchemaName(tenantId);
-    const pool = await this.createPool(schemaName);
-    try {
-      const tables = await this.introspectTables(pool, schemaName, options);
-      return {
-        tenantId,
-        schemaName,
-        tables,
-        introspectedAt: /* @__PURE__ */ new Date()
-      };
-    } catch {
-      return null;
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Compare two schema snapshots.
-   *
-   * This method compares pre-introspected schema snapshots,
-   * useful when you already have the schema data available.
-   *
-   * @param reference - Reference (expected) schema
-   * @param target - Target (actual) schema
-   * @param options - Comparison options
-   * @returns Drift details
-   *
-   * @example
-   * ```typescript
-   * const refSchema = await detector.introspectSchema('golden-tenant');
-   * const targetSchema = await detector.introspectSchema('tenant-123');
-   *
-   * if (refSchema && targetSchema) {
-   *   const drift = detector.compareSchemas(refSchema, targetSchema);
-   *   console.log(`Drift detected: ${drift.hasDrift}`);
-   * }
-   * ```
-   */
-  compareSchemas(reference, target, options = {}) {
-    const { includeIndexes = true, includeConstraints = true } = options;
-    const tableDrifts = [];
-    let totalIssues = 0;
-    const refTableMap = new Map(reference.tables.map((t) => [t.name, t]));
-    const targetTableMap = new Map(target.tables.map((t) => [t.name, t]));
-    for (const refTable of reference.tables) {
-      const targetTable = targetTableMap.get(refTable.name);
-      if (!targetTable) {
-        tableDrifts.push({
-          table: refTable.name,
-          status: "missing",
-          columns: refTable.columns.map((c) => ({
-            column: c.name,
-            type: "missing",
-            expected: c.dataType,
-            description: `Column "${c.name}" (${c.dataType}) is missing`
-          })),
-          indexes: [],
-          constraints: []
-        });
-        totalIssues += refTable.columns.length;
-        continue;
-      }
-      const columnDrifts = compareColumns(refTable.columns, targetTable.columns);
-      const indexDrifts = includeIndexes ? compareIndexes(refTable.indexes, targetTable.indexes) : [];
-      const constraintDrifts = includeConstraints ? compareConstraints(refTable.constraints, targetTable.constraints) : [];
-      const issues = columnDrifts.length + indexDrifts.length + constraintDrifts.length;
-      totalIssues += issues;
-      if (issues > 0) {
-        tableDrifts.push({
-          table: refTable.name,
-          status: "drifted",
-          columns: columnDrifts,
-          indexes: indexDrifts,
-          constraints: constraintDrifts
-        });
-      }
-    }
-    for (const targetTable of target.tables) {
-      if (!refTableMap.has(targetTable.name)) {
-        tableDrifts.push({
-          table: targetTable.name,
-          status: "extra",
-          columns: targetTable.columns.map((c) => ({
-            column: c.name,
-            type: "extra",
-            actual: c.dataType,
-            description: `Extra column "${c.name}" (${c.dataType}) not in reference`
-          })),
-          indexes: [],
-          constraints: []
-        });
-        totalIssues += targetTable.columns.length;
-      }
-    }
-    return {
-      tenantId: target.tenantId,
-      schemaName: target.schemaName,
-      hasDrift: totalIssues > 0,
-      tables: tableDrifts,
-      issueCount: totalIssues
-    };
-  }
-  /**
-   * Introspect all tables in a schema
-   */
-  async introspectTables(pool, schemaName, options) {
-    const { includeIndexes = true, includeConstraints = true, excludeTables = [] } = options;
-    const tablesResult = await pool.query(
-      `SELECT table_name
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,[e,n]),r=new Map;for(let t of a.rows){let i=r.get(t.constraint_name);if(i)t.column_name&&!i.columns.includes(t.column_name)&&i.columns.push(t.column_name),t.foreign_column_name&&i.foreignColumns&&!i.foreignColumns.includes(t.foreign_column_name)&&i.foreignColumns.push(t.foreign_column_name);else {let s={name:t.constraint_name,type:t.constraint_type,columns:t.column_name?[t.column_name]:[]};t.foreign_table_name&&(s.foreignTable=t.foreign_table_name),t.foreign_column_name&&(s.foreignColumns=[t.foreign_column_name]),t.check_clause&&(s.checkExpression=t.check_clause),r.set(t.constraint_name,s);}}return Array.from(r.values())}function z(m,e){let n=[],a=new Map(m.map(t=>[t.name,t])),r=new Map(e.map(t=>[t.name,t]));for(let t of m){let i=r.get(t.name);if(!i){n.push({constraint:t.name,type:"missing",expected:`${t.type} on (${t.columns.join(", ")})`,description:`Constraint "${t.name}" (${t.type}) is missing`});continue}let s=t.columns.sort().join(","),o=i.columns.sort().join(",");(t.type!==i.type||s!==o)&&n.push({constraint:t.name,type:"definition_mismatch",expected:`${t.type} on (${t.columns.join(", ")})`,actual:`${i.type} on (${i.columns.join(", ")})`,description:`Constraint "${t.name}" definition differs`});}for(let t of e)a.has(t.name)||n.push({constraint:t.name,type:"extra",actual:`${t.type} on (${t.columns.join(", ")})`,description:`Extra constraint "${t.name}" (${t.type}) not in reference`});return n}var se="__drizzle_migrations",O=class{constructor(e,n,a){this.tenantConfig=e;this.schemaManager=n;this.driftConfig=a;this.migrationsTable=a.migrationsTable??se;}migrationsTable;getSchemaName(e){return this.tenantConfig.isolation.schemaNameTemplate(e)}async createPool(e){return this.schemaManager.createPool(e)}async detectDrift(e={}){let n=Date.now(),{concurrency:a=10,includeIndexes:r=true,includeConstraints:t=true,excludeTables:i=[this.migrationsTable],onProgress:s}=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()-n};let l=e.referenceTenant??o[0];s?.(l,"starting"),s?.(l,"introspecting");let c=await this.introspectSchema(l,{includeIndexes:r,includeConstraints:t,excludeTables:i});if(!c)return {referenceTenant:l,total:o.length,noDrift:0,withDrift:0,error:o.length,details:o.map(p=>({tenantId:p,schemaName:this.getSchemaName(p),hasDrift:false,tables:[],issueCount:0,error:p===l?"Failed to introspect reference tenant":"Reference tenant introspection failed"})),timestamp:new Date().toISOString(),durationMs:Date.now()-n};s?.(l,"completed");let u=o.filter(p=>p!==l),g=[];g.push({tenantId:l,schemaName:c.schemaName,hasDrift:false,tables:[],issueCount:0});for(let p=0;p<u.length;p+=a){let h=u.slice(p,p+a),y=await Promise.all(h.map(async d=>{try{s?.(d,"starting"),s?.(d,"introspecting");let f=await this.introspectSchema(d,{includeIndexes:r,includeConstraints:t,excludeTables:i});if(!f)return s?.(d,"failed"),{tenantId:d,schemaName:this.getSchemaName(d),hasDrift:!1,tables:[],issueCount:0,error:"Failed to introspect schema"};s?.(d,"comparing");let P=this.compareSchemas(c,f,{includeIndexes:r,includeConstraints:t});return s?.(d,"completed"),P}catch(f){return s?.(d,"failed"),{tenantId:d,schemaName:this.getSchemaName(d),hasDrift:false,tables:[],issueCount:0,error:f.message}}}));g.push(...y);}return {referenceTenant:l,total:g.length,noDrift:g.filter(p=>!p.hasDrift&&!p.error).length,withDrift:g.filter(p=>p.hasDrift&&!p.error).length,error:g.filter(p=>!!p.error).length,details:g,timestamp:new Date().toISOString(),durationMs:Date.now()-n}}async compareTenant(e,n,a={}){let{includeIndexes:r=true,includeConstraints:t=true,excludeTables:i=[this.migrationsTable]}=a,s=await this.introspectSchema(n,{includeIndexes:r,includeConstraints:t,excludeTables:i});if(!s)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:r,includeConstraints:t,excludeTables:i});return o?this.compareSchemas(s,o,{includeIndexes:r,includeConstraints:t}):{tenantId:e,schemaName:this.getSchemaName(e),hasDrift:false,tables:[],issueCount:0,error:"Failed to introspect tenant schema"}}async introspectSchema(e,n={}){let a=this.getSchemaName(e),r=await this.createPool(a);try{let t=await this.introspectTables(r,a,n);return {tenantId:e,schemaName:a,tables:t,introspectedAt:new Date}}catch{return null}finally{await r.end();}}compareSchemas(e,n,a={}){let{includeIndexes:r=true,includeConstraints:t=true}=a,i=[],s=0,o=new Map(e.tables.map(c=>[c.name,c])),l=new Map(n.tables.map(c=>[c.name,c]));for(let c of e.tables){let u=l.get(c.name);if(!u){i.push({table:c.name,status:"missing",columns:c.columns.map(d=>({column:d.name,type:"missing",expected:d.dataType,description:`Column "${d.name}" (${d.dataType}) is missing`})),indexes:[],constraints:[]}),s+=c.columns.length;continue}let g=q(c.columns,u.columns),p=r?I(c.indexes,u.indexes):[],h=t?z(c.constraints,u.constraints):[],y=g.length+p.length+h.length;s+=y,y>0&&i.push({table:c.name,status:"drifted",columns:g,indexes:p,constraints:h});}for(let c of n.tables)o.has(c.name)||(i.push({table:c.name,status:"extra",columns:c.columns.map(u=>({column:u.name,type:"extra",actual:u.dataType,description:`Extra column "${u.name}" (${u.dataType}) not in reference`})),indexes:[],constraints:[]}),s+=c.columns.length);return {tenantId:n.tenantId,schemaName:n.schemaName,hasDrift:s>0,tables:i,issueCount:s}}async introspectTables(e,n,a){let{includeIndexes:r=true,includeConstraints:t=true,excludeTables:i=[]}=a,s=await e.query(`SELECT table_name
        FROM information_schema.tables
        WHERE table_schema = $1
          AND table_type = 'BASE TABLE'
-       ORDER BY table_name`,
-      [schemaName]
-    );
-    const tables = [];
-    for (const row of tablesResult.rows) {
-      if (excludeTables.includes(row.table_name)) {
-        continue;
-      }
-      const columns = await introspectColumns(pool, schemaName, row.table_name);
-      const indexes = includeIndexes ? await introspectIndexes(pool, schemaName, row.table_name) : [];
-      const constraints = includeConstraints ? await introspectConstraints(pool, schemaName, row.table_name) : [];
-      tables.push({
-        name: row.table_name,
-        columns,
-        indexes,
-        constraints
-      });
-    }
-    return tables;
-  }
-};
-var Seeder = class {
-  constructor(config, deps) {
-    this.config = config;
-    this.deps = deps;
-  }
-  /**
-   * Seed a single tenant with initial data
-   *
-   * Creates a database connection for the tenant, executes the seed function,
-   * and properly cleans up the connection afterward.
-   *
-   * @param tenantId - The tenant identifier
-   * @param seedFn - Function that seeds the database
-   * @returns Result of the seeding operation
-   *
-   * @example
-   * ```typescript
-   * const result = await seeder.seedTenant('tenant-123', async (db, tenantId) => {
-   *   await db.insert(users).values([
-   *     { name: 'Admin', email: `admin@${tenantId}.com` },
-   *   ]);
-   * });
-   *
-   * if (result.success) {
-   *   console.log(`Seeded ${result.tenantId} in ${result.durationMs}ms`);
-   * }
-   * ```
-   */
-  async seedTenant(tenantId, seedFn) {
-    const startTime = Date.now();
-    const schemaName = this.deps.schemaNameTemplate(tenantId);
-    const pool = await this.deps.createPool(schemaName);
-    try {
-      const db = drizzle(pool, {
-        schema: this.deps.tenantSchema
-      });
-      await seedFn(db, tenantId);
-      return {
-        tenantId,
-        schemaName,
-        success: true,
-        durationMs: Date.now() - startTime
-      };
-    } catch (error) {
-      return {
-        tenantId,
-        schemaName,
-        success: false,
-        error: error.message,
-        durationMs: Date.now() - startTime
-      };
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Seed all tenants with initial data in parallel
-   *
-   * Discovers all tenants and seeds them in batches with configurable concurrency.
-   * Supports progress callbacks and abort-on-error behavior.
-   *
-   * @param seedFn - Function that seeds each database
-   * @param options - Seeding options
-   * @returns Aggregate results of all seeding operations
-   *
-   * @example
-   * ```typescript
-   * const results = await seeder.seedAll(
-   *   async (db, tenantId) => {
-   *     await db.insert(settings).values({ key: 'initialized', value: 'true' });
-   *   },
-   *   {
-   *     concurrency: 5,
-   *     onProgress: (id, status) => console.log(`${id}: ${status}`),
-   *   }
-   * );
-   *
-   * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
-   * ```
-   */
-  async seedAll(seedFn, options = {}) {
-    const { concurrency = 10, onProgress, onError } = options;
-    const tenantIds = await this.config.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");
-            onProgress?.(tenantId, "seeding");
-            const result = await this.seedTenant(tenantId, seedFn);
-            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);
-  }
-  /**
-   * Seed specific tenants with initial data
-   *
-   * Seeds only the specified tenants in batches with configurable concurrency.
-   *
-   * @param tenantIds - List of tenant IDs to seed
-   * @param seedFn - Function that seeds each database
-   * @param options - Seeding options
-   * @returns Aggregate results of seeding operations
-   *
-   * @example
-   * ```typescript
-   * const results = await seeder.seedTenants(
-   *   ['tenant-1', 'tenant-2', 'tenant-3'],
-   *   async (db) => {
-   *     await db.insert(config).values({ setup: true });
-   *   },
-   *   { concurrency: 2 }
-   * );
-   * ```
-   */
-  async seedTenants(tenantIds, seedFn, options = {}) {
-    const { concurrency = 10, onProgress, onError } = 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) => {
-          try {
-            onProgress?.(tenantId, "starting");
-            onProgress?.(tenantId, "seeding");
-            const result = await this.seedTenant(tenantId, seedFn);
-            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);
-  }
-  /**
-   * Create a skipped result for aborted seeding
-   */
-  createSkippedResult(tenantId) {
-    return {
-      tenantId,
-      schemaName: this.deps.schemaNameTemplate(tenantId),
-      success: false,
-      error: "Skipped due to abort",
-      durationMs: 0
-    };
-  }
-  /**
-   * Create an error result for failed seeding
-   */
-  createErrorResult(tenantId, error) {
-    return {
-      tenantId,
-      schemaName: this.deps.schemaNameTemplate(tenantId),
-      success: false,
-      error: error.message,
-      durationMs: 0
-    };
-  }
-  /**
-   * Aggregate individual results into a summary
-   */
-  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 createSeeder(config, dependencies) {
-  return new Seeder(config, dependencies);
-}
-
-// src/migrator/sync/sync-manager.ts
-var SyncManager = class {
-  constructor(config, deps) {
-    this.config = config;
-    this.deps = deps;
-  }
-  /**
-   * Get sync status for all tenants
-   *
-   * Detects divergences between migrations on disk and tracking in database.
-   * A tenant is "in sync" when all disk migrations are tracked and no orphan records exist.
-   *
-   * @returns Aggregate sync status for all tenants
-   *
-   * @example
-   * ```typescript
-   * const status = await syncManager.getSyncStatus();
-   * console.log(`Total: ${status.total}, In sync: ${status.inSync}, Out of sync: ${status.outOfSync}`);
-   *
-   * for (const tenant of status.details.filter(d => !d.inSync)) {
-   *   console.log(`${tenant.tenantId}: missing=${tenant.missing.length}, orphans=${tenant.orphans.length}`);
-   * }
-   * ```
-   */
-  async getSyncStatus() {
-    const tenantIds = await this.config.tenantDiscovery();
-    const migrations = await this.deps.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
-   *
-   * Compares migrations on disk with records in the database.
-   * Identifies missing migrations (on disk but not tracked) and
-   * orphan records (tracked but not on disk).
-   *
-   * @param tenantId - The tenant identifier
-   * @param migrations - Optional pre-loaded migrations (avoids reloading from disk)
-   * @returns Sync status for the tenant
-   *
-   * @example
-   * ```typescript
-   * const status = await syncManager.getTenantSyncStatus('tenant-123');
-   * if (status.missing.length > 0) {
-   *   console.log(`Missing: ${status.missing.join(', ')}`);
-   * }
-   * if (status.orphans.length > 0) {
-   *   console.log(`Orphans: ${status.orphans.join(', ')}`);
-   * }
-   * ```
-   */
-  async getTenantSyncStatus(tenantId, migrations) {
-    const schemaName = this.deps.schemaNameTemplate(tenantId);
-    const pool = await this.deps.createPool(schemaName);
-    try {
-      const allMigrations = migrations ?? await this.deps.loadMigrations();
-      const migrationNames = new Set(allMigrations.map((m) => m.name));
-      const migrationHashes = new Set(allMigrations.map((m) => m.hash));
-      const tableExists = await this.deps.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.deps.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
-   *
-   * Records migrations that exist on disk but are not tracked in the database.
-   * Useful for syncing tracking state with already-applied migrations.
-   *
-   * @param tenantId - The tenant identifier
-   * @returns Result of the mark operation
-   *
-   * @example
-   * ```typescript
-   * const result = await syncManager.markMissing('tenant-123');
-   * if (result.success) {
-   *   console.log(`Marked ${result.markedMigrations.length} migrations as applied`);
-   * }
-   * ```
-   */
-  async markMissing(tenantId) {
-    const startTime = Date.now();
-    const schemaName = this.deps.schemaNameTemplate(tenantId);
-    const markedMigrations = [];
-    const pool = await this.deps.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.deps.getOrDetectFormat(pool, schemaName);
-      await this.deps.ensureMigrationsTable(pool, schemaName, format);
-      const allMigrations = await this.deps.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
-   *
-   * Processes all tenants in parallel with configurable concurrency.
-   * Supports progress callbacks and abort-on-error behavior.
-   *
-   * @param options - Sync options
-   * @returns Aggregate results of all mark operations
-   *
-   * @example
-   * ```typescript
-   * const results = await syncManager.markAllMissing({
-   *   concurrency: 10,
-   *   onProgress: (id, status) => console.log(`${id}: ${status}`),
-   * });
-   * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
-   * ```
-   */
-  async markAllMissing(options = {}) {
-    const { concurrency = 10, onProgress, onError } = options;
-    const tenantIds = await this.config.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
-   *
-   * Deletes records from the migrations table that don't have
-   * corresponding files on disk.
-   *
-   * @param tenantId - The tenant identifier
-   * @returns Result of the clean operation
-   *
-   * @example
-   * ```typescript
-   * const result = await syncManager.cleanOrphans('tenant-123');
-   * if (result.success) {
-   *   console.log(`Removed ${result.removedOrphans.length} orphan records`);
-   * }
-   * ```
-   */
-  async cleanOrphans(tenantId) {
-    const startTime = Date.now();
-    const schemaName = this.deps.schemaNameTemplate(tenantId);
-    const removedOrphans = [];
-    const pool = await this.deps.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.deps.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
-   *
-   * Processes all tenants in parallel with configurable concurrency.
-   * Supports progress callbacks and abort-on-error behavior.
-   *
-   * @param options - Sync options
-   * @returns Aggregate results of all clean operations
-   *
-   * @example
-   * ```typescript
-   * const results = await syncManager.cleanAllOrphans({
-   *   concurrency: 10,
-   *   onProgress: (id, status) => console.log(`${id}: ${status}`),
-   * });
-   * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
-   * ```
-   */
-  async cleanAllOrphans(options = {}) {
-    const { concurrency = 10, onProgress, onError } = options;
-    const tenantIds = await this.config.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);
-  }
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-  /**
-   * 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 {
-        identifier: 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);
-  }
-  /**
-   * Record a migration as applied (without executing SQL)
-   */
-  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 sync result for aborted operations
-   */
-  createSkippedSyncResult(tenantId) {
-    return {
-      tenantId,
-      schemaName: this.deps.schemaNameTemplate(tenantId),
-      success: false,
-      markedMigrations: [],
-      removedOrphans: [],
-      error: "Skipped due to abort",
-      durationMs: 0
-    };
-  }
-  /**
-   * Create an error sync result for failed operations
-   */
-  createErrorSyncResult(tenantId, error) {
-    return {
-      tenantId,
-      schemaName: this.deps.schemaNameTemplate(tenantId),
-      success: false,
-      markedMigrations: [],
-      removedOrphans: [],
-      error: error.message,
-      durationMs: 0
-    };
-  }
-  /**
-   * Aggregate individual sync results into a summary
-   */
-  aggregateSyncResults(results) {
-    return {
-      total: results.length,
-      succeeded: results.filter((r) => r.success).length,
-      failed: results.filter((r) => !r.success).length,
-      details: results
-    };
-  }
-};
-function createSyncManager(config, dependencies) {
-  return new SyncManager(config, dependencies);
-}
-
-// src/migrator/executor/migration-executor.ts
-var MigrationExecutor = class {
-  constructor(config, deps) {
-    this.config = config;
-    this.deps = deps;
-  }
-  /**
-   * Migrate a single tenant
-   *
-   * Applies all pending migrations to the tenant's schema.
-   * Creates the migrations table if it doesn't exist.
-   *
-   * @param tenantId - The tenant identifier
-   * @param migrations - Optional pre-loaded migrations (avoids reloading from disk)
-   * @param options - Migration options (dryRun, onProgress)
-   * @returns Migration result with applied migrations and duration
-   *
-   * @example
-   * ```typescript
-   * const result = await executor.migrateTenant('tenant-123', undefined, {
-   *   dryRun: false,
-   *   onProgress: (id, status, name) => console.log(`${id}: ${status} ${name}`),
-   * });
-   *
-   * if (result.success) {
-   *   console.log(`Applied ${result.appliedMigrations.length} migrations`);
-   * }
-   * ```
-   */
-  async migrateTenant(tenantId, migrations, options = {}) {
-    const startTime = Date.now();
-    const schemaName = this.deps.schemaNameTemplate(tenantId);
-    const appliedMigrations = [];
-    const pool = await this.deps.createPool(schemaName);
-    try {
-      await this.config.hooks?.beforeTenant?.(tenantId);
-      const format = await this.deps.getOrDetectFormat(pool, schemaName);
-      await this.deps.ensureMigrationsTable(pool, schemaName, format);
-      const allMigrations = migrations ?? await this.deps.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.config.hooks?.beforeMigration?.(tenantId, migration.name);
-        await this.applyMigration(pool, schemaName, migration, format);
-        await this.config.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.config.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } catch (error) {
-      const result = {
-        tenantId,
-        schemaName,
-        success: false,
-        appliedMigrations,
-        error: error.message,
-        durationMs: Date.now() - startTime
-      };
-      await this.config.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Mark migrations as applied without executing SQL
-   *
-   * Useful for syncing tracking state with already-applied migrations
-   * or when migrations were applied manually.
-   *
-   * @param tenantId - The tenant identifier
-   * @param options - Options with progress callback
-   * @returns Result with list of marked migrations
-   *
-   * @example
-   * ```typescript
-   * const result = await executor.markAsApplied('tenant-123', {
-   *   onProgress: (id, status, name) => console.log(`${id}: marking ${name}`),
-   * });
-   *
-   * console.log(`Marked ${result.appliedMigrations.length} migrations`);
-   * ```
-   */
-  async markAsApplied(tenantId, options = {}) {
-    const startTime = Date.now();
-    const schemaName = this.deps.schemaNameTemplate(tenantId);
-    const markedMigrations = [];
-    const pool = await this.deps.createPool(schemaName);
-    try {
-      await this.config.hooks?.beforeTenant?.(tenantId);
-      const format = await this.deps.getOrDetectFormat(pool, schemaName);
-      await this.deps.ensureMigrationsTable(pool, schemaName, format);
-      const allMigrations = await this.deps.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.config.hooks?.beforeMigration?.(tenantId, migration.name);
-        await this.recordMigration(pool, schemaName, migration, format);
-        await this.config.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.config.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.config.hooks?.afterTenant?.(tenantId, result);
-      return result;
-    } finally {
-      await pool.end();
-    }
-  }
-  /**
-   * Get migration status for a specific tenant
-   *
-   * Returns information about applied and pending migrations.
-   *
-   * @param tenantId - The tenant identifier
-   * @param migrations - Optional pre-loaded migrations
-   * @returns Migration status with counts and pending list
-   *
-   * @example
-   * ```typescript
-   * const status = await executor.getTenantStatus('tenant-123');
-   * if (status.status === 'behind') {
-   *   console.log(`Pending: ${status.pendingMigrations.join(', ')}`);
-   * }
-   * ```
-   */
-  async getTenantStatus(tenantId, migrations) {
-    const schemaName = this.deps.schemaNameTemplate(tenantId);
-    const pool = await this.deps.createPool(schemaName);
-    try {
-      const allMigrations = migrations ?? await this.deps.loadMigrations();
-      const tableExists = await this.deps.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
-        };
-      }
-      const format = await this.deps.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();
-    }
-  }
-  // ============================================================================
-  // IMigrationExecutor Interface Methods
-  // ============================================================================
-  /**
-   * Execute a single migration on a schema
-   */
-  async executeMigration(pool, schemaName, migration, format, options) {
-    if (options?.markOnly) {
-      options.onProgress?.("recording");
-      await this.recordMigration(pool, schemaName, migration, format);
-    } else {
-      options?.onProgress?.("applying");
-      await this.applyMigration(pool, schemaName, migration, format);
-    }
-  }
-  /**
-   * Execute multiple migrations on a schema
-   */
-  async executeMigrations(pool, schemaName, migrations, format, options) {
-    const appliedNames = [];
-    for (const migration of migrations) {
-      await this.executeMigration(pool, schemaName, migration, format, options);
-      appliedNames.push(migration.name);
-    }
-    return appliedNames;
-  }
-  /**
-   * Record a migration as applied without executing SQL
-   */
-  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]
-    );
-  }
-  /**
-   * Get list of applied migrations for a tenant
-   */
-  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 {
-        identifier: row.identifier,
-        // Set name or hash based on format
-        ...format.columns.identifier === "name" ? { name: row.identifier } : { hash: row.identifier },
-        appliedAt
-      };
-    });
-  }
-  /**
-   * Get pending migrations (not yet applied)
-   */
-  async getPendingMigrations(pool, schemaName, allMigrations, format) {
-    const applied = await this.getAppliedMigrations(pool, schemaName, format);
-    const appliedSet = new Set(applied.map((m) => m.identifier));
-    return allMigrations.filter(
-      (m) => !this.isMigrationApplied(m, appliedSet, format)
-    );
-  }
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-  /**
-   * 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);
-  }
-  /**
-   * Apply a migration to a schema (execute SQL + record)
-   */
-  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();
-    }
-  }
-};
-function createMigrationExecutor(config, dependencies) {
-  return new MigrationExecutor(config, dependencies);
-}
-
-// src/migrator/executor/batch-executor.ts
-var BatchExecutor = class {
-  constructor(config, executor, loadMigrations) {
-    this.config = config;
-    this.executor = executor;
-    this.loadMigrations = loadMigrations;
-  }
-  /**
-   * Migrate all tenants in parallel
-   *
-   * Processes tenants in batches with configurable concurrency.
-   * Supports progress callbacks, error handling, and abort behavior.
-   *
-   * @param options - Migration options (concurrency, dryRun, callbacks)
-   * @returns Aggregate results for all tenants
-   *
-   * @example
-   * ```typescript
-   * const results = await batchExecutor.migrateAll({
-   *   concurrency: 10,
-   *   dryRun: false,
-   *   onProgress: (id, status) => console.log(`${id}: ${status}`),
-   *   onError: (id, error) => {
-   *     console.error(`${id} failed: ${error.message}`);
-   *     return 'continue'; // or 'abort' to stop all
-   *   },
-   * });
-   *
-   * console.log(`Succeeded: ${results.succeeded}/${results.total}`);
-   * ```
-   */
-  async migrateAll(options = {}) {
-    const {
-      concurrency = 10,
-      onProgress,
-      onError,
-      dryRun = false
-    } = options;
-    const tenantIds = await this.config.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.executor.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 specific tenants in parallel
-   *
-   * Same as migrateAll but for a subset of tenants.
-   *
-   * @param tenantIds - List of tenant IDs to migrate
-   * @param options - Migration options
-   * @returns Aggregate results for specified tenants
-   *
-   * @example
-   * ```typescript
-   * const results = await batchExecutor.migrateTenants(
-   *   ['tenant-1', 'tenant-2', 'tenant-3'],
-   *   { concurrency: 5 }
-   * );
-   * ```
-   */
-  async migrateTenants(tenantIds, options = {}) {
-    const migrations = await this.loadMigrations();
-    const results = [];
-    const { concurrency = 10, onProgress, onError, dryRun = false } = 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.executor.migrateTenant(tenantId, migrations, { dryRun, 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);
-  }
-  /**
-   * Mark all tenants as applied without executing SQL
-   *
-   * Useful for syncing tracking state with already-applied migrations.
-   * Processes tenants in parallel with configurable concurrency.
-   *
-   * @param options - Migration options
-   * @returns Aggregate results for all tenants
-   *
-   * @example
-   * ```typescript
-   * const results = await batchExecutor.markAllAsApplied({
-   *   concurrency: 10,
-   *   onProgress: (id, status) => console.log(`${id}: ${status}`),
-   * });
-   * ```
-   */
-  async markAllAsApplied(options = {}) {
-    const {
-      concurrency = 10,
-      onProgress,
-      onError
-    } = options;
-    const tenantIds = await this.config.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.executor.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 migration status for all tenants
-   *
-   * Queries each tenant's migration status sequentially.
-   *
-   * @returns List of migration status for all tenants
-   *
-   * @example
-   * ```typescript
-   * const statuses = await batchExecutor.getStatus();
-   * const behind = statuses.filter(s => s.status === 'behind');
-   * console.log(`${behind.length} tenants need migrations`);
-   * ```
-   */
-  async getStatus() {
-    const tenantIds = await this.config.tenantDiscovery();
-    const migrations = await this.loadMigrations();
-    const statuses = [];
-    for (const tenantId of tenantIds) {
-      statuses.push(await this.executor.getTenantStatus(tenantId, migrations));
-    }
-    return statuses;
-  }
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-  /**
-   * Create a skipped result for aborted operations
-   */
-  createSkippedResult(tenantId) {
-    return {
-      tenantId,
-      schemaName: "",
-      // Schema name not available in batch context
-      success: false,
-      appliedMigrations: [],
-      error: "Skipped due to abort",
-      durationMs: 0
-    };
-  }
-  /**
-   * Create an error result for failed operations
-   */
-  createErrorResult(tenantId, error) {
-    return {
-      tenantId,
-      schemaName: "",
-      // Schema name not available in batch context
-      success: false,
-      appliedMigrations: [],
-      error: error.message,
-      durationMs: 0
-    };
-  }
-  /**
-   * Aggregate individual migration results into a summary
-   */
-  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 createBatchExecutor(config, executor, loadMigrations) {
-  return new BatchExecutor(config, executor, loadMigrations);
-}
-
-// src/migrator/clone/ddl-generator.ts
-async function listTables(pool, schemaName, excludeTables = []) {
-  const excludePlaceholders = excludeTables.length > 0 ? excludeTables.map((_, i) => `$${i + 2}`).join(", ") : "''::text";
-  const result = await pool.query(
-    `SELECT table_name
+       ORDER BY table_name`,[n]),o=[];for(let l of s.rows){if(i.includes(l.table_name))continue;let c=await v(e,n,l.table_name),u=r?await j(e,n,l.table_name):[],g=t?await B(e,n,l.table_name):[];o.push({name:l.table_name,columns:c,indexes:u,constraints:g});}return o}};var R=class{constructor(e,n){this.config=e;this.deps=n;}async seedTenant(e,n){let a=Date.now(),r=this.deps.schemaNameTemplate(e),t=await this.deps.createPool(r);try{let i=drizzle(t,{schema:this.deps.tenantSchema});return await n(i,e),{tenantId:e,schemaName:r,success:!0,durationMs:Date.now()-a}}catch(i){return {tenantId:e,schemaName:r,success:false,error:i.message,durationMs:Date.now()-a}}finally{await t.end();}}async seedAll(e,n={}){let{concurrency:a=10,onProgress:r,onError:t}=n,i=await this.config.tenantDiscovery(),s=[],o=false;for(let l=0;l<i.length&&!o;l+=a){let c=i.slice(l,l+a),u=await Promise.all(c.map(async g=>{if(o)return this.createSkippedResult(g);try{r?.(g,"starting"),r?.(g,"seeding");let p=await this.seedTenant(g,e);return r?.(g,p.success?"completed":"failed"),p}catch(p){return r?.(g,"failed"),t?.(g,p)==="abort"&&(o=true),this.createErrorResult(g,p)}}));s.push(...u);}if(o){let l=i.slice(s.length);for(let c of l)s.push(this.createSkippedResult(c));}return this.aggregateResults(s)}async seedTenants(e,n,a={}){let{concurrency:r=10,onProgress:t,onError:i}=a,s=[];for(let o=0;o<e.length;o+=r){let l=e.slice(o,o+r),c=await Promise.all(l.map(async u=>{try{t?.(u,"starting"),t?.(u,"seeding");let g=await this.seedTenant(u,n);return t?.(u,g.success?"completed":"failed"),g}catch(g){return t?.(u,"failed"),i?.(u,g),this.createErrorResult(u,g)}}));s.push(...c);}return this.aggregateResults(s)}createSkippedResult(e){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,error:"Skipped due to abort",durationMs:0}}createErrorResult(e,n){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,error:n.message,durationMs:0}}aggregateResults(e){return {total:e.length,succeeded:e.filter(n=>n.success).length,failed:e.filter(n=>!n.success&&n.error!=="Skipped due to abort").length,skipped:e.filter(n=>n.error==="Skipped due to abort").length,details:e}}};function ce(m,e){return new R(m,e)}var le="public",A=class{constructor(e,n){this.config=e;this.deps=n;this.schemaName=e.schemaName??le;}schemaName;async seed(e){let n=Date.now(),a=await this.deps.createPool();try{this.config.hooks?.onStart?.();let r=drizzle(a,{schema:this.deps.sharedSchema});return await e(r),this.config.hooks?.onComplete?.(),{schemaName:this.schemaName,success:!0,durationMs:Date.now()-n}}catch(r){return this.config.hooks?.onError?.(r),{schemaName:this.schemaName,success:false,error:r.message,durationMs:Date.now()-n}}finally{await a.end();}}};var x=class{constructor(e,n){this.config=e;this.deps=n;}async getSyncStatus(){let e=await this.config.tenantDiscovery(),n=await this.deps.loadMigrations(),a=[];for(let r of e)a.push(await this.getTenantSyncStatus(r,n));return {total:a.length,inSync:a.filter(r=>r.inSync&&!r.error).length,outOfSync:a.filter(r=>!r.inSync&&!r.error).length,error:a.filter(r=>!!r.error).length,details:a}}async getTenantSyncStatus(e,n){let a=this.deps.schemaNameTemplate(e),r=await this.deps.createPool(a);try{let t=n??await this.deps.loadMigrations(),i=new Set(t.map(h=>h.name)),s=new Set(t.map(h=>h.hash));if(!await this.deps.migrationsTableExists(r,a))return {tenantId:e,schemaName:a,missing:t.map(h=>h.name),orphans:[],inSync:t.length===0,format:null};let l=await this.deps.getOrDetectFormat(r,a),c=await this.getAppliedMigrations(r,a,l),u=new Set(c.map(h=>h.identifier)),g=t.filter(h=>!this.isMigrationApplied(h,u,l)).map(h=>h.name),p=c.filter(h=>(l.columns.identifier==="name"||!s.has(h.identifier))&&!i.has(h.identifier)).map(h=>h.identifier);return {tenantId:e,schemaName:a,missing:g,orphans:p,inSync:g.length===0&&p.length===0,format:l.format}}catch(t){return {tenantId:e,schemaName:a,missing:[],orphans:[],inSync:false,format:null,error:t.message}}finally{await r.end();}}async markMissing(e){let n=Date.now(),a=this.deps.schemaNameTemplate(e),r=[],t=await this.deps.createPool(a);try{let i=await this.getTenantSyncStatus(e);if(i.error)return {tenantId:e,schemaName:a,success:!1,markedMigrations:[],removedOrphans:[],error:i.error,durationMs:Date.now()-n};if(i.missing.length===0)return {tenantId:e,schemaName:a,success:!0,markedMigrations:[],removedOrphans:[],durationMs:Date.now()-n};let s=await this.deps.getOrDetectFormat(t,a);await this.deps.ensureMigrationsTable(t,a,s);let o=await this.deps.loadMigrations(),l=new Set(i.missing);for(let c of o)l.has(c.name)&&(await this.recordMigration(t,a,c,s),r.push(c.name));return {tenantId:e,schemaName:a,success:!0,markedMigrations:r,removedOrphans:[],durationMs:Date.now()-n}}catch(i){return {tenantId:e,schemaName:a,success:false,markedMigrations:r,removedOrphans:[],error:i.message,durationMs:Date.now()-n}}finally{await t.end();}}async markAllMissing(e={}){let{concurrency:n=10,onProgress:a,onError:r}=e,t=await this.config.tenantDiscovery(),i=[],s=false;for(let o=0;o<t.length&&!s;o+=n){let l=t.slice(o,o+n),c=await Promise.all(l.map(async u=>{if(s)return this.createSkippedSyncResult(u);try{a?.(u,"starting");let g=await this.markMissing(u);return a?.(u,g.success?"completed":"failed"),g}catch(g){return a?.(u,"failed"),r?.(u,g)==="abort"&&(s=true),this.createErrorSyncResult(u,g)}}));i.push(...c);}return this.aggregateSyncResults(i)}async cleanOrphans(e){let n=Date.now(),a=this.deps.schemaNameTemplate(e),r=[],t=await this.deps.createPool(a);try{let i=await this.getTenantSyncStatus(e);if(i.error)return {tenantId:e,schemaName:a,success:!1,markedMigrations:[],removedOrphans:[],error:i.error,durationMs:Date.now()-n};if(i.orphans.length===0)return {tenantId:e,schemaName:a,success:!0,markedMigrations:[],removedOrphans:[],durationMs:Date.now()-n};let s=await this.deps.getOrDetectFormat(t,a),o=s.columns.identifier;for(let l of i.orphans)await t.query(`DELETE FROM "${a}"."${s.tableName}" WHERE "${o}" = $1`,[l]),r.push(l);return {tenantId:e,schemaName:a,success:!0,markedMigrations:[],removedOrphans:r,durationMs:Date.now()-n}}catch(i){return {tenantId:e,schemaName:a,success:false,markedMigrations:[],removedOrphans:r,error:i.message,durationMs:Date.now()-n}}finally{await t.end();}}async cleanAllOrphans(e={}){let{concurrency:n=10,onProgress:a,onError:r}=e,t=await this.config.tenantDiscovery(),i=[],s=false;for(let o=0;o<t.length&&!s;o+=n){let l=t.slice(o,o+n),c=await Promise.all(l.map(async u=>{if(s)return this.createSkippedSyncResult(u);try{a?.(u,"starting");let g=await this.cleanOrphans(u);return a?.(u,g.success?"completed":"failed"),g}catch(g){return a?.(u,"failed"),r?.(u,g)==="abort"&&(s=true),this.createErrorSyncResult(u,g)}}));i.push(...c);}return this.aggregateSyncResults(i)}async getAppliedMigrations(e,n,a){let r=a.columns.identifier,t=a.columns.timestamp;return (await e.query(`SELECT id, "${r}" as identifier, "${t}" as applied_at
+       FROM "${n}"."${a.tableName}"
+       ORDER BY id`)).rows.map(s=>{let o=a.columns.timestampType==="bigint"?new Date(Number(s.applied_at)):new Date(s.applied_at);return {identifier:s.identifier,appliedAt:o}})}isMigrationApplied(e,n,a){return a.columns.identifier==="name"?n.has(e.name):n.has(e.hash)||n.has(e.name)}async recordMigration(e,n,a,r){let{identifier:t,timestamp:i,timestampType:s}=r.columns,o=t==="name"?a.name:a.hash,l=s==="bigint"?Date.now():new Date;await e.query(`INSERT INTO "${n}"."${r.tableName}" ("${t}", "${i}") VALUES ($1, $2)`,[o,l]);}createSkippedSyncResult(e){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,markedMigrations:[],removedOrphans:[],error:"Skipped due to abort",durationMs:0}}createErrorSyncResult(e,n){return {tenantId:e,schemaName:this.deps.schemaNameTemplate(e),success:false,markedMigrations:[],removedOrphans:[],error:n.message,durationMs:0}}aggregateSyncResults(e){return {total:e.length,succeeded:e.filter(n=>n.success).length,failed:e.filter(n=>!n.success).length,details:e}}};function ue(m,e){return new x(m,e)}var T=class{constructor(e,n){this.config=e;this.deps=n;}async migrateTenant(e,n,a={}){let r=Date.now(),t=this.deps.schemaNameTemplate(e),i=[],s=await this.deps.createPool(t);try{await this.config.hooks?.beforeTenant?.(e);let o=await this.deps.getOrDetectFormat(s,t);await this.deps.ensureMigrationsTable(s,t,o);let l=n??await this.deps.loadMigrations(),c=await this.getAppliedMigrations(s,t,o),u=new Set(c.map(h=>h.identifier)),g=l.filter(h=>!this.isMigrationApplied(h,u,o));if(a.dryRun)return {tenantId:e,schemaName:t,success:!0,appliedMigrations:g.map(h=>h.name),durationMs:Date.now()-r,format:o.format};for(let h of g){let y=Date.now();a.onProgress?.(e,"migrating",h.name),await this.config.hooks?.beforeMigration?.(e,h.name),await this.applyMigration(s,t,h,o),await this.config.hooks?.afterMigration?.(e,h.name,Date.now()-y),i.push(h.name);}let p={tenantId:e,schemaName:t,success:!0,appliedMigrations:i,durationMs:Date.now()-r,format:o.format};return await this.config.hooks?.afterTenant?.(e,p),p}catch(o){let l={tenantId:e,schemaName:t,success:false,appliedMigrations:i,error:o.message,durationMs:Date.now()-r};return await this.config.hooks?.afterTenant?.(e,l),l}finally{await s.end();}}async markAsApplied(e,n={}){let a=Date.now(),r=this.deps.schemaNameTemplate(e),t=[],i=await this.deps.createPool(r);try{await this.config.hooks?.beforeTenant?.(e);let s=await this.deps.getOrDetectFormat(i,r);await this.deps.ensureMigrationsTable(i,r,s);let o=await this.deps.loadMigrations(),l=await this.getAppliedMigrations(i,r,s),c=new Set(l.map(p=>p.identifier)),u=o.filter(p=>!this.isMigrationApplied(p,c,s));for(let p of u){let h=Date.now();n.onProgress?.(e,"migrating",p.name),await this.config.hooks?.beforeMigration?.(e,p.name),await this.recordMigration(i,r,p,s),await this.config.hooks?.afterMigration?.(e,p.name,Date.now()-h),t.push(p.name);}let g={tenantId:e,schemaName:r,success:!0,appliedMigrations:t,durationMs:Date.now()-a,format:s.format};return await this.config.hooks?.afterTenant?.(e,g),g}catch(s){let o={tenantId:e,schemaName:r,success:false,appliedMigrations:t,error:s.message,durationMs:Date.now()-a};return await this.config.hooks?.afterTenant?.(e,o),o}finally{await i.end();}}async getTenantStatus(e,n){let a=this.deps.schemaNameTemplate(e),r=await this.deps.createPool(a);try{let t=n??await this.deps.loadMigrations();if(!await this.deps.migrationsTableExists(r,a))return {tenantId:e,schemaName:a,appliedCount:0,pendingCount:t.length,pendingMigrations:t.map(u=>u.name),status:t.length>0?"behind":"ok",format:null};let s=await this.deps.getOrDetectFormat(r,a),o=await this.getAppliedMigrations(r,a,s),l=new Set(o.map(u=>u.identifier)),c=t.filter(u=>!this.isMigrationApplied(u,l,s));return {tenantId:e,schemaName:a,appliedCount:o.length,pendingCount:c.length,pendingMigrations:c.map(u=>u.name),status:c.length>0?"behind":"ok",format:s.format}}catch(t){return {tenantId:e,schemaName:a,appliedCount:0,pendingCount:0,pendingMigrations:[],status:"error",error:t.message,format:null}}finally{await r.end();}}async executeMigration(e,n,a,r,t){t?.markOnly?(t.onProgress?.("recording"),await this.recordMigration(e,n,a,r)):(t?.onProgress?.("applying"),await this.applyMigration(e,n,a,r));}async executeMigrations(e,n,a,r,t){let i=[];for(let s of a)await this.executeMigration(e,n,s,r,t),i.push(s.name);return i}async recordMigration(e,n,a,r){let{identifier:t,timestamp:i,timestampType:s}=r.columns,o=t==="name"?a.name:a.hash,l=s==="bigint"?Date.now():new Date;await e.query(`INSERT INTO "${n}"."${r.tableName}" ("${t}", "${i}") VALUES ($1, $2)`,[o,l]);}async getAppliedMigrations(e,n,a){let r=a.columns.identifier,t=a.columns.timestamp;return (await e.query(`SELECT id, "${r}" as identifier, "${t}" as applied_at
+       FROM "${n}"."${a.tableName}"
+       ORDER BY id`)).rows.map(s=>{let o=a.columns.timestampType==="bigint"?new Date(Number(s.applied_at)):new Date(s.applied_at);return {identifier:s.identifier,...a.columns.identifier==="name"?{name:s.identifier}:{hash:s.identifier},appliedAt:o}})}async getPendingMigrations(e,n,a,r){let t=await this.getAppliedMigrations(e,n,r),i=new Set(t.map(s=>s.identifier));return a.filter(s=>!this.isMigrationApplied(s,i,r))}isMigrationApplied(e,n,a){return a.columns.identifier==="name"?n.has(e.name):n.has(e.hash)||n.has(e.name)}async applyMigration(e,n,a,r){let t=await e.connect();try{await t.query("BEGIN"),await t.query(a.sql);let{identifier:i,timestamp:s,timestampType:o}=r.columns,l=i==="name"?a.name:a.hash,c=o==="bigint"?Date.now():new Date;await t.query(`INSERT INTO "${n}"."${r.tableName}" ("${i}", "${s}") VALUES ($1, $2)`,[l,c]),await t.query("COMMIT");}catch(i){throw await t.query("ROLLBACK"),i}finally{t.release();}}};function U(m,e){return new T(m,e)}var M=class{constructor(e,n,a){this.config=e;this.executor=n;this.loadMigrations=a;}async migrateAll(e={}){let{concurrency:n=10,onProgress:a,onError:r,dryRun:t=false}=e,i=await this.config.tenantDiscovery(),s=await this.loadMigrations(),o=[],l=false;for(let c=0;c<i.length&&!l;c+=n){let u=i.slice(c,c+n),g=await Promise.all(u.map(async p=>{if(l)return this.createSkippedResult(p);try{a?.(p,"starting");let h=await this.executor.migrateTenant(p,s,{dryRun:t,onProgress:a});return a?.(p,h.success?"completed":"failed"),h}catch(h){return a?.(p,"failed"),r?.(p,h)==="abort"&&(l=true),this.createErrorResult(p,h)}}));o.push(...g);}if(l){let c=i.slice(o.length);for(let u of c)o.push(this.createSkippedResult(u));}return this.aggregateResults(o)}async migrateTenants(e,n={}){let a=await this.loadMigrations(),r=[],{concurrency:t=10,onProgress:i,onError:s,dryRun:o=false}=n;for(let l=0;l<e.length;l+=t){let c=e.slice(l,l+t),u=await Promise.all(c.map(async g=>{try{i?.(g,"starting");let p=await this.executor.migrateTenant(g,a,{dryRun:o,onProgress:i});return i?.(g,p.success?"completed":"failed"),p}catch(p){return i?.(g,"failed"),s?.(g,p),this.createErrorResult(g,p)}}));r.push(...u);}return this.aggregateResults(r)}async markAllAsApplied(e={}){let{concurrency:n=10,onProgress:a,onError:r}=e,t=await this.config.tenantDiscovery(),i=[],s=false;for(let o=0;o<t.length&&!s;o+=n){let l=t.slice(o,o+n),c=await Promise.all(l.map(async u=>{if(s)return this.createSkippedResult(u);try{a?.(u,"starting");let g=await this.executor.markAsApplied(u,{onProgress:a});return a?.(u,g.success?"completed":"failed"),g}catch(g){return a?.(u,"failed"),r?.(u,g)==="abort"&&(s=true),this.createErrorResult(u,g)}}));i.push(...c);}if(s){let o=t.slice(i.length);for(let l of o)i.push(this.createSkippedResult(l));}return this.aggregateResults(i)}async getStatus(){let e=await this.config.tenantDiscovery(),n=await this.loadMigrations(),a=[];for(let r of e)a.push(await this.executor.getTenantStatus(r,n));return a}createSkippedResult(e){return {tenantId:e,schemaName:"",success:false,appliedMigrations:[],error:"Skipped due to abort",durationMs:0}}createErrorResult(e,n){return {tenantId:e,schemaName:"",success:false,appliedMigrations:[],error:n.message,durationMs:0}}aggregateResults(e){return {total:e.length,succeeded:e.filter(n=>n.success).length,failed:e.filter(n=>!n.success&&n.error!=="Skipped due to abort").length,skipped:e.filter(n=>n.error==="Skipped due to abort").length,details:e}}};function H(m,e,n){return new M(m,e,n)}async function Y(m,e,n=[]){let a=n.length>0?n.map((t,i)=>`$${i+2}`).join(", "):"''::text";return (await m.query(`SELECT table_name
      FROM information_schema.tables
      WHERE table_schema = $1
        AND table_type = 'BASE TABLE'
-       AND table_name NOT IN (${excludePlaceholders})
-     ORDER BY table_name`,
-    [schemaName, ...excludeTables]
-  );
-  return result.rows.map((r) => r.table_name);
-}
-async function getColumns(pool, schemaName, tableName) {
-  const result = await pool.query(
-    `SELECT
+       AND table_name NOT IN (${a})
+     ORDER BY table_name`,[e,...n])).rows.map(t=>t.table_name)}async function ge(m,e,n){return (await m.query(`SELECT
       column_name,
       data_type,
       udt_name,
@@ -2255,68 +79,13 @@ async function getColumns(pool, schemaName, tableName) {
       numeric_scale
      FROM information_schema.columns
      WHERE table_schema = $1 AND table_name = $2
-     ORDER BY ordinal_position`,
-    [schemaName, tableName]
-  );
-  return result.rows.map((row) => ({
-    columnName: row.column_name,
-    dataType: row.data_type,
-    udtName: row.udt_name,
-    isNullable: row.is_nullable === "YES",
-    columnDefault: row.column_default,
-    characterMaximumLength: row.character_maximum_length,
-    numericPrecision: row.numeric_precision,
-    numericScale: row.numeric_scale
-  }));
-}
-async function generateTableDdl(pool, schemaName, tableName) {
-  const columns = await getColumns(pool, schemaName, tableName);
-  const columnDefs = columns.map((col) => {
-    let type = col.udtName;
-    if (col.dataType === "character varying" && col.characterMaximumLength) {
-      type = `varchar(${col.characterMaximumLength})`;
-    } else if (col.dataType === "character" && col.characterMaximumLength) {
-      type = `char(${col.characterMaximumLength})`;
-    } else if (col.dataType === "numeric" && col.numericPrecision) {
-      type = `numeric(${col.numericPrecision}${col.numericScale ? `, ${col.numericScale}` : ""})`;
-    } else if (col.dataType === "ARRAY") {
-      type = col.udtName.replace(/^_/, "") + "[]";
-    }
-    let definition = `"${col.columnName}" ${type}`;
-    if (!col.isNullable) {
-      definition += " NOT NULL";
-    }
-    if (col.columnDefault) {
-      const defaultValue = col.columnDefault.replace(
-        new RegExp(`"?${schemaName}"?\\.`, "g"),
-        ""
-      );
-      definition += ` DEFAULT ${defaultValue}`;
-    }
-    return definition;
-  });
-  return `CREATE TABLE IF NOT EXISTS "${tableName}" (
-  ${columnDefs.join(",\n  ")}
-)`;
-}
-async function generateIndexDdls(pool, sourceSchema, targetSchema, tableName) {
-  const result = await pool.query(
-    `SELECT indexname, indexdef
+     ORDER BY ordinal_position`,[e,n])).rows.map(r=>({columnName:r.column_name,dataType:r.data_type,udtName:r.udt_name,isNullable:r.is_nullable==="YES",columnDefault:r.column_default,characterMaximumLength:r.character_maximum_length,numericPrecision:r.numeric_precision,numericScale:r.numeric_scale}))}async function pe(m,e,n){let r=(await ge(m,e,n)).map(t=>{let i=t.udtName;t.dataType==="character varying"&&t.characterMaximumLength?i=`varchar(${t.characterMaximumLength})`:t.dataType==="character"&&t.characterMaximumLength?i=`char(${t.characterMaximumLength})`:t.dataType==="numeric"&&t.numericPrecision?i=`numeric(${t.numericPrecision}${t.numericScale?`, ${t.numericScale}`:""})`:t.dataType==="ARRAY"&&(i=t.udtName.replace(/^_/,"")+"[]");let s=`"${t.columnName}" ${i}`;if(t.isNullable||(s+=" NOT NULL"),t.columnDefault){let o=t.columnDefault.replace(new RegExp(`"?${e}"?\\.`,"g"),"");s+=` DEFAULT ${o}`;}return s});return `CREATE TABLE IF NOT EXISTS "${n}" (
+  ${r.join(`,
+  `)}
+)`}async function he(m,e,n,a){return (await m.query(`SELECT indexname, indexdef
      FROM pg_indexes
      WHERE schemaname = $1 AND tablename = $2
-       AND indexname NOT LIKE '%_pkey'`,
-    [sourceSchema, tableName]
-  );
-  return result.rows.map(
-    (row) => (
-      // Replace source schema with target schema
-      row.indexdef.replace(new RegExp(`ON "${sourceSchema}"\\."`, "g"), `ON "${targetSchema}"."`).replace(new RegExp(`"${sourceSchema}"\\."`, "g"), `"${targetSchema}"."`)
-    )
-  );
-}
-async function generatePrimaryKeyDdl(pool, schemaName, tableName) {
-  const result = await pool.query(
-    `SELECT
+       AND indexname NOT LIKE '%_pkey'`,[e,a])).rows.map(t=>t.indexdef.replace(new RegExp(`ON "${e}"\\."`,"g"),`ON "${n}"."`).replace(new RegExp(`"${e}"\\."`,"g"),`"${n}"."`))}async function de(m,e,n){let a=await m.query(`SELECT
       tc.constraint_name,
       kcu.column_name
      FROM information_schema.table_constraints tc
@@ -2326,17 +95,7 @@ async function generatePrimaryKeyDdl(pool, schemaName, tableName) {
      WHERE tc.table_schema = $1
        AND tc.table_name = $2
        AND tc.constraint_type = 'PRIMARY KEY'
-     ORDER BY kcu.ordinal_position`,
-    [schemaName, tableName]
-  );
-  if (result.rows.length === 0) return null;
-  const columns = result.rows.map((r) => `"${r.column_name}"`).join(", ");
-  const constraintName = result.rows[0].constraint_name;
-  return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${constraintName}" PRIMARY KEY (${columns})`;
-}
-async function generateForeignKeyDdls(pool, sourceSchema, targetSchema, tableName) {
-  const result = await pool.query(
-    `SELECT
+     ORDER BY kcu.ordinal_position`,[e,n]);if(a.rows.length===0)return null;let r=a.rows.map(i=>`"${i.column_name}"`).join(", "),t=a.rows[0].constraint_name;return `ALTER TABLE "${n}" ADD CONSTRAINT "${t}" PRIMARY KEY (${r})`}async function fe(m,e,n,a){let r=await m.query(`SELECT
       tc.constraint_name,
       kcu.column_name,
       ccu.table_name as foreign_table_name,
@@ -2356,43 +115,7 @@ async function generateForeignKeyDdls(pool, sourceSchema, targetSchema, tableNam
      WHERE tc.table_schema = $1
        AND tc.table_name = $2
        AND tc.constraint_type = 'FOREIGN KEY'
-     ORDER BY tc.constraint_name, kcu.ordinal_position`,
-    [sourceSchema, tableName]
-  );
-  const fkMap = /* @__PURE__ */ new Map();
-  for (const row of result.rows) {
-    const existing = fkMap.get(row.constraint_name);
-    if (existing) {
-      existing.columns.push(row.column_name);
-      existing.foreignColumns.push(row.foreign_column_name);
-    } else {
-      fkMap.set(row.constraint_name, {
-        columns: [row.column_name],
-        foreignTable: row.foreign_table_name,
-        foreignColumns: [row.foreign_column_name],
-        updateRule: row.update_rule,
-        deleteRule: row.delete_rule
-      });
-    }
-  }
-  return Array.from(fkMap.entries()).map(([name, fk]) => {
-    const columns = fk.columns.map((c) => `"${c}"`).join(", ");
-    const foreignColumns = fk.foreignColumns.map((c) => `"${c}"`).join(", ");
-    let ddl = `ALTER TABLE "${targetSchema}"."${tableName}" `;
-    ddl += `ADD CONSTRAINT "${name}" FOREIGN KEY (${columns}) `;
-    ddl += `REFERENCES "${targetSchema}"."${fk.foreignTable}" (${foreignColumns})`;
-    if (fk.updateRule !== "NO ACTION") {
-      ddl += ` ON UPDATE ${fk.updateRule}`;
-    }
-    if (fk.deleteRule !== "NO ACTION") {
-      ddl += ` ON DELETE ${fk.deleteRule}`;
-    }
-    return ddl;
-  });
-}
-async function generateUniqueDdls(pool, schemaName, tableName) {
-  const result = await pool.query(
-    `SELECT
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,[e,a]),t=new Map;for(let i of r.rows){let s=t.get(i.constraint_name);s?(s.columns.push(i.column_name),s.foreignColumns.push(i.foreign_column_name)):t.set(i.constraint_name,{columns:[i.column_name],foreignTable:i.foreign_table_name,foreignColumns:[i.foreign_column_name],updateRule:i.update_rule,deleteRule:i.delete_rule});}return Array.from(t.entries()).map(([i,s])=>{let o=s.columns.map(u=>`"${u}"`).join(", "),l=s.foreignColumns.map(u=>`"${u}"`).join(", "),c=`ALTER TABLE "${n}"."${a}" `;return c+=`ADD CONSTRAINT "${i}" FOREIGN KEY (${o}) `,c+=`REFERENCES "${n}"."${s.foreignTable}" (${l})`,s.updateRule!=="NO ACTION"&&(c+=` ON UPDATE ${s.updateRule}`),s.deleteRule!=="NO ACTION"&&(c+=` ON DELETE ${s.deleteRule}`),c})}async function Se(m,e,n){let a=await m.query(`SELECT
       tc.constraint_name,
       kcu.column_name
      FROM information_schema.table_constraints tc
@@ -2402,26 +125,7 @@ async function generateUniqueDdls(pool, schemaName, tableName) {
      WHERE tc.table_schema = $1
        AND tc.table_name = $2
        AND tc.constraint_type = 'UNIQUE'
-     ORDER BY tc.constraint_name, kcu.ordinal_position`,
-    [schemaName, tableName]
-  );
-  const uniqueMap = /* @__PURE__ */ new Map();
-  for (const row of result.rows) {
-    const existing = uniqueMap.get(row.constraint_name);
-    if (existing) {
-      existing.push(row.column_name);
-    } else {
-      uniqueMap.set(row.constraint_name, [row.column_name]);
-    }
-  }
-  return Array.from(uniqueMap.entries()).map(([name, columns]) => {
-    const cols = columns.map((c) => `"${c}"`).join(", ");
-    return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${name}" UNIQUE (${cols})`;
-  });
-}
-async function generateCheckDdls(pool, schemaName, tableName) {
-  const result = await pool.query(
-    `SELECT
+     ORDER BY tc.constraint_name, kcu.ordinal_position`,[e,n]),r=new Map;for(let t of a.rows){let i=r.get(t.constraint_name);i?i.push(t.column_name):r.set(t.constraint_name,[t.column_name]);}return Array.from(r.entries()).map(([t,i])=>{let s=i.map(o=>`"${o}"`).join(", ");return `ALTER TABLE "${n}" ADD CONSTRAINT "${t}" UNIQUE (${s})`})}async function ye(m,e,n){return (await m.query(`SELECT
       tc.constraint_name,
       cc.check_clause
      FROM information_schema.table_constraints tc
@@ -2431,91 +135,12 @@ async function generateCheckDdls(pool, schemaName, tableName) {
      WHERE tc.table_schema = $1
        AND tc.table_name = $2
        AND tc.constraint_type = 'CHECK'
-       AND tc.constraint_name NOT LIKE '%_not_null'`,
-    [schemaName, tableName]
-  );
-  return result.rows.map(
-    (row) => `ALTER TABLE "${tableName}" ADD CONSTRAINT "${row.constraint_name}" CHECK (${row.check_clause})`
-  );
-}
-async function getRowCount(pool, schemaName, tableName) {
-  const result = await pool.query(
-    `SELECT count(*) FROM "${schemaName}"."${tableName}"`
-  );
-  return parseInt(result.rows[0].count, 10);
-}
-async function generateTableCloneInfo(pool, sourceSchema, targetSchema, tableName) {
-  const [createDdl, indexDdls, pkDdl, uniqueDdls, checkDdls, fkDdls, rowCount] = await Promise.all([
-    generateTableDdl(pool, sourceSchema, tableName),
-    generateIndexDdls(pool, sourceSchema, targetSchema, tableName),
-    generatePrimaryKeyDdl(pool, sourceSchema, tableName),
-    generateUniqueDdls(pool, sourceSchema, tableName),
-    generateCheckDdls(pool, sourceSchema, tableName),
-    generateForeignKeyDdls(pool, sourceSchema, targetSchema, tableName),
-    getRowCount(pool, sourceSchema, tableName)
-  ]);
-  return {
-    name: tableName,
-    createDdl,
-    indexDdls,
-    constraintDdls: [
-      ...pkDdl ? [pkDdl] : [],
-      ...uniqueDdls,
-      ...checkDdls,
-      ...fkDdls
-    ],
-    rowCount
-  };
-}
-
-// src/migrator/clone/data-copier.ts
-async function getTableColumns(pool, schemaName, tableName) {
-  const result = await pool.query(
-    `SELECT column_name
+       AND tc.constraint_name NOT LIKE '%_not_null'`,[e,n])).rows.map(r=>`ALTER TABLE "${n}" ADD CONSTRAINT "${r.constraint_name}" CHECK (${r.check_clause})`)}async function Te(m,e,n){let a=await m.query(`SELECT count(*) FROM "${e}"."${n}"`);return parseInt(a.rows[0].count,10)}async function W(m,e,n,a){let[r,t,i,s,o,l,c]=await Promise.all([pe(m,e,a),he(m,e,n,a),de(m,e,a),Se(m,e,a),ye(m,e,a),fe(m,e,n,a),Te(m,e,a)]);return {name:a,createDdl:r,indexDdls:t,constraintDdls:[...i?[i]:[],...s,...o,...l],rowCount:c}}async function Me(m,e,n){return (await m.query(`SELECT column_name
      FROM information_schema.columns
      WHERE table_schema = $1 AND table_name = $2
-     ORDER BY ordinal_position`,
-    [schemaName, tableName]
-  );
-  return result.rows.map((r) => r.column_name);
-}
-function formatAnonymizeValue(value) {
-  if (value === null) {
-    return "NULL";
-  }
-  if (typeof value === "string") {
-    return `'${value.replace(/'/g, "''")}'`;
-  }
-  if (typeof value === "boolean") {
-    return value ? "TRUE" : "FALSE";
-  }
-  return String(value);
-}
-async function copyTableData(pool, sourceSchema, targetSchema, tableName, anonymizeRules) {
-  const columns = await getTableColumns(pool, sourceSchema, tableName);
-  if (columns.length === 0) {
-    return 0;
-  }
-  const tableRules = anonymizeRules?.[tableName] ?? {};
-  const selectColumns = columns.map((col) => {
-    if (col in tableRules) {
-      const value = tableRules[col];
-      return `${formatAnonymizeValue(value)} as "${col}"`;
-    }
-    return `"${col}"`;
-  });
-  const insertColumns = columns.map((c) => `"${c}"`).join(", ");
-  const selectExpr = selectColumns.join(", ");
-  const result = await pool.query(
-    `INSERT INTO "${targetSchema}"."${tableName}" (${insertColumns})
-     SELECT ${selectExpr}
-     FROM "${sourceSchema}"."${tableName}"`
-  );
-  return result.rowCount ?? 0;
-}
-async function getTablesInDependencyOrder(pool, schemaName, tables) {
-  const result = await pool.query(
-    `SELECT DISTINCT
+     ORDER BY ordinal_position`,[e,n])).rows.map(r=>r.column_name)}function _e(m){return m===null?"NULL":typeof m=="string"?`'${m.replace(/'/g,"''")}'`:typeof m=="boolean"?m?"TRUE":"FALSE":String(m)}async function Ee(m,e,n,a,r){let t=await Me(m,e,a);if(t.length===0)return 0;let i=r?.[a]??{},s=t.map(u=>{if(u in i){let g=i[u];return `${_e(g)} as "${u}"`}return `"${u}"`}),o=t.map(u=>`"${u}"`).join(", "),l=s.join(", ");return (await m.query(`INSERT INTO "${n}"."${a}" (${o})
+     SELECT ${l}
+     FROM "${e}"."${a}"`)).rowCount??0}async function be(m,e,n){let a=await m.query(`SELECT DISTINCT
       tc.table_name,
       ccu.table_name as foreign_table_name
      FROM information_schema.table_constraints tc
@@ -2524,587 +149,6 @@ async function getTablesInDependencyOrder(pool, schemaName, tables) {
        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`,
-    [schemaName]
-  );
-  const dependencies = /* @__PURE__ */ new Map();
-  const tableSet = new Set(tables);
-  for (const table of tables) {
-    dependencies.set(table, /* @__PURE__ */ new Set());
-  }
-  for (const row of result.rows) {
-    if (tableSet.has(row.table_name) && tableSet.has(row.foreign_table_name)) {
-      dependencies.get(row.table_name).add(row.foreign_table_name);
-    }
-  }
-  const sorted = [];
-  const inDegree = /* @__PURE__ */ new Map();
-  const queue = [];
-  for (const table of tables) {
-    inDegree.set(table, 0);
-  }
-  for (const [table, deps] of dependencies) {
-    for (const dep of deps) {
-      inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
-    }
-  }
-  for (const [table, degree] of inDegree) {
-    if (degree === 0) {
-      queue.push(table);
-    }
-  }
-  while (queue.length > 0) {
-    const table = queue.shift();
-    sorted.push(table);
-    for (const [otherTable, deps] of dependencies) {
-      if (deps.has(table)) {
-        deps.delete(table);
-        const newDegree = (inDegree.get(otherTable) ?? 0) - 1;
-        inDegree.set(otherTable, newDegree);
-        if (newDegree === 0) {
-          queue.push(otherTable);
-        }
-      }
-    }
-  }
-  const remaining = tables.filter((t) => !sorted.includes(t));
-  return [...sorted, ...remaining];
-}
-async function copyAllData(pool, sourceSchema, targetSchema, tables, anonymizeRules, onProgress) {
-  let totalRows = 0;
-  const orderedTables = await getTablesInDependencyOrder(pool, sourceSchema, tables);
-  await pool.query("SET session_replication_role = replica");
-  try {
-    for (let i = 0; i < orderedTables.length; i++) {
-      const table = orderedTables[i];
-      onProgress?.("copying_data", {
-        table,
-        progress: i + 1,
-        total: orderedTables.length
-      });
-      const rows = await copyTableData(pool, sourceSchema, targetSchema, table, anonymizeRules);
-      totalRows += rows;
-    }
-  } finally {
-    await pool.query("SET session_replication_role = DEFAULT");
-  }
-  return totalRows;
-}
-
-// src/migrator/clone/cloner.ts
-var DEFAULT_MIGRATIONS_TABLE3 = "__drizzle_migrations";
-var Cloner = class {
-  constructor(config, deps) {
-    this.deps = deps;
-    this.migrationsTable = config.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE3;
-  }
-  migrationsTable;
-  /**
-   * Clone a tenant to another
-   *
-   * @param sourceTenantId - Source tenant ID
-   * @param targetTenantId - Target tenant ID
-   * @param options - Clone options
-   * @returns Clone result
-   */
-  async cloneTenant(sourceTenantId, targetTenantId, options = {}) {
-    const startTime = Date.now();
-    const {
-      includeData = false,
-      anonymize,
-      excludeTables = [],
-      onProgress
-    } = options;
-    const sourceSchema = this.deps.schemaNameTemplate(sourceTenantId);
-    const targetSchema = this.deps.schemaNameTemplate(targetTenantId);
-    const allExcludes = [this.migrationsTable, ...excludeTables];
-    let sourcePool = null;
-    let rootPool = null;
-    try {
-      onProgress?.("starting");
-      const sourceExists = await this.deps.schemaExists(sourceTenantId);
-      if (!sourceExists) {
-        return this.createErrorResult(
-          sourceTenantId,
-          targetTenantId,
-          targetSchema,
-          `Source tenant "${sourceTenantId}" does not exist`,
-          startTime
-        );
-      }
-      const targetExists = await this.deps.schemaExists(targetTenantId);
-      if (targetExists) {
-        return this.createErrorResult(
-          sourceTenantId,
-          targetTenantId,
-          targetSchema,
-          `Target tenant "${targetTenantId}" already exists`,
-          startTime
-        );
-      }
-      onProgress?.("introspecting");
-      sourcePool = await this.deps.createPool(sourceSchema);
-      const tables = await listTables(sourcePool, sourceSchema, allExcludes);
-      if (tables.length === 0) {
-        onProgress?.("creating_schema");
-        await this.deps.createSchema(targetTenantId);
-        onProgress?.("completed");
-        return {
-          sourceTenant: sourceTenantId,
-          targetTenant: targetTenantId,
-          targetSchema,
-          success: true,
-          tables: [],
-          durationMs: Date.now() - startTime
-        };
-      }
-      const tableInfos = await Promise.all(
-        tables.map((t) => generateTableCloneInfo(sourcePool, sourceSchema, targetSchema, t))
-      );
-      await sourcePool.end();
-      sourcePool = null;
-      onProgress?.("creating_schema");
-      await this.deps.createSchema(targetTenantId);
-      rootPool = await this.deps.createRootPool();
-      onProgress?.("creating_tables");
-      for (const info of tableInfos) {
-        await rootPool.query(`SET search_path TO "${targetSchema}"; ${info.createDdl}`);
-      }
-      onProgress?.("creating_constraints");
-      for (const info of tableInfos) {
-        for (const constraint of info.constraintDdls.filter((c) => !c.includes("FOREIGN KEY"))) {
-          try {
-            await rootPool.query(`SET search_path TO "${targetSchema}"; ${constraint}`);
-          } catch (error) {
-          }
-        }
-      }
-      onProgress?.("creating_indexes");
-      for (const info of tableInfos) {
-        for (const index of info.indexDdls) {
-          try {
-            await rootPool.query(index);
-          } catch (error) {
-          }
-        }
-      }
-      let rowsCopied = 0;
-      if (includeData) {
-        onProgress?.("copying_data");
-        rowsCopied = await copyAllData(
-          rootPool,
-          sourceSchema,
-          targetSchema,
-          tables,
-          anonymize?.enabled ? anonymize.rules : void 0,
-          onProgress
-        );
-      }
-      for (const info of tableInfos) {
-        for (const fk of info.constraintDdls.filter((c) => c.includes("FOREIGN KEY"))) {
-          try {
-            await rootPool.query(fk);
-          } catch (error) {
-          }
-        }
-      }
-      onProgress?.("completed");
-      const result = {
-        sourceTenant: sourceTenantId,
-        targetTenant: targetTenantId,
-        targetSchema,
-        success: true,
-        tables,
-        durationMs: Date.now() - startTime
-      };
-      if (includeData) {
-        result.rowsCopied = rowsCopied;
-      }
-      return result;
-    } catch (error) {
-      options.onError?.(error);
-      onProgress?.("failed");
-      return this.createErrorResult(
-        sourceTenantId,
-        targetTenantId,
-        targetSchema,
-        error.message,
-        startTime
-      );
-    } finally {
-      if (sourcePool) {
-        await sourcePool.end().catch(() => {
-        });
-      }
-      if (rootPool) {
-        await rootPool.end().catch(() => {
-        });
-      }
-    }
-  }
-  createErrorResult(source, target, schema, error, startTime) {
-    return {
-      sourceTenant: source,
-      targetTenant: target,
-      targetSchema: schema,
-      success: false,
-      error,
-      tables: [],
-      durationMs: Date.now() - startTime
-    };
-  }
-};
-function createCloner(config, dependencies) {
-  return new Cloner(config, dependencies);
-}
-
-// src/migrator/migrator.ts
-var DEFAULT_MIGRATIONS_TABLE4 = "__drizzle_migrations";
-var Migrator = class {
-  constructor(tenantConfig, migratorConfig) {
-    this.migratorConfig = migratorConfig;
-    this.migrationsTable = migratorConfig.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE4;
-    this.schemaManager = new SchemaManager(tenantConfig, this.migrationsTable);
-    this.driftDetector = new DriftDetector(tenantConfig, this.schemaManager, {
-      migrationsTable: this.migrationsTable,
-      tenantDiscovery: migratorConfig.tenantDiscovery
-    });
-    this.seeder = new Seeder(
-      { tenantDiscovery: migratorConfig.tenantDiscovery },
-      {
-        createPool: this.schemaManager.createPool.bind(this.schemaManager),
-        schemaNameTemplate: tenantConfig.isolation.schemaNameTemplate,
-        tenantSchema: tenantConfig.schemas.tenant
-      }
-    );
-    this.syncManager = new SyncManager(
-      {
-        tenantDiscovery: migratorConfig.tenantDiscovery,
-        migrationsFolder: migratorConfig.migrationsFolder,
-        migrationsTable: this.migrationsTable
-      },
-      {
-        createPool: this.schemaManager.createPool.bind(this.schemaManager),
-        schemaNameTemplate: tenantConfig.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 MigrationExecutor(
-      { hooks: migratorConfig.hooks },
-      {
-        createPool: this.schemaManager.createPool.bind(this.schemaManager),
-        schemaNameTemplate: tenantConfig.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 BatchExecutor(
-      { tenantDiscovery: migratorConfig.tenantDiscovery },
-      this.migrationExecutor,
-      this.loadMigrations.bind(this)
-    );
-    this.cloner = new Cloner(
-      { migrationsTable: this.migrationsTable },
-      {
-        createPool: this.schemaManager.createPool.bind(this.schemaManager),
-        createRootPool: this.schemaManager.createRootPool.bind(this.schemaManager),
-        schemaNameTemplate: tenantConfig.isolation.schemaNameTemplate,
-        schemaExists: this.schemaManager.schemaExists.bind(this.schemaManager),
-        createSchema: this.schemaManager.createSchema.bind(this.schemaManager)
-      }
-    );
-  }
-  migrationsTable;
-  schemaManager;
-  driftDetector;
-  seeder;
-  syncManager;
-  migrationExecutor;
-  batchExecutor;
-  cloner;
-  /**
-   * Migrate all tenants in parallel
-   *
-   * Delegates to BatchExecutor for parallel migration operations.
-   */
-  async migrateAll(options = {}) {
-    return this.batchExecutor.migrateAll(options);
-  }
-  /**
-   * Migrate a single tenant
-   *
-   * Delegates to MigrationExecutor for single tenant operations.
-   */
-  async migrateTenant(tenantId, migrations, options = {}) {
-    return this.migrationExecutor.migrateTenant(tenantId, migrations, options);
-  }
-  /**
-   * Migrate specific tenants
-   *
-   * Delegates to BatchExecutor for parallel migration operations.
-   */
-  async migrateTenants(tenantIds, options = {}) {
-    return this.batchExecutor.migrateTenants(tenantIds, options);
-  }
-  /**
-   * Get migration status for all tenants
-   *
-   * Delegates to BatchExecutor for status operations.
-   */
-  async getStatus() {
-    return this.batchExecutor.getStatus();
-  }
-  /**
-   * Get migration status for a specific tenant
-   *
-   * Delegates to MigrationExecutor for single tenant operations.
-   */
-  async getTenantStatus(tenantId, migrations) {
-    return this.migrationExecutor.getTenantStatus(tenantId, migrations);
-  }
-  /**
-   * Create a new tenant schema and optionally apply migrations
-   */
-  async createTenant(tenantId, options = {}) {
-    const { migrate = true } = options;
-    await this.schemaManager.createSchema(tenantId);
-    if (migrate) {
-      await this.migrateTenant(tenantId);
-    }
-  }
-  /**
-   * Drop a tenant schema
-   */
-  async dropTenant(tenantId, options = {}) {
-    await this.schemaManager.dropSchema(tenantId, options);
-  }
-  /**
-   * Check if a tenant schema exists
-   */
-  async tenantExists(tenantId) {
-    return this.schemaManager.schemaExists(tenantId);
-  }
-  /**
-   * Clone a tenant to a new tenant
-   *
-   * By default, clones only schema structure. Use includeData to copy data.
-   *
-   * @example
-   * ```typescript
-   * // Schema-only clone
-   * await migrator.cloneTenant('production', 'dev');
-   *
-   * // Clone with data
-   * await migrator.cloneTenant('production', 'dev', { includeData: true });
-   *
-   * // Clone with anonymization
-   * await migrator.cloneTenant('production', 'dev', {
-   *   includeData: true,
-   *   anonymize: {
-   *     enabled: true,
-   *     rules: {
-   *       users: { email: null, phone: null },
-   *     },
-   *   },
-   * });
-   * ```
-   */
-  async cloneTenant(sourceTenantId, targetTenantId, options = {}) {
-    return this.cloner.cloneTenant(sourceTenantId, targetTenantId, options);
-  }
-  /**
-   * Mark migrations as applied without executing SQL
-   * Useful for syncing tracking state with already-applied migrations
-   *
-   * Delegates to MigrationExecutor for single tenant operations.
-   */
-  async markAsApplied(tenantId, options = {}) {
-    return this.migrationExecutor.markAsApplied(tenantId, options);
-  }
-  /**
-   * Mark migrations as applied for all tenants without executing SQL
-   * Useful for syncing tracking state with already-applied migrations
-   *
-   * Delegates to BatchExecutor for parallel operations.
-   */
-  async markAllAsApplied(options = {}) {
-    return this.batchExecutor.markAllAsApplied(options);
-  }
-  // ============================================================================
-  // Sync Methods (delegated to SyncManager)
-  // ============================================================================
-  /**
-   * Get sync status for all tenants
-   * Detects divergences between migrations on disk and tracking in database
-   */
-  async getSyncStatus() {
-    return this.syncManager.getSyncStatus();
-  }
-  /**
-   * Get sync status for a specific tenant
-   */
-  async getTenantSyncStatus(tenantId, migrations) {
-    return this.syncManager.getTenantSyncStatus(tenantId, migrations);
-  }
-  /**
-   * Mark missing migrations as applied for a tenant
-   */
-  async markMissing(tenantId) {
-    return this.syncManager.markMissing(tenantId);
-  }
-  /**
-   * Mark missing migrations as applied for all tenants
-   */
-  async markAllMissing(options = {}) {
-    return this.syncManager.markAllMissing(options);
-  }
-  /**
-   * Remove orphan migration records for a tenant
-   */
-  async cleanOrphans(tenantId) {
-    return this.syncManager.cleanOrphans(tenantId);
-  }
-  /**
-   * Remove orphan migration records for all tenants
-   */
-  async cleanAllOrphans(options = {}) {
-    return this.syncManager.cleanAllOrphans(options);
-  }
-  // ============================================================================
-  // Seeding Methods (delegated to Seeder)
-  // ============================================================================
-  /**
-   * Seed a single tenant with initial data
-   *
-   * @example
-   * ```typescript
-   * const seed: SeedFunction = async (db, tenantId) => {
-   *   await db.insert(roles).values([
-   *     { name: 'admin', permissions: ['*'] },
-   *     { name: 'user', permissions: ['read'] },
-   *   ]);
-   * };
-   *
-   * await migrator.seedTenant('tenant-123', seed);
-   * ```
-   */
-  async seedTenant(tenantId, seedFn) {
-    return this.seeder.seedTenant(tenantId, seedFn);
-  }
-  /**
-   * Seed all tenants with initial data in parallel
-   *
-   * @example
-   * ```typescript
-   * const seed: SeedFunction = async (db, tenantId) => {
-   *   await db.insert(roles).values([
-   *     { name: 'admin', permissions: ['*'] },
-   *   ]);
-   * };
-   *
-   * await migrator.seedAll(seed, { concurrency: 10 });
-   * ```
-   */
-  async seedAll(seedFn, options = {}) {
-    return this.seeder.seedAll(seedFn, options);
-  }
-  /**
-   * Seed specific tenants with initial data
-   */
-  async seedTenants(tenantIds, seedFn, options = {}) {
-    return this.seeder.seedTenants(tenantIds, seedFn, options);
-  }
-  /**
-   * 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);
-  }
-  /**
-   * Get or detect the format for a schema
-   * Returns the configured format or auto-detects from existing table
-   *
-   * Note: This method is shared with SyncManager and MigrationExecutor via dependency injection.
-   */
-  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);
-  }
-  // ============================================================================
-  // Schema Drift Detection Methods (delegated to DriftDetector)
-  // ============================================================================
-  /**
-   * Detect schema drift across all tenants
-   * Compares each tenant's schema against a reference tenant (first tenant by default)
-   *
-   * @example
-   * ```typescript
-   * const drift = await migrator.getSchemaDrift();
-   * if (drift.withDrift > 0) {
-   *   console.log('Schema drift detected!');
-   *   for (const tenant of drift.details) {
-   *     if (tenant.hasDrift) {
-   *       console.log(`Tenant ${tenant.tenantId} has drift:`);
-   *       for (const table of tenant.tables) {
-   *         for (const col of table.columns) {
-   *           console.log(`  - ${table.table}.${col.column}: ${col.description}`);
-   *         }
-   *       }
-   *     }
-   *   }
-   * }
-   * ```
-   */
-  async getSchemaDrift(options = {}) {
-    return this.driftDetector.detectDrift(options);
-  }
-  /**
-   * Get schema drift for a specific tenant compared to a reference
-   */
-  async getTenantSchemaDrift(tenantId, referenceTenantId, options = {}) {
-    return this.driftDetector.compareTenant(tenantId, referenceTenantId, options);
-  }
-  /**
-   * Introspect the schema of a tenant
-   */
-  async introspectTenantSchema(tenantId, options = {}) {
-    return this.driftDetector.introspectSchema(tenantId, options);
-  }
-};
-function createMigrator(tenantConfig, migratorConfig) {
-  return new Migrator(tenantConfig, migratorConfig);
-}
-
-export { BatchExecutor, Cloner, DEFAULT_FORMAT, DRIZZLE_KIT_FORMAT, MigrationExecutor, Migrator, SchemaManager, Seeder, SyncManager, createBatchExecutor, createCloner, createMigrationExecutor, createMigrator, createSchemaManager, createSeeder, createSyncManager, detectTableFormat, getFormatConfig };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+       AND tc.table_name != ccu.table_name`,[e]),r=new Map,t=new Set(n);for(let c of n)r.set(c,new Set);for(let c of a.rows)t.has(c.table_name)&&t.has(c.foreign_table_name)&&r.get(c.table_name).add(c.foreign_table_name);let i=[],s=new Map,o=[];for(let c of n)s.set(c,0);for(let[c,u]of r)for(let g of u)s.set(g,(s.get(g)??0)+1);for(let[c,u]of s)u===0&&o.push(c);for(;o.length>0;){let c=o.shift();i.push(c);for(let[u,g]of r)if(g.has(c)){g.delete(c);let p=(s.get(u)??0)-1;s.set(u,p),p===0&&o.push(u);}}let l=n.filter(c=>!i.includes(c));return [...i,...l]}async function K(m,e,n,a,r,t){let i=0,s=await be(m,e,a);await m.query("SET session_replication_role = replica");try{for(let o=0;o<s.length;o++){let l=s[o];t?.("copying_data",{table:l,progress:o+1,total:s.length});let c=await Ee(m,e,n,l,r);i+=c;}}finally{await m.query("SET session_replication_role = DEFAULT");}return i}var we="__drizzle_migrations",_=class{constructor(e,n){this.deps=n;this.migrationsTable=e.migrationsTable??we;}migrationsTable;async cloneTenant(e,n,a={}){let r=Date.now(),{includeData:t=false,anonymize:i,excludeTables:s=[],onProgress:o}=a,l=this.deps.schemaNameTemplate(e),c=this.deps.schemaNameTemplate(n),u=[this.migrationsTable,...s],g=null,p=null;try{if(o?.("starting"),!await this.deps.schemaExists(e))return this.createErrorResult(e,n,c,`Source tenant "${e}" does not exist`,r);if(await this.deps.schemaExists(n))return this.createErrorResult(e,n,c,`Target tenant "${n}" already exists`,r);o?.("introspecting"),g=await this.deps.createPool(l);let d=await Y(g,l,u);if(d.length===0)return o?.("creating_schema"),await this.deps.createSchema(n),o?.("completed"),{sourceTenant:e,targetTenant:n,targetSchema:c,success:!0,tables:[],durationMs:Date.now()-r};let f=await Promise.all(d.map(S=>W(g,l,c,S)));await g.end(),g=null,o?.("creating_schema"),await this.deps.createSchema(n),p=await this.deps.createRootPool(),o?.("creating_tables");for(let S of f)await p.query(`SET search_path TO "${c}"; ${S.createDdl}`);o?.("creating_constraints");for(let S of f)for(let C of S.constraintDdls.filter(b=>!b.includes("FOREIGN KEY")))try{await p.query(`SET search_path TO "${c}"; ${C}`);}catch{}o?.("creating_indexes");for(let S of f)for(let C of S.indexDdls)try{await p.query(C);}catch{}let P=0;t&&(o?.("copying_data"),P=await K(p,l,c,d,i?.enabled?i.rules:void 0,o));for(let S of f)for(let C of S.constraintDdls.filter(b=>b.includes("FOREIGN KEY")))try{await p.query(C);}catch{}o?.("completed");let $={sourceTenant:e,targetTenant:n,targetSchema:c,success:!0,tables:d,durationMs:Date.now()-r};return t&&($.rowsCopied=P),$}catch(h){return a.onError?.(h),o?.("failed"),this.createErrorResult(e,n,c,h.message,r)}finally{g&&await g.end().catch(()=>{}),p&&await p.end().catch(()=>{});}}createErrorResult(e,n,a,r,t){return {sourceTenant:e,targetTenant:n,targetSchema:a,success:false,error:r,tables:[],durationMs:Date.now()-t}}};function V(m,e){return new _(m,e)}var De="public",E=class{constructor(e,n){this.config=e;this.deps=n;this.schemaName=e.schemaName??De;}schemaName;async migrate(e={}){let n=Date.now(),a=[],r=await this.deps.createPool();try{e.onProgress?.("starting"),await this.config.hooks?.beforeMigration?.();let t=await this.deps.getOrDetectFormat(r,this.schemaName);await this.deps.ensureMigrationsTable(r,this.schemaName,t);let i=await this.deps.loadMigrations(),s=await this.getAppliedMigrations(r,t),o=new Set(s.map(c=>c.identifier)),l=i.filter(c=>!this.isMigrationApplied(c,o,t));if(e.dryRun)return {schemaName:this.schemaName,success:!0,appliedMigrations:l.map(c=>c.name),durationMs:Date.now()-n,format:t.format};for(let c of l){let u=Date.now();e.onProgress?.("migrating",c.name),await this.applyMigration(r,c,t),await this.config.hooks?.afterMigration?.(c.name,Date.now()-u),a.push(c.name);}return e.onProgress?.("completed"),{schemaName:this.schemaName,success:!0,appliedMigrations:a,durationMs:Date.now()-n,format:t.format}}catch(t){return e.onProgress?.("failed"),{schemaName:this.schemaName,success:false,appliedMigrations:a,error:t.message,durationMs:Date.now()-n}}finally{await r.end();}}async markAsApplied(e={}){let n=Date.now(),a=[],r=await this.deps.createPool();try{e.onProgress?.("starting");let t=await this.deps.getOrDetectFormat(r,this.schemaName);await this.deps.ensureMigrationsTable(r,this.schemaName,t);let i=await this.deps.loadMigrations(),s=await this.getAppliedMigrations(r,t),o=new Set(s.map(c=>c.identifier)),l=i.filter(c=>!this.isMigrationApplied(c,o,t));for(let c of l)e.onProgress?.("migrating",c.name),await this.recordMigration(r,c,t),a.push(c.name);return e.onProgress?.("completed"),{schemaName:this.schemaName,success:!0,appliedMigrations:a,durationMs:Date.now()-n,format:t.format}}catch(t){return e.onProgress?.("failed"),{schemaName:this.schemaName,success:false,appliedMigrations:a,error:t.message,durationMs:Date.now()-n}}finally{await r.end();}}async getStatus(){let e=await this.deps.createPool();try{let n=await this.deps.loadMigrations();if(!await this.deps.migrationsTableExists(e,this.schemaName))return {schemaName:this.schemaName,appliedCount:0,pendingCount:n.length,pendingMigrations:n.map(o=>o.name),status:n.length>0?"behind":"ok",format:null};let r=await this.deps.getOrDetectFormat(e,this.schemaName),t=await this.getAppliedMigrations(e,r),i=new Set(t.map(o=>o.identifier)),s=n.filter(o=>!this.isMigrationApplied(o,i,r));return {schemaName:this.schemaName,appliedCount:t.length,pendingCount:s.length,pendingMigrations:s.map(o=>o.name),status:s.length>0?"behind":"ok",format:r.format}}catch(n){return {schemaName:this.schemaName,appliedCount:0,pendingCount:0,pendingMigrations:[],status:"error",error:n.message,format:null}}finally{await e.end();}}async getAppliedMigrations(e,n){let a=n.columns.identifier,r=n.columns.timestamp;return (await e.query(`SELECT id, "${a}" as identifier, "${r}" as applied_at
+       FROM "${this.schemaName}"."${n.tableName}"
+       ORDER BY id`)).rows.map(i=>{let s=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:s}})}isMigrationApplied(e,n,a){return a.columns.identifier==="name"?n.has(e.name):n.has(e.hash)||n.has(e.name)}async applyMigration(e,n,a){let r=await e.connect();try{await r.query("BEGIN"),await r.query(n.sql);let{identifier:t,timestamp:i,timestampType:s}=a.columns,o=t==="name"?n.name:n.hash,l=s==="bigint"?Date.now():new Date;await r.query(`INSERT INTO "${this.schemaName}"."${a.tableName}" ("${t}", "${i}") VALUES ($1, $2)`,[o,l]),await r.query("COMMIT");}catch(t){throw await r.query("ROLLBACK"),t}finally{r.release();}}async recordMigration(e,n,a){let{identifier:r,timestamp:t,timestampType:i}=a.columns,s=r==="name"?n.name:n.hash,o=i==="bigint"?Date.now():new Date;await e.query(`INSERT INTO "${this.schemaName}"."${a.tableName}" ("${r}", "${t}") VALUES ($1, $2)`,[s,o]);}};function G(m,e){return new E(m,e)}var xe="__drizzle_migrations",te="__drizzle_shared_migrations",F=class{constructor(e,n){this.migratorConfig=n;if(this.migrationsTable=n.migrationsTable??xe,this.schemaManager=new D(e,this.migrationsTable),this.driftDetector=new O(e,this.schemaManager,{migrationsTable:this.migrationsTable,tenantDiscovery:n.tenantDiscovery}),this.seeder=new R({tenantDiscovery:n.tenantDiscovery},{createPool:this.schemaManager.createPool.bind(this.schemaManager),schemaNameTemplate:e.isolation.schemaNameTemplate,tenantSchema:e.schemas.tenant}),this.syncManager=new x({tenantDiscovery:n.tenantDiscovery,migrationsFolder:n.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 T({hooks:n.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 M({tenantDiscovery:n.tenantDiscovery},this.migrationExecutor,this.loadMigrations.bind(this)),this.cloner=new _({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)}),n.sharedMigrationsFolder&&existsSync(n.sharedMigrationsFolder)){let a=n.sharedMigrationsTable??te,r=n.sharedHooks,t={schemaName:"public",migrationsTable:a};(r?.beforeMigration||r?.afterApply)&&(t.hooks={},r.beforeMigration&&(t.hooks.beforeMigration=r.beforeMigration),r.afterApply&&(t.hooks.afterMigration=r.afterApply)),this.sharedMigrationExecutor=new E(t,{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 A({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,n,a={}){return this.migrationExecutor.migrateTenant(e,n,a)}async migrateTenants(e,n={}){return this.batchExecutor.migrateTenants(e,n)}async getStatus(){return this.batchExecutor.getStatus()}async getTenantStatus(e,n){return this.migrationExecutor.getTenantStatus(e,n)}async createTenant(e,n={}){let{migrate:a=true}=n;await this.schemaManager.createSchema(e),a&&await this.migrateTenant(e);}async dropTenant(e,n={}){await this.schemaManager.dropSchema(e,n);}async tenantExists(e){return this.schemaManager.schemaExists(e)}async cloneTenant(e,n,a={}){return this.cloner.cloneTenant(e,n,a)}async markAsApplied(e,n={}){return this.migrationExecutor.markAsApplied(e,n)}async markAllAsApplied(e={}){return this.batchExecutor.markAllAsApplied(e)}async getSyncStatus(){return this.syncManager.getSyncStatus()}async getTenantSyncStatus(e,n){return this.syncManager.getTenantSyncStatus(e,n)}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,n){return this.seeder.seedTenant(e,n)}async seedAll(e,n={}){return this.seeder.seedAll(e,n)}async seedTenants(e,n,a={}){return this.seeder.seedTenants(e,n,a)}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,n,a={}){let r=await this.seedShared(e),t=await this.seedAll(n,a);return {shared:r,tenants:t}}async loadMigrations(){let e=await readdir(this.migratorConfig.migrationsFolder),n=[];for(let a of e){if(!a.endsWith(".sql"))continue;let r=join(this.migratorConfig.migrationsFolder,a),t=await readFile(r,"utf-8"),i=a.match(/^(\d+)_/),s=i?.[1]?parseInt(i[1],10):0,o=createHash("sha256").update(t).digest("hex");n.push({name:basename(a,".sql"),path:r,sql:t,timestamp:s,hash:o});}return n.sort((a,r)=>a.timestamp-r.timestamp)}async getOrDetectFormat(e,n){let a=this.migratorConfig.tableFormat??"auto";if(a!=="auto")return w(a,this.migrationsTable);let r=await N(e,n,this.migrationsTable);if(r)return r;let t=this.migratorConfig.defaultFormat??"name";return w(t,this.migrationsTable)}async loadSharedMigrations(){if(!this.migratorConfig.sharedMigrationsFolder)return [];let e=await readdir(this.migratorConfig.sharedMigrationsFolder),n=[];for(let a of e){if(!a.endsWith(".sql"))continue;let r=join(this.migratorConfig.sharedMigrationsFolder,a),t=await readFile(r,"utf-8"),i=a.match(/^(\d+)_/),s=i?.[1]?parseInt(i[1],10):0,o=createHash("sha256").update(t).digest("hex");n.push({name:basename(a,".sql"),path:r,sql:t,timestamp:s,hash:o});}return n.sort((a,r)=>a.timestamp-r.timestamp)}async getOrDetectSharedFormat(e,n){let a=this.migratorConfig.sharedMigrationsTable??te,r=this.migratorConfig.sharedTableFormat??this.migratorConfig.tableFormat??"auto";if(r!=="auto")return w(r,a);let t=await N(e,n,a);if(t)return t;let i=this.migratorConfig.sharedDefaultFormat??this.migratorConfig.defaultFormat??"name";return w(i,a)}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:n,...a}=e,r=await this.migrateShared(n??{}),t=await this.migrateAll(a);return {shared:r,tenants:t}}async getSchemaDrift(e={}){return this.driftDetector.detectDrift(e)}async getTenantSchemaDrift(e,n,a={}){return this.driftDetector.compareTenant(e,n,a)}async introspectTenantSchema(e,n={}){return this.driftDetector.introspectSchema(e,n)}};function Ce(m,e){return new F(m,e)}export{M as BatchExecutor,_ as Cloner,ne as DEFAULT_FORMAT,ae as DRIZZLE_KIT_FORMAT,T as MigrationExecutor,F as Migrator,D as SchemaManager,R as Seeder,E as SharedMigrationExecutor,x as SyncManager,H as createBatchExecutor,V as createCloner,U as createMigrationExecutor,Ce as createMigrator,ie as createSchemaManager,ce as createSeeder,G as createSharedMigrationExecutor,ue as createSyncManager,N as detectTableFormat,w as getFormatConfig};