@remix-run/data-table 0.2.1 → 0.4.0

package/dist/lib/migrations/runner.js

@@ -1,7 +1,6 @@
-import { createDatabase, createDatabaseWithTransaction } from "../database.js";
-import { deleteJournalRow, ensureMigrationJournal, getBatch, hasMigrationJournal, insertJournalRow, loadJournalRows, normalizeChecksum, } from "./journal-store.js";
-import { resolveMigrations } from "./registry.js";
-import { createMigrationSchema } from "./schema-api.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;
@@ -10,28 +9,42 @@ 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) {
+function resolveTargetOption(migrations, to) {
     if (!to) {
-        return;
+        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;
 }
-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 = normalizeChecksum(migration);
+        let expected = await computeChecksum(migration);
         if (expected !== row.checksum) {
             throw new Error('Migration checksum drift detected for "' +
                 row.id +
@@ -43,190 +56,154 @@ function assertNoMigrationDrift(migrations, journal) {
         }
     }
 }
-function createDryRunDatabase(adapter) {
-    let error = new Error('Cannot execute data operations while running migrations with dryRun');
-    let throwDryRunError = async () => {
-        throw error;
-    };
-    let dryRunAdapter = {
-        dialect: adapter.dialect,
-        capabilities: adapter.capabilities,
-        compileSql(operation) {
-            return adapter.compileSql(operation);
-        },
-        async hasTable(table) {
-            return adapter.hasTable(table);
-        },
-        async hasColumn(table, column) {
-            return adapter.hasColumn(table, column);
-        },
-        execute: throwDryRunError,
-        migrate: throwDryRunError,
-        beginTransaction: throwDryRunError,
-        commitTransaction: throwDryRunError,
-        rollbackTransaction: throwDryRunError,
-        createSavepoint: throwDryRunError,
-        rollbackToSavepoint: throwDryRunError,
-        releaseSavepoint: throwDryRunError,
-    };
-    return createDatabase(dryRunAdapter);
+function resolveTransactionMode(migration) {
+    if (migration.transaction) {
+        return migration.transaction;
+    }
+    let directive = parseTransactionDirective(migration.up);
+    if (directive) {
+        return directive;
+    }
+    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]));
-        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 {
-            let appliedMigrations = migrations
-                .filter((migration) => appliedMap.has(migration.id))
-                .reverse();
-            if (target) {
-                appliedMigrations = appliedMigrations.filter((migration) => migration.id >= target);
-            }
-            if (step !== undefined) {
-                appliedMigrations = appliedMigrations.slice(0, step);
-            }
-            toRun = appliedMigrations;
+    }
+    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) {
-            if (migration.migration.transaction === '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 &&
-                migration.migration.transaction !== '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);
+                }
             }
-            let db = dryRun
-                ? createDryRunDatabase(adapter)
-                : token
-                    ? createDatabaseWithTransaction(adapter, token)
-                    : createDatabase(adapter);
-            let schema = createMigrationSchema(db, async (operation) => {
-                let compiled = adapter.compileSql(operation);
-                sql.push(...compiled);
+            if (input.direction === 'up') {
                 if (!dryRun) {
-                    await adapter.migrate({ operation, transaction: token });
-                }
-            }, { transaction: token });
-            let context = {
-                db,
-                schema,
-            };
-            try {
-                if (input.direction === 'up') {
-                    await migration.migration.up(context);
-                    if (!dryRun) {
-                        await insertJournalRow(adapter, journalTable, {
-                            id: migration.id,
-                            name: migration.name,
-                            checksum: normalizeChecksum(migration),
-                            batch,
-                        }, token);
-                    }
-                    applied.push({
+                    await insertJournalRow(driver, journalTable, {
                         id: migration.id,
                         name: migration.name,
-                        status: 'applied',
-                    });
-                }
-                else {
-                    await migration.migration.down(context);
-                    if (!dryRun) {
-                        await deleteJournalRow(adapter, journalTable, migration.id, token);
-                    }
-                    reverted.push({
-                        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 migrations against an adapter.
- * @param adapter Database adapter used to compile and execute migration operations.
- * @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',
@@ -235,7 +212,7 @@ export function createMigrationRunner(adapter, migrations, options = {}) {
         },
         async down(runOptions = {}) {
             return runMigrations({
-                adapter,
+                driver,
                 migrations: resolveMigrations(migrations),
                 journalTable,
                 direction: 'down',
@@ -243,21 +220,25 @@ 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);
-            return sortedMigrations.map((migration) => {
+            let migrationIds = new Set(sortedMigrations.map((migration) => migration.id));
+            let statuses = [];
+            for (let migration of sortedMigrations) {
                 let journalRow = journalMap.get(migration.id);
                 if (!journalRow) {
-                    return {
+                    statuses.push({
                         id: migration.id,
                         name: migration.name,
                         status: 'pending',
-                    };
+                    });
+                    continue;
                 }
-                let checksum = normalizeChecksum(migration);
-                return {
+                let checksum = await computeChecksum(migration);
+                statuses.push({
                     id: migration.id,
                     name: migration.name,
                     status: checksum === journalRow.checksum
@@ -266,8 +247,22 @@ export function createMigrationRunner(adapter, migrations, options = {}) {
                     appliedAt: journalRow.appliedAt,
                     batch: journalRow.batch,
                     checksum: journalRow.checksum,
-                };
-            });
+                });
+            }
+            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,10 +1,13 @@
-import type { MigrationDescriptor } from './migrations.ts';
+import type { MigrationDescriptor, Seed } from './migrations.ts';
 /**
- * Loads migration modules from a directory on Node.js.
+ * Loads SQL-file migrations from a directory on Node.js.
  *
- * Filenames are used to infer migration `id` and `name`.
- * Each file must default-export `createMigration(...)`.
- * @param directory Absolute or relative directory containing migration files.
+ * Each migration is a directory named `YYYYMMDDHHmmss_<slug>` containing:
+ * - `up.sql` (required)
+ * - `down.sql` (optional; omit for irreversible migrations)
+ *
+ * `id` and `name` are inferred from the directory name.
+ * @param directory Absolute or relative directory containing migration directories.
  * @returns A sorted list of loaded migration descriptors.
  * @example
  * ```ts
@@ -14,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":"AAIA,OAAO,KAAK,EAAa,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAGrE;;;;;;;;;;;;;GAaG;AACH,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAiDtF"}
+{"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,22 +1,15 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { createHash } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { parseMigrationFilename } from "./migrations/filename.js";
+import { parseMigrationDirectoryName } from './migrations/directory-name.js';
 /**
- * Loads migration modules from a directory on Node.js.
+ * Loads SQL-file migrations from a directory on Node.js.
+ *
+ * Each migration is a directory named `YYYYMMDDHHmmss_<slug>` containing:
+ * - `up.sql` (required)
+ * - `down.sql` (optional; omit for irreversible migrations)
  *
- * Filenames are used to infer migration `id` and `name`.
- * Each file must default-export `createMigration(...)`.
- * @param directory Absolute or relative directory containing migration files.
+ * `id` and `name` are inferred from the directory name.
+ * @param directory Absolute or relative directory containing migration directories.
  * @returns A sorted list of loaded migration descriptors.
  * @example
  * ```ts
@@ -26,40 +19,79 @@ import { parseMigrationFilename } from "./migrations/filename.js";
  * ```
  */
 export async function loadMigrations(directory) {
-    let allFiles = (await fs.readdir(directory, { withFileTypes: true }))
-        .filter((entry) => entry.isFile())
+    let entries = await fs.readdir(directory, { withFileTypes: true });
+    let directories = entries
+        .filter((entry) => entry.isDirectory())
         .map((entry) => entry.name)
         .sort((left, right) => left.localeCompare(right));
-    let files = [];
-    for (let file of allFiles) {
-        if (!/\.(?:m?ts|m?js|cts|cjs)$/.test(file)) {
-            continue;
-        }
-        let parsed = parseMigrationFilename(file);
-        files.push({ file, id: parsed.id, name: parsed.name });
-    }
     let migrations = [];
     let seenIds = new Set();
-    for (let entry of files) {
-        if (seenIds.has(entry.id)) {
-            throw new Error('Duplicate migration id "' + entry.id + '" inferred from filename "' + entry.file + '"');
+    for (let directoryName of directories) {
+        let parsed = parseMigrationDirectoryName(directoryName);
+        if (seenIds.has(parsed.id)) {
+            throw new Error('Duplicate migration id "' +
+                parsed.id +
+                '" inferred from directory "' +
+                directoryName +
+                '"');
         }
-        seenIds.add(entry.id);
-        let fullPath = path.join(directory, entry.file);
-        let source = await fs.readFile(fullPath, 'utf8');
-        let checksum = createHash('sha256').update(source).digest('hex');
-        let module = (await import(__rewriteRelativeImportExtension(pathToFileURL(fullPath).href)));
-        let migration = module.default;
-        if (!migration || typeof migration.up !== 'function' || typeof migration.down !== 'function') {
-            throw new Error('Migration file "' + entry.file + '" must default-export createMigration(...)');
+        seenIds.add(parsed.id);
+        let directoryPath = path.join(directory, directoryName);
+        let upPath = path.join(directoryPath, 'up.sql');
+        let downPath = path.join(directoryPath, 'down.sql');
+        let up;
+        try {
+            up = await fs.readFile(upPath, 'utf8');
+        }
+        catch (error) {
+            if (isNodeFileNotFoundError(error)) {
+                throw new Error('Migration directory "' + directoryName + '" is missing up.sql');
+            }
+            throw error;
+        }
+        let down;
+        try {
+            down = await fs.readFile(downPath, 'utf8');
+        }
+        catch (error) {
+            if (!isNodeFileNotFoundError(error)) {
+                throw error;
+            }
         }
         migrations.push({
-            id: entry.id,
-            name: entry.name,
-            path: fullPath,
-            checksum,
-            migration,
+            id: parsed.id,
+            name: parsed.name,
+            up,
+            down,
+            path: directoryPath,
         });
     }
     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 &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}