drizzle-multitenant 1.0.8 → 1.0.10

package/dist/cli/index.js

@@ -370,6 +370,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 (error2) {
+      const result = {
+        tenantId,
+        schemaName,
+        success: false,
+        appliedMigrations: markedMigrations,
+        error: error2.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 (error2) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error2);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorResult(tenantId, error2);
+          }
+        })
+      );
+      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 (error2) {
+      return {
+        tenantId,
+        schemaName,
+        missing: [],
+        orphans: [],
+        inSync: false,
+        format: null,
+        error: error2.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 (error2) {
+      return {
+        tenantId,
+        schemaName,
+        success: false,
+        markedMigrations,
+        removedOrphans: [],
+        error: error2.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 (error2) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error2);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorSyncResult(tenantId, error2);
+          }
+        })
+      );
+      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 (error2) {
+      return {
+        tenantId,
+        schemaName,
+        success: false,
+        markedMigrations: [],
+        removedOrphans,
+        error: error2.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 (error2) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error2);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorSyncResult(tenantId, error2);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return this.aggregateSyncResults(results);
+  }
   /**
    * Load migration files from the migrations folder
    */
@@ -499,6 +865,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
    */
@@ -537,6 +916,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, error2) {
+    return {
+      tenantId,
+      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
+      success: false,
+      markedMigrations: [],
+      removedOrphans: [],
+      error: error2.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);
@@ -969,7 +1387,7 @@ function handleError(err) {
 }
 
 // src/cli/commands/migrate.ts
-var migrateCommand = new Command("migrate").description("Apply pending migrations to tenant schemas").option("-c, --config <path>", "Path to config file").option("-a, --all", "Migrate all tenants").option("-t, --tenant <id>", "Migrate a specific tenant").option("--tenants <ids>", "Migrate specific tenants (comma-separated)").option("--concurrency <number>", "Number of concurrent migrations", "10").option("--dry-run", "Show what would be applied without executing").option("--migrations-folder <path>", "Path to migrations folder").addHelpText("after", `
+var migrateCommand = new Command("migrate").description("Apply pending migrations to tenant schemas").option("-c, --config <path>", "Path to config file").option("-a, --all", "Migrate all tenants").option("-t, --tenant <id>", "Migrate a specific tenant").option("--tenants <ids>", "Migrate specific tenants (comma-separated)").option("--concurrency <number>", "Number of concurrent migrations", "10").option("--dry-run", "Show what would be applied without executing").option("--mark-applied", "Mark migrations as applied without executing SQL").option("--migrations-folder <path>", "Path to migrations folder").addHelpText("after", `
 Examples:
   $ drizzle-multitenant migrate --all
   $ drizzle-multitenant migrate --tenant=my-tenant
@@ -977,6 +1395,7 @@ Examples:
   $ drizzle-multitenant migrate --all --dry-run
   $ drizzle-multitenant migrate --all --concurrency=5
   $ drizzle-multitenant migrate --all --json
+  $ drizzle-multitenant migrate --all --mark-applied
 `).action(async (options) => {
   const startTime = Date.now();
   const ctx = getOutputContext();
@@ -1036,7 +1455,11 @@ Examples:
     if (options.dryRun) {
       log(info(bold("\nDry run mode - no changes will be made\n")));
     }
-    log(info(`Migrating ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}...
+    if (options.markApplied) {
+      log(info(bold("\nMark-applied mode - migrations will be recorded without executing SQL\n")));
+    }
+    const actionLabel = options.markApplied ? "Marking" : "Migrating";
+    log(info(`${actionLabel} ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}...
 `));
     const migrator = createMigrator(config, {
       migrationsFolder: folder,
@@ -1046,9 +1469,8 @@ Examples:
     const concurrency = parseInt(options.concurrency || "10", 10);
     const progressBar = createProgressBar({ total: tenantIds.length });
     progressBar.start();
-    const results = await migrator.migrateAll({
+    const migrateOptions = {
       concurrency,
-      dryRun: !!options.dryRun,
       onProgress: (tenantId, status, migrationName) => {
         if (status === "completed") {
           progressBar.increment({ tenant: tenantId, status: "success" });
@@ -1057,14 +1479,16 @@ Examples:
           progressBar.increment({ tenant: tenantId, status: "error" });
           debug(`Failed: ${tenantId}`);
         } else if (status === "migrating" && migrationName) {
-          debug(`${tenantId}: Applying ${migrationName}`);
+          const actionVerb = options.markApplied ? "Marking" : "Applying";
+          debug(`${tenantId}: ${actionVerb} ${migrationName}`);
         }
       },
       onError: (tenantId, err) => {
         debug(`Error on ${tenantId}: ${err.message}`);
         return "continue";
       }
-    });
+    };
+    const results = options.markApplied ? await migrator.markAllAsApplied(migrateOptions) : await migrator.migrateAll({ ...migrateOptions, dryRun: !!options.dryRun });
     progressBar.stop();
     const totalDuration = Date.now() - startTime;
     if (ctx.jsonMode) {
@@ -1189,6 +1613,261 @@ Examples:
     handleError(err);
   }
 });
+var syncCommand = new Command("sync").description("Detect and fix divergences between migrations on disk and tracking in database").option("-c, --config <path>", "Path to config file").option("-s, --status", "Show sync status without making changes").option("--mark-missing", "Mark missing migrations as applied").option("--clean-orphans", "Remove orphan records from tracking table").option("--concurrency <number>", "Number of concurrent operations", "10").option("--migrations-folder <path>", "Path to migrations folder").addHelpText("after", `
+Examples:
+  $ drizzle-multitenant sync --status
+  $ drizzle-multitenant sync --mark-missing
+  $ drizzle-multitenant sync --clean-orphans
+  $ drizzle-multitenant sync --mark-missing --clean-orphans
+  $ drizzle-multitenant sync --status --json
+`).action(async (options) => {
+  const startTime = Date.now();
+  const ctx = getOutputContext();
+  const spinner = createSpinner("Loading configuration...");
+  try {
+    spinner.start();
+    const { config, migrationsFolder, migrationsTable, tenantDiscovery } = await loadConfig(options.config);
+    if (!tenantDiscovery) {
+      throw CLIErrors.noTenantDiscovery();
+    }
+    const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
+    debug(`Using migrations folder: ${folder}`);
+    const migrator = createMigrator(config, {
+      migrationsFolder: folder,
+      ...migrationsTable && { migrationsTable },
+      tenantDiscovery
+    });
+    const showStatus = options.status || !options.markMissing && !options.cleanOrphans;
+    if (showStatus) {
+      spinner.text = "Fetching sync status...";
+      const syncStatus = await migrator.getSyncStatus();
+      spinner.succeed(`Found ${syncStatus.total} tenant${syncStatus.total > 1 ? "s" : ""}`);
+      if (ctx.jsonMode) {
+        const jsonOutput = {
+          tenants: syncStatus.details.map((s) => ({
+            id: s.tenantId,
+            schema: s.schemaName,
+            format: s.format,
+            inSync: s.inSync,
+            missing: s.missing,
+            orphans: s.orphans,
+            error: s.error
+          })),
+          summary: {
+            total: syncStatus.total,
+            inSync: syncStatus.inSync,
+            outOfSync: syncStatus.outOfSync,
+            error: syncStatus.error
+          }
+        };
+        outputJson(jsonOutput);
+        return;
+      }
+      log("\n" + bold("Sync Status:"));
+      log(createSyncStatusTable(syncStatus.details));
+      log(createSyncSummary(syncStatus));
+      return;
+    }
+    const concurrency = parseInt(options.concurrency || "10", 10);
+    if (options.markMissing) {
+      spinner.text = "Marking missing migrations...";
+      spinner.succeed();
+      const tenantIds = await tenantDiscovery();
+      log(info(`
+Marking missing migrations for ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}...
+`));
+      const progressBar = createProgressBar({ total: tenantIds.length });
+      progressBar.start();
+      const results = await migrator.markAllMissing({
+        concurrency,
+        onProgress: (tenantId, status) => {
+          if (status === "completed") {
+            progressBar.increment({ tenant: tenantId, status: "success" });
+          } else if (status === "failed") {
+            progressBar.increment({ tenant: tenantId, status: "error" });
+          }
+        },
+        onError: (tenantId, err) => {
+          debug(`Error on ${tenantId}: ${err.message}`);
+          return "continue";
+        }
+      });
+      progressBar.stop();
+      const totalDuration = Date.now() - startTime;
+      if (ctx.jsonMode) {
+        outputJson({
+          action: "mark-missing",
+          results: results.details.map((r) => ({
+            tenantId: r.tenantId,
+            schema: r.schemaName,
+            success: r.success,
+            markedMigrations: r.markedMigrations,
+            durationMs: r.durationMs,
+            error: r.error
+          })),
+          summary: {
+            total: results.total,
+            succeeded: results.succeeded,
+            failed: results.failed,
+            durationMs: totalDuration
+          }
+        });
+        process.exit(results.failed > 0 ? 1 : 0);
+      }
+      log("\n" + bold("Results:"));
+      log(createSyncResultsTable(results.details, "mark-missing"));
+      log("\n" + bold("Summary:"));
+      log(`  Total:      ${results.total}`);
+      log(`  Succeeded:  ${success(results.succeeded.toString())}`);
+      if (results.failed > 0) {
+        log(`  Failed:     ${error(results.failed.toString())}`);
+      }
+      log(`  Duration:   ${dim(formatDuration2(totalDuration))}`);
+    }
+    if (options.cleanOrphans) {
+      if (options.markMissing) {
+        log("\n");
+      }
+      spinner.text = "Cleaning orphan records...";
+      spinner.succeed();
+      const tenantIds = await tenantDiscovery();
+      log(info(`
+Cleaning orphan records for ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}...
+`));
+      const progressBar = createProgressBar({ total: tenantIds.length });
+      progressBar.start();
+      const results = await migrator.cleanAllOrphans({
+        concurrency,
+        onProgress: (tenantId, status) => {
+          if (status === "completed") {
+            progressBar.increment({ tenant: tenantId, status: "success" });
+          } else if (status === "failed") {
+            progressBar.increment({ tenant: tenantId, status: "error" });
+          }
+        },
+        onError: (tenantId, err) => {
+          debug(`Error on ${tenantId}: ${err.message}`);
+          return "continue";
+        }
+      });
+      progressBar.stop();
+      const totalDuration = Date.now() - startTime;
+      if (ctx.jsonMode) {
+        outputJson({
+          action: "clean-orphans",
+          results: results.details.map((r) => ({
+            tenantId: r.tenantId,
+            schema: r.schemaName,
+            success: r.success,
+            removedOrphans: r.removedOrphans,
+            durationMs: r.durationMs,
+            error: r.error
+          })),
+          summary: {
+            total: results.total,
+            succeeded: results.succeeded,
+            failed: results.failed,
+            durationMs: totalDuration
+          }
+        });
+        process.exit(results.failed > 0 ? 1 : 0);
+      }
+      log("\n" + bold("Results:"));
+      log(createSyncResultsTable(results.details, "clean-orphans"));
+      log("\n" + bold("Summary:"));
+      log(`  Total:      ${results.total}`);
+      log(`  Succeeded:  ${success(results.succeeded.toString())}`);
+      if (results.failed > 0) {
+        log(`  Failed:     ${error(results.failed.toString())}`);
+      }
+      log(`  Duration:   ${dim(formatDuration2(totalDuration))}`);
+    }
+  } catch (err) {
+    spinner.fail(err.message);
+    handleError(err);
+  }
+});
+function formatDuration2(ms) {
+  if (ms < 1e3) {
+    return `${ms}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  const mins = Math.floor(ms / 6e4);
+  const secs = Math.round(ms % 6e4 / 1e3);
+  return `${mins}m ${secs}s`;
+}
+function createSyncStatusTable(details) {
+  if (details.length === 0) {
+    return "  No tenants found.\n";
+  }
+  const lines = [];
+  for (const detail of details) {
+    if (detail.error) {
+      lines.push(`  ${error(detail.tenantId)}: ${dim(detail.error)}`);
+    } else if (detail.inSync) {
+      lines.push(`  ${success(detail.tenantId)}: ${dim("In sync")}`);
+    } else {
+      const issues = [];
+      if (detail.missing.length > 0) {
+        issues.push(`${detail.missing.length} missing`);
+      }
+      if (detail.orphans.length > 0) {
+        issues.push(`${detail.orphans.length} orphan${detail.orphans.length > 1 ? "s" : ""}`);
+      }
+      lines.push(`  ${warning(detail.tenantId)}: ${issues.join(", ")}`);
+      if (detail.missing.length > 0) {
+        lines.push(`    ${dim("Missing:")} ${detail.missing.slice(0, 3).join(", ")}${detail.missing.length > 3 ? `, +${detail.missing.length - 3} more` : ""}`);
+      }
+      if (detail.orphans.length > 0) {
+        lines.push(`    ${dim("Orphans:")} ${detail.orphans.slice(0, 3).join(", ")}${detail.orphans.length > 3 ? `, +${detail.orphans.length - 3} more` : ""}`);
+      }
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function createSyncSummary(status) {
+  const lines = [];
+  lines.push("\n" + bold("Summary:"));
+  lines.push(`  Total:       ${status.total}`);
+  lines.push(`  In Sync:     ${success(status.inSync.toString())}`);
+  if (status.outOfSync > 0) {
+    lines.push(`  Out of Sync: ${warning(status.outOfSync.toString())}`);
+  }
+  if (status.error > 0) {
+    lines.push(`  Errors:      ${error(status.error.toString())}`);
+  }
+  if (status.outOfSync > 0) {
+    lines.push("\n" + dim("Run with --mark-missing to mark missing migrations as applied."));
+    lines.push(dim("Run with --clean-orphans to remove orphan records."));
+  }
+  return lines.join("\n");
+}
+function createSyncResultsTable(details, action) {
+  if (details.length === 0) {
+    return "  No tenants processed.\n";
+  }
+  const lines = [];
+  for (const detail of details) {
+    if (detail.error) {
+      lines.push(`  ${error(detail.tenantId)}: ${dim(detail.error)}`);
+    } else if (action === "mark-missing") {
+      if (detail.markedMigrations.length > 0) {
+        lines.push(`  ${success(detail.tenantId)}: Marked ${detail.markedMigrations.length} migration${detail.markedMigrations.length > 1 ? "s" : ""}`);
+      } else {
+        lines.push(`  ${dim(detail.tenantId)}: Nothing to mark`);
+      }
+    } else {
+      if (detail.removedOrphans.length > 0) {
+        lines.push(`  ${success(detail.tenantId)}: Removed ${detail.removedOrphans.length} orphan${detail.removedOrphans.length > 1 ? "s" : ""}`);
+      } else {
+        lines.push(`  ${dim(detail.tenantId)}: No orphans found`);
+      }
+    }
+  }
+  return lines.join("\n") + "\n";
+}
 var generateCommand = new Command("generate").description("Generate a new migration file").requiredOption("-n, --name <name>", "Migration name").option("-c, --config <path>", "Path to config file").option("--type <type>", "Migration type: tenant or shared", "tenant").option("--migrations-folder <path>", "Path to migrations folder").action(async (options) => {
   const spinner = createSpinner("Loading configuration...");
   try {
@@ -2066,6 +2745,7 @@ Documentation:
 `);
 program.addCommand(migrateCommand);
 program.addCommand(statusCommand);
+program.addCommand(syncCommand);
 program.addCommand(generateCommand);
 program.addCommand(tenantCreateCommand);
 program.addCommand(tenantDropCommand);