@remix-run/data-table 0.3.0 → 0.5.0

package/dist/lib/migrations/journal-store.js

@@ -1,4 +1,4 @@
-import { rawSql } from "../sql.js";
+import { rawSql } from '../sql.js';
 export async function computeChecksum(migration) {
     let digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(migration.up));
     return bytesToHex(new Uint8Array(digest));
@@ -10,8 +10,8 @@ function bytesToHex(bytes) {
     }
     return hex;
 }
-export async function ensureMigrationJournal(adapter, tableName) {
-    await adapter.executeScript('create table if not exists ' +
+export async function ensureMigrationJournal(driver, tableName) {
+    await driver.executeScript('create table if not exists ' +
         tableName +
         ' (' +
         'id varchar(64) not null primary key, ' +
@@ -21,9 +21,9 @@ export async function ensureMigrationJournal(adapter, tableName) {
         'applied_at timestamp not null default current_timestamp' +
         ')');
 }
-export async function hasMigrationJournal(adapter, tableName) {
+export async function hasMigrationJournal(driver, tableName) {
     try {
-        await adapter.execute({
+        await driver.execute({
             operation: {
                 kind: 'raw',
                 sql: rawSql('select 1 from ' + tableName + ' limit 1'),
@@ -32,11 +32,20 @@ export async function hasMigrationJournal(adapter, tableName) {
         return true;
     }
     catch {
+        // The probe fails both when the journal table is missing and when the
+        // database itself is unreachable. Only the former means "no journal yet";
+        // rethrow connection/auth failures via a table-independent query.
+        await driver.execute({
+            operation: {
+                kind: 'raw',
+                sql: rawSql('select 1'),
+            },
+        });
         return false;
     }
 }
-export async function loadJournalRows(adapter, tableName) {
-    let result = await adapter.execute({
+export async function loadJournalRows(driver, tableName) {
+    let result = await driver.execute({
         operation: {
             kind: 'raw',
             sql: rawSql('select id, name, checksum, batch, applied_at from ' + tableName + ' order by id asc'),
@@ -51,8 +60,8 @@ export async function loadJournalRows(adapter, tableName) {
         appliedAt: new Date(String(row.applied_at)),
     }));
 }
-export async function insertJournalRow(adapter, tableName, row, transaction) {
-    await adapter.execute({
+export async function insertJournalRow(driver, tableName, row, transaction) {
+    await driver.execute({
         operation: {
             kind: 'raw',
             sql: rawSql('insert into ' + tableName + ' (id, name, checksum, batch) values (?, ?, ?, ?)', [
@@ -65,8 +74,8 @@ export async function insertJournalRow(adapter, tableName, row, transaction) {
         transaction,
     });
 }
-export async function deleteJournalRow(adapter, tableName, id, transaction) {
-    await adapter.execute({
+export async function deleteJournalRow(driver, tableName, id, transaction) {
+    await driver.execute({
         operation: {
             kind: 'raw',
             sql: rawSql('delete from ' + tableName + ' where id = ?', [id]),

package/dist/lib/migrations/runner.d.ts

@@ -1,20 +1,13 @@
-import type { DatabaseAdapter } from '../adapter.ts';
-import type { MigrationDescriptor, MigrationRegistry, MigrationRunner, MigrationRunnerOptions } from '../migrations.ts';
-/**
- * Creates a migration runner for applying/reverting SQL migrations against an adapter.
- * @param adapter Database adapter used to execute migration scripts.
- * @param migrations Migration descriptors or registry.
- * @param options Optional runner configuration.
- * @returns A migration runner instance.
- * @example
- * ```ts
- * import { createMigrationRunner } from 'remix/data-table/migrations'
- *
- * let runner = createMigrationRunner(adapter, migrations, {
- *   journalTable: 'app_migrations',
- * })
- * await runner.up()
- * ```
- */
-export declare function createMigrationRunner(adapter: DatabaseAdapter, migrations: MigrationDescriptor[] | MigrationRegistry, options?: MigrationRunnerOptions): MigrationRunner;
+import type { DatabaseDriver } from '../driver.ts';
+import type { MigrationOperationOptions, MigrateResult, MigrationDescriptor, MigrationRegistry, MigrationStatusEntry } from '../migrations.ts';
+interface MigrationRunnerOptions {
+    journalTable?: string;
+}
+interface MigrationRunner {
+    up(options?: MigrationOperationOptions): Promise<MigrateResult>;
+    down(options?: MigrationOperationOptions): Promise<MigrateResult>;
+    status(): Promise<MigrationStatusEntry[]>;
+}
+export declare function createMigrationRunner(driver: DatabaseDriver, migrations: MigrationDescriptor[] | MigrationRegistry, options?: MigrationRunnerOptions): MigrationRunner;
+export {};
 //# sourceMappingURL=runner.d.ts.map

package/dist/lib/migrations/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/lib/migrations/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,eAAe,CAAA;AACtE,OAAO,KAAK,EAGV,mBAAmB,EAGnB,iBAAiB,EACjB,eAAe,EACf,sBAAsB,EAIvB,MAAM,kBAAkB,CAAA;AAqPzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,mBAAmB,EAAE,GAAG,iBAAiB,EACrD,OAAO,GAAE,sBAA2B,GACnC,eAAe,CA6DjB"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/lib/migrations/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAoB,MAAM,cAAc,CAAA;AACpE,OAAO,KAAK,EACV,yBAAyB,EACzB,aAAa,EACb,mBAAmB,EAGnB,iBAAiB,EAEjB,oBAAoB,EAErB,MAAM,kBAAkB,CAAA;AAEzB,UAAU,sBAAsB;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,UAAU,eAAe;IACvB,EAAE,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/D,IAAI,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;IACjE,MAAM,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAAA;CAC1C;AAkSD,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,mBAAmB,EAAE,GAAG,iBAAiB,EACrD,OAAO,GAAE,sBAA2B,GACnC,eAAe,CA6EjB"}

package/dist/lib/migrations/runner.js

@@ -1,6 +1,6 @@
-import { parseTransactionDirective } from "./directive.js";
-import { deleteJournalRow, ensureMigrationJournal, getBatch, hasMigrationJournal, insertJournalRow, loadJournalRows, computeChecksum, } from "./journal-store.js";
-import { resolveMigrations } from "./registry.js";
+import { parseTransactionDirective } from './directive.js';
+import { deleteJournalRow, ensureMigrationJournal, getBatch, hasMigrationJournal, insertJournalRow, loadJournalRows, computeChecksum, } from './journal-store.js';
+import { resolveMigrations } from './registry.js';
 function assertStepOption(step) {
     if (step === undefined) {
         return;
@@ -9,26 +9,40 @@ function assertStepOption(step) {
         throw new Error('Invalid migration step option. Expected a positive integer.');
     }
 }
-function assertMigrateOptions(options) {
+function assertMigrationOperationOptions(options) {
     if (options.to !== undefined && options.step !== undefined) {
         throw new Error('Cannot combine "to" and "step" migration options in the same run');
     }
 }
-function assertTargetOption(migrations, to) {
-    if (!to) {
-        return;
+function resolveTargetOption(migrations, to) {
+    if (to === undefined) {
+        return undefined;
     }
-    let target = migrations.find((migration) => migration.id === to);
-    if (!target) {
+    // Accept either a bare migration id or the full `id_name` directory form and
+    // normalize to the bare id so range filtering compares ids consistently.
+    let matches = migrations.filter((migration) => migration.id === to || migration.id + '_' + migration.name === to);
+    if (matches.length === 0) {
         throw new Error('Unknown migration target: ' + to);
     }
+    if (matches.length > 1) {
+        throw new Error('Ambiguous migration target "' +
+            to +
+            '". Matches: ' +
+            matches.map((migration) => migration.id + '_' + migration.name).join(', '));
+    }
+    return matches[0].id;
 }
-async function assertNoMigrationDrift(migrations, journal) {
+async function assertMigrationIntegrity(migrations, journal, direction) {
     let migrationMap = new Map(migrations.map((migration) => [migration.id, migration]));
     for (let row of journal) {
         let migration = migrationMap.get(row.id);
         if (!migration) {
-            continue;
+            // Rolling back must stay possible when journal rows have no matching
+            // migration files, so only forward runs hard-error on orphaned entries.
+            if (direction === 'down') {
+                continue;
+            }
+            throw new Error('Applied migration "' + row.id + '_' + row.name + '" is missing from current migrations');
         }
         let expected = await computeChecksum(migration);
         if (expected !== row.checksum) {
@@ -53,150 +67,143 @@ function resolveTransactionMode(migration) {
     return 'auto';
 }
 async function runMigrations(input) {
-    let adapter = input.adapter;
+    if (input.driver.capabilities.migrationLock && !input.driver.withMigrationLock) {
+        throw new Error('Database driver reports migration lock support but does not implement withMigrationLock()');
+    }
+    if (input.driver.withMigrationLock) {
+        return input.driver.withMigrationLock(input.journalTable, (driver) => runMigrationsUnlocked({ ...input, driver }));
+    }
+    return runMigrationsUnlocked(input);
+}
+async function runMigrationsUnlocked(input) {
+    let driver = input.driver;
     let migrations = input.migrations;
     let journalTable = input.journalTable;
     let dryRun = Boolean(input.options.dryRun);
-    let target = input.options.to;
     let step = input.options.step;
-    assertMigrateOptions(input.options);
+    assertMigrationOperationOptions(input.options);
     assertStepOption(step);
-    assertTargetOption(migrations, target);
+    let target = resolveTargetOption(migrations, input.options.to);
     let sql = [];
-    await adapter.acquireMigrationLock?.();
-    try {
-        let journal = [];
-        if (dryRun) {
-            let canReadJournal = await hasMigrationJournal(adapter, journalTable);
-            if (canReadJournal) {
-                journal = await loadJournalRows(adapter, journalTable);
+    let journal = [];
+    if (dryRun) {
+        let canReadJournal = await hasMigrationJournal(driver, journalTable);
+        if (canReadJournal) {
+            journal = await loadJournalRows(driver, journalTable);
+        }
+    }
+    else {
+        await ensureMigrationJournal(driver, journalTable);
+        journal = await loadJournalRows(driver, journalTable);
+    }
+    let appliedMap = new Map(journal.map((row) => [row.id, row]));
+    await assertMigrationIntegrity(migrations, journal, input.direction);
+    let toRun = [];
+    if (input.direction === 'up') {
+        for (let migration of migrations) {
+            if (!appliedMap.has(migration.id)) {
+                toRun.push(migration);
             }
         }
-        else {
-            await ensureMigrationJournal(adapter, journalTable);
-            journal = await loadJournalRows(adapter, journalTable);
+        if (target) {
+            toRun = toRun.filter((migration) => migration.id <= target);
         }
-        let appliedMap = new Map(journal.map((row) => [row.id, row]));
-        await assertNoMigrationDrift(migrations, journal);
-        let toRun = [];
-        if (input.direction === 'up') {
-            for (let migration of migrations) {
-                if (!appliedMap.has(migration.id)) {
-                    toRun.push(migration);
-                }
-            }
-            if (target) {
-                toRun = toRun.filter((migration) => migration.id <= target);
-            }
-            if (step !== undefined) {
-                toRun = toRun.slice(0, step);
-            }
+        if (step !== undefined) {
+            toRun = toRun.slice(0, step);
         }
-        else {
-            toRun = migrations.filter((migration) => appliedMap.has(migration.id)).reverse();
-            if (target) {
-                toRun = toRun.filter((migration) => migration.id >= target);
-            }
-            if (step !== undefined) {
-                toRun = toRun.slice(0, step);
-            }
-            for (let migration of toRun) {
-                if (migration.down === undefined) {
-                    throw new Error('Migration "' + migration.id + '" has no down script');
-                }
-            }
+    }
+    else {
+        toRun = migrations.filter((migration) => appliedMap.has(migration.id)).reverse();
+        if (target) {
+            toRun = toRun.filter((migration) => migration.id >= target);
+        }
+        if (step !== undefined) {
+            toRun = toRun.slice(0, step);
         }
-        let applied = [];
-        let reverted = [];
-        let batch = getBatch(journal);
         for (let migration of toRun) {
-            let script = (input.direction === 'up' ? migration.up : migration.down);
-            let mode = resolveTransactionMode(migration);
-            if (mode === 'required' && !adapter.capabilities.transactionalDdl) {
-                throw new Error('Migration "' +
-                    migration.id +
-                    '" requires transactional DDL, but adapter does not support it');
+            if (migration.down === undefined) {
+                throw new Error('Migration "' + migration.id + '" has no down script');
             }
-            let shouldUseTransaction = !dryRun && mode !== 'none' && adapter.capabilities.transactionalDdl;
-            let token;
-            if (shouldUseTransaction) {
-                token = await adapter.beginTransaction();
+        }
+    }
+    let applied = [];
+    let reverted = [];
+    let batch = getBatch(journal);
+    for (let migration of toRun) {
+        let script = (input.direction === 'up' ? migration.up : migration.down);
+        let mode = resolveTransactionMode(migration);
+        if (mode === 'required' && !driver.capabilities.transactionalDdl) {
+            throw new Error('Migration "' +
+                migration.id +
+                '" requires transactional DDL, but the database does not support it');
+        }
+        let shouldUseTransaction = !dryRun && mode !== 'none' && driver.capabilities.transactionalDdl;
+        let token;
+        if (shouldUseTransaction) {
+            token = await driver.beginTransaction();
+        }
+        sql.push(script);
+        try {
+            if (!dryRun) {
+                if (script.trim().length > 0) {
+                    await driver.executeScript(script, token);
+                }
             }
-            sql.push(script);
-            try {
+            if (input.direction === 'up') {
                 if (!dryRun) {
-                    if (script.trim().length > 0) {
-                        await adapter.executeScript(script, token);
-                    }
-                }
-                if (input.direction === 'up') {
-                    if (!dryRun) {
-                        await insertJournalRow(adapter, journalTable, {
-                            id: migration.id,
-                            name: migration.name,
-                            checksum: await computeChecksum(migration),
-                            batch,
-                        }, token);
-                    }
-                    applied.push({
-                        id: migration.id,
-                        name: migration.name,
-                        status: 'applied',
-                    });
-                }
-                else {
-                    if (!dryRun) {
-                        await deleteJournalRow(adapter, journalTable, migration.id, token);
-                    }
-                    reverted.push({
+                    await insertJournalRow(driver, journalTable, {
                         id: migration.id,
                         name: migration.name,
-                        status: 'pending',
-                    });
+                        checksum: await computeChecksum(migration),
+                        batch,
+                    }, token);
                 }
-                if (token) {
-                    await adapter.commitTransaction(token);
+                applied.push({
+                    id: migration.id,
+                    name: migration.name,
+                    status: 'applied',
+                });
+            }
+            else {
+                if (!dryRun) {
+                    await deleteJournalRow(driver, journalTable, migration.id, token);
                 }
+                reverted.push({
+                    id: migration.id,
+                    name: migration.name,
+                    status: 'pending',
+                });
             }
-            catch (error) {
-                if (token) {
-                    await adapter.rollbackTransaction(token);
+        }
+        catch (error) {
+            if (token) {
+                try {
+                    await driver.rollbackTransaction(token);
+                }
+                catch (rollbackError) {
+                    throw new AggregateError([error, rollbackError], 'Migration and rollback both failed', {
+                        cause: error,
+                    });
                 }
-                throw error;
             }
+            throw error;
+        }
+        if (token) {
+            await driver.commitTransaction(token);
         }
-        return {
-            applied,
-            reverted,
-            sql,
-        };
-    }
-    finally {
-        await adapter.releaseMigrationLock?.();
     }
+    return {
+        applied,
+        reverted,
+        sql,
+    };
 }
-/**
- * Creates a migration runner for applying/reverting SQL migrations against an adapter.
- * @param adapter Database adapter used to execute migration scripts.
- * @param migrations Migration descriptors or registry.
- * @param options Optional runner configuration.
- * @returns A migration runner instance.
- * @example
- * ```ts
- * import { createMigrationRunner } from 'remix/data-table/migrations'
- *
- * let runner = createMigrationRunner(adapter, migrations, {
- *   journalTable: 'app_migrations',
- * })
- * await runner.up()
- * ```
- */
-export function createMigrationRunner(adapter, migrations, options = {}) {
+export function createMigrationRunner(driver, migrations, options = {}) {
     let journalTable = options.journalTable ?? 'data_table_migrations';
     return {
         async up(runOptions = {}) {
             return runMigrations({
-                adapter,
+                driver,
                 migrations: resolveMigrations(migrations),
                 journalTable,
                 direction: 'up',
@@ -205,7 +212,7 @@ export function createMigrationRunner(adapter, migrations, options = {}) {
         },
         async down(runOptions = {}) {
             return runMigrations({
-                adapter,
+                driver,
                 migrations: resolveMigrations(migrations),
                 journalTable,
                 direction: 'down',
@@ -213,10 +220,12 @@ export function createMigrationRunner(adapter, migrations, options = {}) {
             });
         },
         async status() {
-            await ensureMigrationJournal(adapter, journalTable);
-            let journal = await loadJournalRows(adapter, journalTable);
+            let journal = (await hasMigrationJournal(driver, journalTable))
+                ? await loadJournalRows(driver, journalTable)
+                : [];
             let journalMap = new Map(journal.map((row) => [row.id, row]));
             let sortedMigrations = resolveMigrations(migrations);
+            let migrationIds = new Set(sortedMigrations.map((migration) => migration.id));
             let statuses = [];
             for (let migration of sortedMigrations) {
                 let journalRow = journalMap.get(migration.id);
@@ -240,7 +249,20 @@ export function createMigrationRunner(adapter, migrations, options = {}) {
                     checksum: journalRow.checksum,
                 });
             }
-            return statuses;
+            for (let journalRow of journal) {
+                if (migrationIds.has(journalRow.id)) {
+                    continue;
+                }
+                statuses.push({
+                    id: journalRow.id,
+                    name: journalRow.name,
+                    status: 'missing',
+                    appliedAt: journalRow.appliedAt,
+                    batch: journalRow.batch,
+                    checksum: journalRow.checksum,
+                });
+            }
+            return statuses.sort((left, right) => left.id.localeCompare(right.id));
         },
     };
 }

package/dist/lib/migrations-node.d.ts

@@ -1,4 +1,4 @@
-import type { MigrationDescriptor } from './migrations.ts';
+import type { MigrationDescriptor, Seed } from './migrations.ts';
 /**
  * Loads SQL-file migrations from a directory on Node.js.
  *
@@ -17,4 +17,22 @@ import type { MigrationDescriptor } from './migrations.ts';
  * ```
  */
 export declare function loadMigrations(directory: string): Promise<MigrationDescriptor[]>;
+/**
+ * Loads a SQL seed file on Node.js.
+ *
+ * The file may contain multiple SQL statements. Seeds that must be safe to
+ * run against an already-seeded database should use idempotent statements
+ * (for example, `insert or ignore` on SQLite).
+ *
+ * @param filename Absolute or relative path to a SQL seed file.
+ * @returns A seed function that executes the file's SQL script.
+ * @example
+ * ```ts
+ * import { loadSeed } from 'remix/data-table/migrations/node'
+ *
+ * let seed = await loadSeed('./app/data/seed.sql')
+ * await db.reset({ migrations, seed })
+ * ```
+ */
+export declare function loadSeed(filename: string): Promise<Seed>;
 //# sourceMappingURL=migrations-node.d.ts.map

package/dist/lib/migrations-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migrations-node.d.ts","sourceRoot":"","sources":["../../src/lib/migrations-node.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAG1D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CA0DtF"}
+{"version":3,"file":"migrations-node.d.ts","sourceRoot":"","sources":["../../src/lib/migrations-node.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAGhE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CA0DtF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG9D"}

package/dist/lib/migrations-node.js

@@ -1,6 +1,6 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { parseMigrationDirectoryName } from "./migrations/directory-name.js";
+import { parseMigrationDirectoryName } from './migrations/directory-name.js';
 /**
  * Loads SQL-file migrations from a directory on Node.js.
  *
@@ -68,6 +68,27 @@ export async function loadMigrations(directory) {
     }
     return migrations;
 }
+/**
+ * Loads a SQL seed file on Node.js.
+ *
+ * The file may contain multiple SQL statements. Seeds that must be safe to
+ * run against an already-seeded database should use idempotent statements
+ * (for example, `insert or ignore` on SQLite).
+ *
+ * @param filename Absolute or relative path to a SQL seed file.
+ * @returns A seed function that executes the file's SQL script.
+ * @example
+ * ```ts
+ * import { loadSeed } from 'remix/data-table/migrations/node'
+ *
+ * let seed = await loadSeed('./app/data/seed.sql')
+ * await db.reset({ migrations, seed })
+ * ```
+ */
+export async function loadSeed(filename) {
+    let sql = await fs.readFile(filename, 'utf8');
+    return (db) => db.executeScript(sql);
+}
 function isNodeFileNotFoundError(error) {
     return (typeof error === 'object' &&
         error !== null &&