drizzle-multitenant 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,866 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { mkdir, readdir, writeFile, readFile } from 'fs/promises';
+import { resolve, join, extname, basename } from 'path';
+import { Pool } from 'pg';
+import ora from 'ora';
+import chalk2 from 'chalk';
+import Table from 'cli-table3';
+import { pathToFileURL } from 'url';
+import { existsSync } from 'fs';
+import { createInterface } from 'readline';
+
+var DEFAULT_MIGRATIONS_TABLE = "__drizzle_migrations";
+var Migrator = class {
+  constructor(tenantConfig, migratorConfig) {
+    this.tenantConfig = tenantConfig;
+    this.migratorConfig = migratorConfig;
+    this.migrationsTable = migratorConfig.migrationsTable ?? DEFAULT_MIGRATIONS_TABLE;
+  }
+  migrationsTable;
+  /**
+   * Migrate all tenants in parallel
+   */
+  async migrateAll(options = {}) {
+    const {
+      concurrency = 10,
+      onProgress,
+      onError,
+      dryRun = false
+    } = options;
+    const tenantIds = await this.migratorConfig.tenantDiscovery();
+    const migrations = await this.loadMigrations();
+    const results = [];
+    let aborted = false;
+    for (let i = 0; i < tenantIds.length && !aborted; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          if (aborted) {
+            return this.createSkippedResult(tenantId);
+          }
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.migrateTenant(tenantId, migrations, { dryRun, onProgress });
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error6) {
+            onProgress?.(tenantId, "failed");
+            const action = onError?.(tenantId, error6);
+            if (action === "abort") {
+              aborted = true;
+            }
+            return this.createErrorResult(tenantId, error6);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    if (aborted) {
+      const remaining = tenantIds.slice(results.length);
+      for (const tenantId of remaining) {
+        results.push(this.createSkippedResult(tenantId));
+      }
+    }
+    return this.aggregateResults(results);
+  }
+  /**
+   * Migrate a single tenant
+   */
+  async migrateTenant(tenantId, migrations, options = {}) {
+    const startTime = Date.now();
+    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+    const appliedMigrations = [];
+    const pool = await this.createPool(schemaName);
+    try {
+      await this.migratorConfig.hooks?.beforeTenant?.(tenantId);
+      await this.ensureMigrationsTable(pool, schemaName);
+      const allMigrations = migrations ?? await this.loadMigrations();
+      const applied = await this.getAppliedMigrations(pool, schemaName);
+      const appliedSet = new Set(applied.map((m) => m.name));
+      const pending = allMigrations.filter((m) => !appliedSet.has(m.name));
+      if (options.dryRun) {
+        return {
+          tenantId,
+          schemaName,
+          success: true,
+          appliedMigrations: pending.map((m) => m.name),
+          durationMs: Date.now() - startTime
+        };
+      }
+      for (const migration of pending) {
+        const migrationStart = Date.now();
+        options.onProgress?.(tenantId, "migrating", migration.name);
+        await this.migratorConfig.hooks?.beforeMigration?.(tenantId, migration.name);
+        await this.applyMigration(pool, schemaName, migration);
+        await this.migratorConfig.hooks?.afterMigration?.(
+          tenantId,
+          migration.name,
+          Date.now() - migrationStart
+        );
+        appliedMigrations.push(migration.name);
+      }
+      const result = {
+        tenantId,
+        schemaName,
+        success: true,
+        appliedMigrations,
+        durationMs: Date.now() - startTime
+      };
+      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
+      return result;
+    } catch (error6) {
+      const result = {
+        tenantId,
+        schemaName,
+        success: false,
+        appliedMigrations,
+        error: error6.message,
+        durationMs: Date.now() - startTime
+      };
+      await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
+      return result;
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Migrate specific tenants
+   */
+  async migrateTenants(tenantIds, options = {}) {
+    const migrations = await this.loadMigrations();
+    const results = [];
+    const { concurrency = 10, onProgress, onError } = options;
+    for (let i = 0; i < tenantIds.length; i += concurrency) {
+      const batch = tenantIds.slice(i, i + concurrency);
+      const batchResults = await Promise.all(
+        batch.map(async (tenantId) => {
+          try {
+            onProgress?.(tenantId, "starting");
+            const result = await this.migrateTenant(tenantId, migrations, { dryRun: options.dryRun ?? false, onProgress });
+            onProgress?.(tenantId, result.success ? "completed" : "failed");
+            return result;
+          } catch (error6) {
+            onProgress?.(tenantId, "failed");
+            onError?.(tenantId, error6);
+            return this.createErrorResult(tenantId, error6);
+          }
+        })
+      );
+      results.push(...batchResults);
+    }
+    return this.aggregateResults(results);
+  }
+  /**
+   * Get migration status for all tenants
+   */
+  async getStatus() {
+    const tenantIds = await this.migratorConfig.tenantDiscovery();
+    const migrations = await this.loadMigrations();
+    const statuses = [];
+    for (const tenantId of tenantIds) {
+      statuses.push(await this.getTenantStatus(tenantId, migrations));
+    }
+    return statuses;
+  }
+  /**
+   * Get migration status for a specific tenant
+   */
+  async getTenantStatus(tenantId, migrations) {
+    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+    const pool = await this.createPool(schemaName);
+    try {
+      const allMigrations = migrations ?? await this.loadMigrations();
+      const tableExists = await this.migrationsTableExists(pool, schemaName);
+      if (!tableExists) {
+        return {
+          tenantId,
+          schemaName,
+          appliedCount: 0,
+          pendingCount: allMigrations.length,
+          pendingMigrations: allMigrations.map((m) => m.name),
+          status: allMigrations.length > 0 ? "behind" : "ok"
+        };
+      }
+      const applied = await this.getAppliedMigrations(pool, schemaName);
+      const appliedSet = new Set(applied.map((m) => m.name));
+      const pending = allMigrations.filter((m) => !appliedSet.has(m.name));
+      return {
+        tenantId,
+        schemaName,
+        appliedCount: applied.length,
+        pendingCount: pending.length,
+        pendingMigrations: pending.map((m) => m.name),
+        status: pending.length > 0 ? "behind" : "ok"
+      };
+    } catch (error6) {
+      return {
+        tenantId,
+        schemaName,
+        appliedCount: 0,
+        pendingCount: 0,
+        pendingMigrations: [],
+        status: "error",
+        error: error6.message
+      };
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Create a new tenant schema and optionally apply migrations
+   */
+  async createTenant(tenantId, options = {}) {
+    const { migrate = true } = options;
+    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+    const pool = new Pool({
+      connectionString: this.tenantConfig.connection.url,
+      ...this.tenantConfig.connection.poolConfig
+    });
+    try {
+      await pool.query(`CREATE SCHEMA IF NOT EXISTS "${schemaName}"`);
+      if (migrate) {
+        await this.migrateTenant(tenantId);
+      }
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Drop a tenant schema
+   */
+  async dropTenant(tenantId, options = {}) {
+    const { cascade = true } = options;
+    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+    const pool = new Pool({
+      connectionString: this.tenantConfig.connection.url,
+      ...this.tenantConfig.connection.poolConfig
+    });
+    try {
+      const cascadeSql = cascade ? "CASCADE" : "RESTRICT";
+      await pool.query(`DROP SCHEMA IF EXISTS "${schemaName}" ${cascadeSql}`);
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Check if a tenant schema exists
+   */
+  async tenantExists(tenantId) {
+    const schemaName = this.tenantConfig.isolation.schemaNameTemplate(tenantId);
+    const pool = new Pool({
+      connectionString: this.tenantConfig.connection.url,
+      ...this.tenantConfig.connection.poolConfig
+    });
+    try {
+      const result = await pool.query(
+        `SELECT 1 FROM information_schema.schemata WHERE schema_name = $1`,
+        [schemaName]
+      );
+      return result.rowCount !== null && result.rowCount > 0;
+    } finally {
+      await pool.end();
+    }
+  }
+  /**
+   * Load migration files from the migrations folder
+   */
+  async loadMigrations() {
+    const files = await readdir(this.migratorConfig.migrationsFolder);
+    const migrations = [];
+    for (const file of files) {
+      if (!file.endsWith(".sql")) continue;
+      const filePath = join(this.migratorConfig.migrationsFolder, file);
+      const content = await readFile(filePath, "utf-8");
+      const match = file.match(/^(\d+)_/);
+      const timestamp = match?.[1] ? parseInt(match[1], 10) : 0;
+      migrations.push({
+        name: basename(file, ".sql"),
+        path: filePath,
+        sql: content,
+        timestamp
+      });
+    }
+    return migrations.sort((a, b) => a.timestamp - b.timestamp);
+  }
+  /**
+   * Create a pool for a specific schema
+   */
+  async createPool(schemaName) {
+    return new Pool({
+      connectionString: this.tenantConfig.connection.url,
+      ...this.tenantConfig.connection.poolConfig,
+      options: `-c search_path="${schemaName}",public`
+    });
+  }
+  /**
+   * Ensure migrations table exists
+   */
+  async ensureMigrationsTable(pool, schemaName) {
+    await pool.query(`
+      CREATE TABLE IF NOT EXISTS "${schemaName}"."${this.migrationsTable}" (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255) NOT NULL UNIQUE,
+        applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+  }
+  /**
+   * Check if migrations table exists
+   */
+  async migrationsTableExists(pool, schemaName) {
+    const result = await pool.query(
+      `SELECT 1 FROM information_schema.tables
+       WHERE table_schema = $1 AND table_name = $2`,
+      [schemaName, this.migrationsTable]
+    );
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+  /**
+   * Get applied migrations for a schema
+   */
+  async getAppliedMigrations(pool, schemaName) {
+    const result = await pool.query(
+      `SELECT id, name, applied_at FROM "${schemaName}"."${this.migrationsTable}" ORDER BY id`
+    );
+    return result.rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      appliedAt: row.applied_at
+    }));
+  }
+  /**
+   * Apply a migration to a schema
+   */
+  async applyMigration(pool, schemaName, migration) {
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(migration.sql);
+      await client.query(
+        `INSERT INTO "${schemaName}"."${this.migrationsTable}" (name) VALUES ($1)`,
+        [migration.name]
+      );
+      await client.query("COMMIT");
+    } catch (error6) {
+      await client.query("ROLLBACK");
+      throw error6;
+    } finally {
+      client.release();
+    }
+  }
+  /**
+   * Create a skipped result
+   */
+  createSkippedResult(tenantId) {
+    return {
+      tenantId,
+      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
+      success: false,
+      appliedMigrations: [],
+      error: "Skipped due to abort",
+      durationMs: 0
+    };
+  }
+  /**
+   * Create an error result
+   */
+  createErrorResult(tenantId, error6) {
+    return {
+      tenantId,
+      schemaName: this.tenantConfig.isolation.schemaNameTemplate(tenantId),
+      success: false,
+      appliedMigrations: [],
+      error: error6.message,
+      durationMs: 0
+    };
+  }
+  /**
+   * Aggregate migration results
+   */
+  aggregateResults(results) {
+    return {
+      total: results.length,
+      succeeded: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success && r.error !== "Skipped due to abort").length,
+      skipped: results.filter((r) => r.error === "Skipped due to abort").length,
+      details: results
+    };
+  }
+};
+function createMigrator(tenantConfig, migratorConfig) {
+  return new Migrator(tenantConfig, migratorConfig);
+}
+function createSpinner(text) {
+  return ora({
+    text,
+    color: "cyan"
+  });
+}
+function success(message) {
+  return chalk2.green("\u2713 ") + message;
+}
+function error(message) {
+  return chalk2.red("\u2717 ") + message;
+}
+function warning(message) {
+  return chalk2.yellow("\u26A0 ") + message;
+}
+function info(message) {
+  return chalk2.blue("\u2139 ") + message;
+}
+function dim(message) {
+  return chalk2.dim(message);
+}
+function bold(message) {
+  return chalk2.bold(message);
+}
+function red(message) {
+  return chalk2.red(message);
+}
+function createStatusTable(statuses) {
+  const table = new Table({
+    head: [
+      chalk2.cyan("Tenant"),
+      chalk2.cyan("Schema"),
+      chalk2.cyan("Applied"),
+      chalk2.cyan("Pending"),
+      chalk2.cyan("Status")
+    ],
+    style: {
+      head: [],
+      border: []
+    }
+  });
+  for (const status of statuses) {
+    const statusIcon = getStatusIcon(status.status);
+    const statusText = getStatusText(status.status);
+    table.push([
+      status.tenantId,
+      chalk2.dim(status.schemaName),
+      chalk2.green(status.appliedCount.toString()),
+      status.pendingCount > 0 ? chalk2.yellow(status.pendingCount.toString()) : chalk2.dim("0"),
+      `${statusIcon} ${statusText}`
+    ]);
+  }
+  return table.toString();
+}
+function createResultsTable(results) {
+  const table = new Table({
+    head: [
+      chalk2.cyan("Tenant"),
+      chalk2.cyan("Migrations"),
+      chalk2.cyan("Duration"),
+      chalk2.cyan("Status")
+    ],
+    style: {
+      head: [],
+      border: []
+    }
+  });
+  for (const result of results) {
+    const statusIcon = result.success ? chalk2.green("\u2713") : chalk2.red("\u2717");
+    const statusText = result.success ? chalk2.green("OK") : chalk2.red(result.error ?? "Failed");
+    table.push([
+      result.tenantId,
+      result.appliedMigrations.length.toString(),
+      `${result.durationMs}ms`,
+      `${statusIcon} ${statusText}`
+    ]);
+  }
+  return table.toString();
+}
+function createPendingSummary(statuses) {
+  const pendingMap = /* @__PURE__ */ new Map();
+  for (const status of statuses) {
+    for (const migration of status.pendingMigrations) {
+      pendingMap.set(migration, (pendingMap.get(migration) || 0) + 1);
+    }
+  }
+  if (pendingMap.size === 0) {
+    return chalk2.green("\nAll tenants are up to date.");
+  }
+  const lines = [chalk2.yellow("\nPending migrations:")];
+  for (const [migration, count] of pendingMap.entries()) {
+    lines.push(
+      `  ${chalk2.dim("-")} ${migration} ${chalk2.dim(`(${count} tenant${count > 1 ? "s" : ""})`)}`
+    );
+  }
+  lines.push(
+    chalk2.dim("\nRun 'drizzle-multitenant migrate --all' to apply pending migrations.")
+  );
+  return lines.join("\n");
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "ok":
+      return chalk2.green("\u2713");
+    case "behind":
+      return chalk2.yellow("\u26A0");
+    case "error":
+      return chalk2.red("\u2717");
+  }
+}
+function getStatusText(status) {
+  switch (status) {
+    case "ok":
+      return chalk2.green("OK");
+    case "behind":
+      return chalk2.yellow("Behind");
+    case "error":
+      return chalk2.red("Error");
+  }
+}
+var CONFIG_FILE_NAMES = [
+  "tenant.config.ts",
+  "tenant.config.js",
+  "tenant.config.mjs",
+  "drizzle-multitenant.config.ts",
+  "drizzle-multitenant.config.js",
+  "drizzle-multitenant.config.mjs"
+];
+async function loadConfig(configPath) {
+  const cwd = process.cwd();
+  let configFile;
+  if (configPath) {
+    configFile = resolve(cwd, configPath);
+    if (!existsSync(configFile)) {
+      throw new Error(`Config file not found: ${configFile}`);
+    }
+  } else {
+    for (const name of CONFIG_FILE_NAMES) {
+      const path = resolve(cwd, name);
+      if (existsSync(path)) {
+        configFile = path;
+        break;
+      }
+    }
+  }
+  if (!configFile) {
+    throw new Error(
+      "Config file not found. Create a tenant.config.ts or use --config flag."
+    );
+  }
+  const ext = extname(configFile);
+  if (ext === ".ts") {
+    await registerTypeScript();
+  }
+  const configUrl = pathToFileURL(configFile).href;
+  const module = await import(configUrl);
+  const exported = module.default ?? module;
+  if (!exported.connection || !exported.isolation || !exported.schemas) {
+    throw new Error(
+      "Invalid config file. Expected an object with connection, isolation, and schemas properties."
+    );
+  }
+  return {
+    config: exported,
+    migrationsFolder: exported.migrations?.tenantFolder,
+    tenantDiscovery: exported.migrations?.tenantDiscovery
+  };
+}
+async function registerTypeScript() {
+  try {
+    await import('tsx/esm');
+  } catch {
+    try {
+      await import('ts-node/esm');
+    } catch {
+      throw new Error(
+        "TypeScript config requires tsx or ts-node. Install with: npm install -D tsx"
+      );
+    }
+  }
+}
+function resolveMigrationsFolder(folder) {
+  const cwd = process.cwd();
+  const defaultFolder = "./drizzle/tenant";
+  const resolved = resolve(cwd, folder ?? defaultFolder);
+  if (!existsSync(resolved)) {
+    throw new Error(`Migrations folder not found: ${resolved}`);
+  }
+  return resolved;
+}
+
+// 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").action(async (options) => {
+  const spinner = createSpinner("Loading configuration...");
+  try {
+    spinner.start();
+    const { config, migrationsFolder, tenantDiscovery } = await loadConfig(options.config);
+    const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
+    let discoveryFn;
+    if (options.tenant) {
+      discoveryFn = async () => [options.tenant];
+    } else if (options.tenants) {
+      const tenantIds2 = options.tenants.split(",").map((id) => id.trim());
+      discoveryFn = async () => tenantIds2;
+    } else if (options.all) {
+      if (!tenantDiscovery) {
+        throw new Error(
+          "No tenant discovery function configured. Add migrations.tenantDiscovery to your config."
+        );
+      }
+      discoveryFn = tenantDiscovery;
+    } else {
+      spinner.stop();
+      console.log(error("Please specify --all, --tenant, or --tenants"));
+      console.log(dim("\nExamples:"));
+      console.log(dim("  npx drizzle-multitenant migrate --all"));
+      console.log(dim("  npx drizzle-multitenant migrate --tenant=tenant-uuid"));
+      console.log(dim("  npx drizzle-multitenant migrate --tenants=tenant-1,tenant-2"));
+      process.exit(1);
+    }
+    spinner.text = "Discovering tenants...";
+    const migrator = createMigrator(config, {
+      migrationsFolder: folder,
+      tenantDiscovery: discoveryFn
+    });
+    const tenantIds = await discoveryFn();
+    if (tenantIds.length === 0) {
+      spinner.stop();
+      console.log(warning("No tenants found."));
+      return;
+    }
+    spinner.text = `Found ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}`;
+    spinner.succeed();
+    if (options.dryRun) {
+      console.log(info(bold("\nDry run mode - no changes will be made\n")));
+    }
+    console.log(info(`Migrating ${tenantIds.length} tenant${tenantIds.length > 1 ? "s" : ""}...
+`));
+    const concurrency = parseInt(options.concurrency, 10);
+    let completed = 0;
+    const results = await migrator.migrateAll({
+      concurrency,
+      dryRun: options.dryRun,
+      onProgress: (tenantId, status, migrationName) => {
+        if (status === "completed") {
+          completed++;
+          const progress = `[${completed}/${tenantIds.length}]`;
+          console.log(`${dim(progress)} ${success(tenantId)}`);
+        } else if (status === "failed") {
+          completed++;
+          const progress = `[${completed}/${tenantIds.length}]`;
+          console.log(`${dim(progress)} ${error(tenantId)}`);
+        } else if (status === "migrating" && migrationName) {
+        }
+      },
+      onError: (tenantId, err) => {
+        console.log(error(`${tenantId}: ${err.message}`));
+        return "continue";
+      }
+    });
+    console.log("\n" + bold("Results:"));
+    console.log(createResultsTable(results.details));
+    console.log("\n" + bold("Summary:"));
+    console.log(`  Total:     ${results.total}`);
+    console.log(`  Succeeded: ${success(results.succeeded.toString())}`);
+    if (results.failed > 0) {
+      console.log(`  Failed:    ${error(results.failed.toString())}`);
+    }
+    if (results.skipped > 0) {
+      console.log(`  Skipped:   ${warning(results.skipped.toString())}`);
+    }
+    if (results.failed > 0) {
+      process.exit(1);
+    }
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+});
+var statusCommand = new Command("status").description("Show migration status for all tenants").option("-c, --config <path>", "Path to config file").option("--migrations-folder <path>", "Path to migrations folder").action(async (options) => {
+  const spinner = createSpinner("Loading configuration...");
+  try {
+    spinner.start();
+    const { config, migrationsFolder, tenantDiscovery } = await loadConfig(options.config);
+    if (!tenantDiscovery) {
+      throw new Error(
+        "No tenant discovery function configured. Add migrations.tenantDiscovery to your config."
+      );
+    }
+    const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
+    spinner.text = "Discovering tenants...";
+    const migrator = createMigrator(config, {
+      migrationsFolder: folder,
+      tenantDiscovery
+    });
+    spinner.text = "Fetching migration status...";
+    const statuses = await migrator.getStatus();
+    spinner.succeed(`Found ${statuses.length} tenant${statuses.length > 1 ? "s" : ""}`);
+    console.log("\n" + bold("Migration Status:"));
+    console.log(createStatusTable(statuses));
+    console.log(createPendingSummary(statuses));
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+});
+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 {
+    spinner.start();
+    const { migrationsFolder: configFolder } = await loadConfig(options.config);
+    const cwd = process.cwd();
+    let folder;
+    if (options.migrationsFolder) {
+      folder = resolve(cwd, options.migrationsFolder);
+    } else if (configFolder) {
+      folder = resolve(cwd, configFolder);
+    } else {
+      folder = resolve(cwd, options.type === "shared" ? "./drizzle/shared" : "./drizzle/tenant");
+    }
+    if (!existsSync(folder)) {
+      await mkdir(folder, { recursive: true });
+      spinner.text = `Created migrations folder: ${folder}`;
+    }
+    spinner.text = "Generating migration...";
+    const files = existsSync(folder) ? await readdir(folder) : [];
+    const sqlFiles = files.filter((f) => f.endsWith(".sql"));
+    let maxSequence = 0;
+    for (const file of sqlFiles) {
+      const match = file.match(/^(\d+)_/);
+      if (match) {
+        const seq = parseInt(match[1], 10);
+        if (seq > maxSequence) {
+          maxSequence = seq;
+        }
+      }
+    }
+    const nextSequence = (maxSequence + 1).toString().padStart(4, "0");
+    const safeName = options.name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+    const fileName = `${nextSequence}_${safeName}.sql`;
+    const filePath = join(folder, fileName);
+    const template = `-- Migration: ${options.name}
+-- Created at: ${(/* @__PURE__ */ new Date()).toISOString()}
+-- Type: ${options.type}
+
+-- Write your SQL migration here
+
+`;
+    await writeFile(filePath, template, "utf-8");
+    spinner.succeed("Migration generated");
+    console.log("\n" + success(`Created: ${dim(filePath)}`));
+    console.log(dim("\nEdit this file to add your migration SQL."));
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+});
+var tenantCreateCommand = new Command("tenant:create").description("Create a new tenant schema and apply all migrations").requiredOption("--id <tenantId>", "Tenant ID").option("-c, --config <path>", "Path to config file").option("--migrations-folder <path>", "Path to migrations folder").option("--no-migrate", "Skip applying migrations after creating schema").action(async (options) => {
+  const spinner = createSpinner("Loading configuration...");
+  try {
+    spinner.start();
+    const { config, migrationsFolder } = await loadConfig(options.config);
+    const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
+    const migrator = createMigrator(config, {
+      migrationsFolder: folder,
+      tenantDiscovery: async () => []
+    });
+    const schemaName = config.isolation.schemaNameTemplate(options.id);
+    spinner.text = `Checking if tenant ${options.id} exists...`;
+    const exists = await migrator.tenantExists(options.id);
+    if (exists) {
+      spinner.warn(`Tenant ${options.id} already exists (${schemaName})`);
+      if (options.migrate) {
+        spinner.start();
+        spinner.text = "Applying pending migrations...";
+        const result = await migrator.migrateTenant(options.id);
+        if (result.appliedMigrations.length > 0) {
+          spinner.succeed(`Applied ${result.appliedMigrations.length} migration(s)`);
+          for (const migration of result.appliedMigrations) {
+            console.log(`  ${dim("-")} ${migration}`);
+          }
+        } else {
+          spinner.succeed("No pending migrations");
+        }
+      }
+      return;
+    }
+    spinner.text = `Creating tenant schema ${schemaName}...`;
+    await migrator.createTenant(options.id, {
+      migrate: options.migrate
+    });
+    spinner.succeed(`Tenant ${options.id} created`);
+    console.log("\n" + success("Schema created: ") + dim(schemaName));
+    if (options.migrate) {
+      console.log(success("All migrations applied"));
+    } else {
+      console.log(warning("Migrations skipped. Run migrate to apply."));
+    }
+    console.log(dim("\nYou can now use this tenant:"));
+    console.log(dim(`  const db = tenants.getDb('${options.id}');`));
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+});
+var tenantDropCommand = new Command("tenant:drop").description("Drop a tenant schema (DESTRUCTIVE)").requiredOption("--id <tenantId>", "Tenant ID").option("-c, --config <path>", "Path to config file").option("--migrations-folder <path>", "Path to migrations folder").option("-f, --force", "Skip confirmation prompt").option("--no-cascade", "Use RESTRICT instead of CASCADE").action(async (options) => {
+  const spinner = createSpinner("Loading configuration...");
+  try {
+    spinner.start();
+    const { config, migrationsFolder } = await loadConfig(options.config);
+    const folder = options.migrationsFolder ? resolveMigrationsFolder(options.migrationsFolder) : resolveMigrationsFolder(migrationsFolder);
+    const migrator = createMigrator(config, {
+      migrationsFolder: folder,
+      tenantDiscovery: async () => []
+    });
+    const schemaName = config.isolation.schemaNameTemplate(options.id);
+    spinner.text = `Checking if tenant ${options.id} exists...`;
+    const exists = await migrator.tenantExists(options.id);
+    if (!exists) {
+      spinner.warn(`Tenant ${options.id} does not exist`);
+      return;
+    }
+    spinner.stop();
+    if (!options.force) {
+      console.log(red(bold("\n\u26A0\uFE0F  WARNING: This action is DESTRUCTIVE and IRREVERSIBLE!")));
+      console.log(dim(`
+You are about to drop schema: ${schemaName}`));
+      console.log(dim("All tables and data in this schema will be permanently deleted.\n"));
+      const confirmed = await askConfirmation(
+        `Type "${options.id}" to confirm deletion: `,
+        options.id
+      );
+      if (!confirmed) {
+        console.log("\n" + warning("Operation cancelled."));
+        return;
+      }
+    }
+    spinner.start();
+    spinner.text = `Dropping tenant schema ${schemaName}...`;
+    await migrator.dropTenant(options.id, {
+      cascade: options.cascade
+    });
+    spinner.succeed(`Tenant ${options.id} dropped`);
+    console.log("\n" + success("Schema deleted: ") + dim(schemaName));
+  } catch (err) {
+    spinner.fail(err.message);
+    process.exit(1);
+  }
+});
+async function askConfirmation(question, expected) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve3) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve3(answer.trim() === expected);
+    });
+  });
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("drizzle-multitenant").description("Multi-tenancy toolkit for Drizzle ORM").version("0.3.0");
+program.addCommand(migrateCommand);
+program.addCommand(statusCommand);
+program.addCommand(generateCommand);
+program.addCommand(tenantCreateCommand);
+program.addCommand(tenantDropCommand);
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map