drizzle-multitenant 1.0.8 → 1.0.10

package/dist/migrator/index.d.ts

@@ -1,4 +1,4 @@
-import { C as Config } from '../types-DKVaTaIb.js';
+import { C as Config } from '../types-B5eSRLFW.js';
 import { Pool } from 'pg';
 import 'drizzle-orm/node-postgres';
 
@@ -191,6 +191,67 @@ interface AppliedMigration {
     hash?: string;
     appliedAt: Date;
 }
+/**
+ * Sync status for a single tenant
+ */
+interface TenantSyncStatus {
+    tenantId: string;
+    schemaName: string;
+    /** Migrations in disk but not tracked in database */
+    missing: string[];
+    /** Migrations tracked in database but not found in disk */
+    orphans: string[];
+    /** Whether the tenant is in sync */
+    inSync: boolean;
+    /** Table format used */
+    format: TableFormat | null;
+    /** Error if any */
+    error?: string;
+}
+/**
+ * Aggregate sync status
+ */
+interface SyncStatus {
+    total: number;
+    inSync: number;
+    outOfSync: number;
+    error: number;
+    details: TenantSyncStatus[];
+}
+/**
+ * Sync result for a single tenant
+ */
+interface TenantSyncResult {
+    tenantId: string;
+    schemaName: string;
+    success: boolean;
+    /** Migrations that were marked as applied */
+    markedMigrations: string[];
+    /** Orphan records that were removed */
+    removedOrphans: string[];
+    error?: string;
+    durationMs: number;
+}
+/**
+ * Aggregate sync results
+ */
+interface SyncResults {
+    total: number;
+    succeeded: number;
+    failed: number;
+    details: TenantSyncResult[];
+}
+/**
+ * Options for sync operations
+ */
+interface SyncOptions {
+    /** Number of concurrent operations */
+    concurrency?: number;
+    /** Progress callback */
+    onProgress?: (tenantId: string, status: 'starting' | 'syncing' | 'completed' | 'failed') => void;
+    /** Error handler */
+    onError?: MigrationErrorHandler;
+}
 
 /**
  * Parallel migration engine for multi-tenant applications
@@ -235,6 +296,43 @@ declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSch
      * Check if a tenant schema exists
      */
     tenantExists(tenantId: string): Promise<boolean>;
+    /**
+     * Mark migrations as applied without executing SQL
+     * Useful for syncing tracking state with already-applied migrations
+     */
+    markAsApplied(tenantId: string, options?: {
+        onProgress?: MigrateOptions['onProgress'];
+    }): Promise<TenantMigrationResult>;
+    /**
+     * Mark migrations as applied for all tenants without executing SQL
+     * Useful for syncing tracking state with already-applied migrations
+     */
+    markAllAsApplied(options?: MigrateOptions): Promise<MigrationResults>;
+    /**
+     * Get sync status for all tenants
+     * Detects divergences between migrations on disk and tracking in database
+     */
+    getSyncStatus(): Promise<SyncStatus>;
+    /**
+     * Get sync status for a specific tenant
+     */
+    getTenantSyncStatus(tenantId: string, migrations?: MigrationFile[]): Promise<TenantSyncStatus>;
+    /**
+     * Mark missing migrations as applied for a tenant
+     */
+    markMissing(tenantId: string): Promise<TenantSyncResult>;
+    /**
+     * Mark missing migrations as applied for all tenants
+     */
+    markAllMissing(options?: SyncOptions): Promise<SyncResults>;
+    /**
+     * Remove orphan migration records for a tenant
+     */
+    cleanOrphans(tenantId: string): Promise<TenantSyncResult>;
+    /**
+     * Remove orphan migration records for all tenants
+     */
+    cleanAllOrphans(options?: SyncOptions): Promise<SyncResults>;
     /**
      * Load migration files from the migrations folder
      */
@@ -268,6 +366,11 @@ declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSch
      * Apply a migration to a schema
      */
     private applyMigration;
+    /**
+     * Record a migration as applied without executing SQL
+     * Used by markAsApplied to sync tracking state
+     */
+    private recordMigration;
     /**
      * Create a skipped result
      */
@@ -280,6 +383,18 @@ declare class Migrator<TTenantSchema extends Record<string, unknown>, TSharedSch
      * Aggregate migration results
      */
     private aggregateResults;
+    /**
+     * Create a skipped sync result
+     */
+    private createSkippedSyncResult;
+    /**
+     * Create an error sync result
+     */
+    private createErrorSyncResult;
+    /**
+     * Aggregate sync results
+     */
+    private aggregateSyncResults;
 }
 /**
  * Create a migrator instance

package/dist/migrator/index.js

@@ -380,6 +380,372 @@ var Migrator = class {
       await pool.end();
     }
   }
+  /**
+   * Mark migrations as applied without executing SQL
+   * Useful for syncing tracking state with already-applied migrations
+   */
+  async markAsApplied(tenantId, options = {}) {
+    const startTime = Date.now();
+    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+    const markedMigrations = [];
+    const pool = await this.createPool(schemaName);
+    try {
+      await this.migratorConfig.hooks?.beforeTenant?.(tenantId);
+      const format = await this.getOrDetectFormat(pool, schemaName);
+      await this.ensureMigrationsTable(pool, schemaName, format);
+      const allMigrations = await this.loadMigrations();
+      const applied = await this.getAppliedMigrations(pool, schemaName, format);
+      const appliedSet = new Set(applied.map((m) => m.identifier));
+      const pending = allMigrations.filter(
+        (m) => !this.isMigrationApplied(m, appliedSet, format)
+      );
+      for (const migration of pending) {
+        const migrationStart = Date.now();
+        options.onProgress?.(tenantId, "migrating", migration.name);
+        await this.migratorConfig.hooks?.beforeMigration?.(tenantId, migration.name);
+        await this.recordMigration(pool, schemaName, migration, format);
+        await this.migratorConfig.hooks?.afterMigration?.(
+          tenantId,
+          migration.name,
+          Date.now() - migrationStart
+        );
+        markedMigrations.push(migration.name);
+      }
+      const result = {
+        tenantId,
+        schemaName,
+        success: true,
+        appliedMigrations: markedMigrations,
+        durationMs: Date.now() - startTime,
+        format: format.format
+      };
+      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
+      return result;
+    } catch (error) {
+      const result = {
+        tenantId,
+        schemaName,
+        success: false,
+        appliedMigrations: markedMigrations,
+        error: error.message,
+        durationMs: Date.now() - startTime
+      };
+      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
+      return result;
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Mark migrations as applied for all tenants without executing SQL
+   * Useful for syncing tracking state with already-applied migrations
+   */
+  async markAllAsApplied(options = {}) {
+    const {
+      concurrency = 10,
+      onProgress,
+      onError
+    } = options;
+    const tenantIds = await this.migratorConfig.tenantDiscovery();
+    const results = [];
+    let aborted = false;
+    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          if (aborted) {
+            return this.createSkippedResult(tenantId);
+          }
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.markAsApplied(tenantId, { onProgress });
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorResult(tenantId, error);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    if (aborted) {
+      const remaining = tenantIds.slice(results.length);
+      for (const tenantId of remaining) {
+        results.push(this.createSkippedResult(tenantId));
+      }
+    }
+    return this.aggregateResults(results);
+  }
+  /**
+   * Get sync status for all tenants
+   * Detects divergences between migrations on disk and tracking in database
+   */
+  async getSyncStatus() {
+    const tenantIds = await this.migratorConfig.tenantDiscovery();
+    const migrations = await this.loadMigrations();
+    const statuses = [];
+    for (const tenantId of tenantIds) {
+      statuses.push(await this.getTenantSyncStatus(tenantId, migrations));
+    }
+    return {
+      total: statuses.length,
+      inSync: statuses.filter((s) => s.inSync && !s.error).length,
+      outOfSync: statuses.filter((s) => !s.inSync && !s.error).length,
+      error: statuses.filter((s) => !!s.error).length,
+      details: statuses
+    };
+  }
+  /**
+   * Get sync status for a specific tenant
+   */
+  async getTenantSyncStatus(tenantId, migrations) {
+    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+    const pool = await this.createPool(schemaName);
+    try {
+      const allMigrations = migrations ?? await this.loadMigrations();
+      const migrationNames = new Set(allMigrations.map((m) => m.name));
+      const migrationHashes = new Set(allMigrations.map((m) => m.hash));
+      const tableExists = await this.migrationsTableExists(pool, schemaName);
+      if (!tableExists) {
+        return {
+          tenantId,
+          schemaName,
+          missing: allMigrations.map((m) => m.name),
+          orphans: [],
+          inSync: allMigrations.length === 0,
+          format: null
+        };
+      }
+      const format = await this.getOrDetectFormat(pool, schemaName);
+      const applied = await this.getAppliedMigrations(pool, schemaName, format);
+      const appliedIdentifiers = new Set(applied.map((m) => m.identifier));
+      const missing = allMigrations.filter((m) => !this.isMigrationApplied(m, appliedIdentifiers, format)).map((m) => m.name);
+      const orphans = applied.filter((m) => {
+        if (format.columns.identifier === "name") {
+          return !migrationNames.has(m.identifier);
+        }
+        return !migrationHashes.has(m.identifier) && !migrationNames.has(m.identifier);
+      }).map((m) => m.identifier);
+      return {
+        tenantId,
+        schemaName,
+        missing,
+        orphans,
+        inSync: missing.length === 0 && orphans.length === 0,
+        format: format.format
+      };
+    } catch (error) {
+      return {
+        tenantId,
+        schemaName,
+        missing: [],
+        orphans: [],
+        inSync: false,
+        format: null,
+        error: error.message
+      };
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Mark missing migrations as applied for a tenant
+   */
+  async markMissing(tenantId) {
+    const startTime = Date.now();
+    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+    const markedMigrations = [];
+    const pool = await this.createPool(schemaName);
+    try {
+      const syncStatus = await this.getTenantSyncStatus(tenantId);
+      if (syncStatus.error) {
+        return {
+          tenantId,
+          schemaName,
+          success: false,
+          markedMigrations: [],
+          removedOrphans: [],
+          error: syncStatus.error,
+          durationMs: Date.now() - startTime
+        };
+      }
+      if (syncStatus.missing.length === 0) {
+        return {
+          tenantId,
+          schemaName,
+          success: true,
+          markedMigrations: [],
+          removedOrphans: [],
+          durationMs: Date.now() - startTime
+        };
+      }
+      const format = await this.getOrDetectFormat(pool, schemaName);
+      await this.ensureMigrationsTable(pool, schemaName, format);
+      const allMigrations = await this.loadMigrations();
+      const missingSet = new Set(syncStatus.missing);
+      for (const migration of allMigrations) {
+        if (missingSet.has(migration.name)) {
+          await this.recordMigration(pool, schemaName, migration, format);
+          markedMigrations.push(migration.name);
+        }
+      }
+      return {
+        tenantId,
+        schemaName,
+        success: true,
+        markedMigrations,
+        removedOrphans: [],
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        tenantId,
+        schemaName,
+        success: false,
+        markedMigrations,
+        removedOrphans: [],
+        error: error.message,
+        durationMs: Date.now() - startTime
+      };
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Mark missing migrations as applied for all tenants
+   */
+  async markAllMissing(options = {}) {
+    const { concurrency = 10, onProgress, onError } = options;
+    const tenantIds = await this.migratorConfig.tenantDiscovery();
+    const results = [];
+    let aborted = false;
+    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          if (aborted) {
+            return this.createSkippedSyncResult(tenantId);
+          }
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.markMissing(tenantId);
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorSyncResult(tenantId, error);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return this.aggregateSyncResults(results);
+  }
+  /**
+   * Remove orphan migration records for a tenant
+   */
+  async cleanOrphans(tenantId) {
+    const startTime = Date.now();
+    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+    const removedOrphans = [];
+    const pool = await this.createPool(schemaName);
+    try {
+      const syncStatus = await this.getTenantSyncStatus(tenantId);
+      if (syncStatus.error) {
+        return {
+          tenantId,
+          schemaName,
+          success: false,
+          markedMigrations: [],
+          removedOrphans: [],
+          error: syncStatus.error,
+          durationMs: Date.now() - startTime
+        };
+      }
+      if (syncStatus.orphans.length === 0) {
+        return {
+          tenantId,
+          schemaName,
+          success: true,
+          markedMigrations: [],
+          removedOrphans: [],
+          durationMs: Date.now() - startTime
+        };
+      }
+      const format = await this.getOrDetectFormat(pool, schemaName);
+      const identifierColumn = format.columns.identifier;
+      for (const orphan of syncStatus.orphans) {
+        await pool.query(
+          `DELETE FROM "${schemaName}"."${format.tableName}" WHERE "${identifierColumn}" = $1`,
+          [orphan]
+        );
+        removedOrphans.push(orphan);
+      }
+      return {
+        tenantId,
+        schemaName,
+        success: true,
+        markedMigrations: [],
+        removedOrphans,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        tenantId,
+        schemaName,
+        success: false,
+        markedMigrations: [],
+        removedOrphans,
+        error: error.message,
+        durationMs: Date.now() - startTime
+      };
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Remove orphan migration records for all tenants
+   */
+  async cleanAllOrphans(options = {}) {
+    const { concurrency = 10, onProgress, onError } = options;
+    const tenantIds = await this.migratorConfig.tenantDiscovery();
+    const results = [];
+    let aborted = false;
+    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          if (aborted) {
+            return this.createSkippedSyncResult(tenantId);
+          }
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.cleanOrphans(tenantId);
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorSyncResult(tenantId, error);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return this.aggregateSyncResults(results);
+  }
   /**
    * Load migration files from the migrations folder
    */
@@ -509,6 +875,19 @@ var Migrator = class {
       client.release();
     }
   }
+  /**
+   * Record a migration as applied without executing SQL
+   * Used by markAsApplied to sync tracking state
+   */
+  async recordMigration(pool, schemaName, migration, format) {
+    const { identifier, timestamp, timestampType } = format.columns;
+    const identifierValue = identifier === "name" ? migration.name : migration.hash;
+    const timestampValue = timestampType === "bigint" ? Date.now() : /* @__PURE__ */ new Date();
+    await pool.query(
+      `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
+      [identifierValue, timestampValue]
+    );
+  }
   /**
    * Create a skipped result
    */
@@ -547,6 +926,45 @@ var Migrator = class {
       details: results
     };
   }
+  /**
+   * Create a skipped sync result
+   */
+  createSkippedSyncResult(tenantId) {
+    return {
+      tenantId,
+      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
+      success: false,
+      markedMigrations: [],
+      removedOrphans: [],
+      error: "Skipped due to abort",
+      durationMs: 0
+    };
+  }
+  /**
+   * Create an error sync result
+   */
+  createErrorSyncResult(tenantId, error) {
+    return {
+      tenantId,
+      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
+      success: false,
+      markedMigrations: [],
+      removedOrphans: [],
+      error: error.message,
+      durationMs: 0
+    };
+  }
+  /**
+   * Aggregate sync results
+   */
+  aggregateSyncResults(results) {
+    return {
+      total: results.length,
+      succeeded: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success).length,
+      details: results
+    };
+  }
 };
 function createMigrator(tenantConfig, migratorConfig) {
   return new Migrator(tenantConfig, migratorConfig);