drizzle-multitenant 1.0.4 → 1.0.5

package/dist/index.js

@@ -4,6 +4,7 @@ import { LRUCache } from 'lru-cache';
 import { AsyncLocalStorage } from 'async_hooks';
 import { readdir, readFile } from 'fs/promises';
 import { join, basename } from 'path';
+import { createHash } from 'crypto';
 import { sql, getTableName } from 'drizzle-orm';
 
 // src/config.ts
@@ -336,6 +337,100 @@ function createTenantContext(manager) {
     isInTenantContext
   };
 }
+
+// src/migrator/table-format.ts
+async function detectTableFormat(pool, schemaName, tableName) {
+  const tableExists = await pool.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
+     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"
+        }
+      };
+  }
+}
+
+// src/migrator/migrator.ts
 var DEFAULT_MIGRATIONS_TABLE = "__drizzle_migrations";
 var Migrator = class {
   constructor(tenantConfig, migratorConfig) {
@@ -400,25 +495,29 @@ var Migrator = class {
     const pool = await this.createPool(schemaName);
     try {
       await this.migratorConfig.hooks?.beforeTenant?.(tenantId);
-      await this.ensureMigrationsTable(pool, schemaName);
+      const format = await this.getOrDetectFormat(pool, schemaName);
+      await this.ensureMigrationsTable(pool, schemaName, format);
       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));
+      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
+          durationMs: Date.now() - startTime,
+          format: format.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.applyMigration(pool, schemaName, migration);
+        await this.applyMigration(pool, schemaName, migration, format);
         await this.migratorConfig.hooks?.afterMigration?.(
           tenantId,
           migration.name,
@@ -431,7 +530,8 @@ var Migrator = class {
         schemaName,
         success: true,
         appliedMigrations,
-        durationMs: Date.now() - startTime
+        durationMs: Date.now() - startTime,
+        format: format.format
       };
       await this.migratorConfig.hooks?.afterTenant?.(tenantId, result);
       return result;
@@ -505,19 +605,25 @@ var Migrator = class {
           appliedCount: 0,
           pendingCount: allMigrations.length,
           pendingMigrations: allMigrations.map((m) => m.name),
-          status: allMigrations.length > 0 ? "behind" : "ok"
+          status: allMigrations.length > 0 ? "behind" : "ok",
+          format: null
+          // New tenant, no table yet
         };
       }
-      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));
+      const format = await this.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"
+        status: pending.length > 0 ? "behind" : "ok",
+        format: format.format
       };
     } catch (error) {
       return {
@@ -527,7 +633,8 @@ var Migrator = class {
         pendingCount: 0,
         pendingMigrations: [],
         status: "error",
-        error: error.message
+        error: error.message,
+        format: null
       };
     } finally {
       await pool.end();
@@ -600,11 +707,13 @@ var Migrator = class {
       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
+        timestamp,
+        hash
       });
     }
     return migrations.sort((a, b) => a.timestamp - b.timestamp);
@@ -620,14 +729,17 @@ var Migrator = class {
     });
   }
   /**
-   * Ensure migrations table exists
+   * Ensure migrations table exists with the correct format
    */
-  async ensureMigrationsTable(pool, schemaName) {
+  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}"."${this.migrationsTable}" (
+      CREATE TABLE IF NOT EXISTS "${schemaName}"."${format.tableName}" (
         id SERIAL PRIMARY KEY,
-        name VARCHAR(255) NOT NULL UNIQUE,
-        applied_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+        ${identifierCol},
+        ${timestampCol}
       )
     `);
   }
@@ -645,27 +757,64 @@ var Migrator = class {
   /**
    * Get applied migrations for a schema
    */
-  async getAppliedMigrations(pool, schemaName) {
+  async getAppliedMigrations(pool, schemaName, format) {
+    const identifierColumn = format.columns.identifier;
+    const timestampColumn = format.columns.timestamp;
     const result = await pool.query(
-      `SELECT id, name, applied_at FROM "${schemaName}"."${this.migrationsTable}" ORDER BY id`
+      `SELECT id, "${identifierColumn}" as identifier, "${timestampColumn}" as applied_at
+       FROM "${schemaName}"."${format.tableName}"
+       ORDER BY id`
     );
-    return result.rows.map((row) => ({
-      id: row.id,
-      name: row.name,
-      appliedAt: row.applied_at
-    }));
+    return result.rows.map((row) => {
+      const appliedAt = format.columns.timestampType === "bigint" ? new Date(Number(row.applied_at)) : new Date(row.applied_at);
+      return {
+        id: row.id,
+        identifier: row.identifier,
+        // Set name or hash based on format
+        ...format.columns.identifier === "name" ? { name: row.identifier } : { hash: 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);
+  }
+  /**
+   * Get or detect the format for a schema
+   * Returns the configured format or auto-detects from existing table
+   */
+  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);
   }
   /**
    * Apply a migration to a schema
    */
-  async applyMigration(pool, schemaName, migration) {
+  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}"."${this.migrationsTable}" (name) VALUES ($1)`,
-        [migration.name]
+        `INSERT INTO "${schemaName}"."${format.tableName}" ("${identifier}", "${timestamp}") VALUES ($1, $2)`,
+        [identifierValue, timestampValue]
       );
       await client.query("COMMIT");
     } catch (error) {