@remix-run/data-table 0.0.0 → 0.2.0

package/dist/lib/migrations/schema-api.js

@@ -0,0 +1,326 @@
+import { rawSql } from "../sql.js";
+import { getTableColumnDefinitions, getTableName, getTablePrimaryKey } from "../table.js";
+import { ColumnBuilder } from "../column.js";
+import { createCheckName, createForeignKeyName, createIndexName, createPrimaryKeyName, createUniqueName, normalizeIndexColumns, normalizeKeyColumns, toTableRef, } from "./helpers.js";
+function asColumnDefinition(definition) {
+    if (definition instanceof ColumnBuilder) {
+        return definition.build();
+    }
+    return definition;
+}
+function asTableRef(value) {
+    if (typeof value === 'string') {
+        return toTableRef(value);
+    }
+    return toTableRef(getTableName(value));
+}
+function lowerTableForCreate(table) {
+    let tableRef = toTableRef(getTableName(table));
+    let sourceColumnDefinitions = getTableColumnDefinitions(table);
+    let columns = {};
+    let uniques = [];
+    let checks = [];
+    let foreignKeys = [];
+    for (let columnName in sourceColumnDefinitions) {
+        if (!Object.prototype.hasOwnProperty.call(sourceColumnDefinitions, columnName)) {
+            continue;
+        }
+        let sourceDefinition = sourceColumnDefinitions[columnName];
+        let columnDefinition = {
+            ...sourceDefinition,
+            checks: undefined,
+            references: undefined,
+            primaryKey: undefined,
+        };
+        let unique = sourceDefinition.unique;
+        if (unique) {
+            let uniqueName = typeof unique === 'object' && unique.name
+                ? unique.name
+                : createUniqueName(tableRef, [columnName]);
+            uniques.push({
+                name: uniqueName,
+                columns: [columnName],
+            });
+            columnDefinition.unique = undefined;
+        }
+        if (sourceDefinition.checks) {
+            for (let check of sourceDefinition.checks) {
+                checks.push({
+                    name: check.name || createCheckName(tableRef, check.expression),
+                    expression: check.expression,
+                });
+            }
+        }
+        if (sourceDefinition.references) {
+            let referenceColumns = [...sourceDefinition.references.columns];
+            let referencesTable = { ...sourceDefinition.references.table };
+            foreignKeys.push({
+                name: sourceDefinition.references.name ||
+                    createForeignKeyName(tableRef, [columnName], referencesTable, referenceColumns),
+                columns: [columnName],
+                references: {
+                    table: referencesTable,
+                    columns: referenceColumns,
+                },
+                onDelete: sourceDefinition.references.onDelete,
+                onUpdate: sourceDefinition.references.onUpdate,
+            });
+        }
+        columns[columnName] = columnDefinition;
+    }
+    let primaryKeyColumns = [...getTablePrimaryKey(table)];
+    let primaryKey;
+    if (primaryKeyColumns.length > 0) {
+        primaryKey = {
+            columns: primaryKeyColumns,
+            name: createPrimaryKeyName(tableRef),
+        };
+    }
+    return {
+        kind: 'createTable',
+        table: tableRef,
+        columns,
+        primaryKey,
+        uniques: uniques.length > 0 ? uniques : undefined,
+        checks: checks.length > 0 ? checks : undefined,
+        foreignKeys: foreignKeys.length > 0 ? foreignKeys : undefined,
+    };
+}
+class AlterTableBuilderRuntime {
+    alterChanges = [];
+    extraStatements = [];
+    table;
+    constructor(table) {
+        this.table = table;
+    }
+    addColumn(name, definition) {
+        this.alterChanges.push({
+            kind: 'addColumn',
+            column: name,
+            definition: asColumnDefinition(definition),
+        });
+    }
+    changeColumn(name, definition) {
+        this.alterChanges.push({
+            kind: 'changeColumn',
+            column: name,
+            definition: asColumnDefinition(definition),
+        });
+    }
+    renameColumn(from, to) {
+        this.alterChanges.push({ kind: 'renameColumn', from, to });
+    }
+    dropColumn(name, options) {
+        this.alterChanges.push({ kind: 'dropColumn', column: name, ifExists: options?.ifExists });
+    }
+    addPrimaryKey(columns, options) {
+        let normalizedColumns = normalizeKeyColumns(columns);
+        this.alterChanges.push({
+            kind: 'addPrimaryKey',
+            constraint: {
+                columns: normalizedColumns,
+                name: options?.name ?? createPrimaryKeyName(this.table),
+            },
+        });
+    }
+    dropPrimaryKey(name) {
+        this.alterChanges.push({ kind: 'dropPrimaryKey', name });
+    }
+    addUnique(columns, options) {
+        let normalizedColumns = normalizeKeyColumns(columns);
+        this.alterChanges.push({
+            kind: 'addUnique',
+            constraint: {
+                columns: normalizedColumns,
+                name: options?.name ?? createUniqueName(this.table, normalizedColumns),
+            },
+        });
+    }
+    dropUnique(name) {
+        this.alterChanges.push({ kind: 'dropUnique', name });
+    }
+    addForeignKey(columns, refTable, refColumns, options) {
+        let normalizedColumns = normalizeKeyColumns(columns);
+        let normalizedReferenceColumns = refColumns ? normalizeKeyColumns(refColumns) : ['id'];
+        let referenceTable = asTableRef(refTable);
+        this.alterChanges.push({
+            kind: 'addForeignKey',
+            constraint: {
+                columns: normalizedColumns,
+                references: {
+                    table: referenceTable,
+                    columns: normalizedReferenceColumns,
+                },
+                name: options?.name ??
+                    createForeignKeyName(this.table, normalizedColumns, referenceTable, normalizedReferenceColumns),
+                onDelete: options?.onDelete,
+                onUpdate: options?.onUpdate,
+            },
+        });
+    }
+    dropForeignKey(name) {
+        this.alterChanges.push({ kind: 'dropForeignKey', name });
+    }
+    addCheck(expression, options) {
+        this.alterChanges.push({
+            kind: 'addCheck',
+            constraint: {
+                expression,
+                name: options?.name ?? createCheckName(this.table, expression),
+            },
+        });
+    }
+    dropCheck(name) {
+        this.alterChanges.push({ kind: 'dropCheck', name });
+    }
+    addIndex(columns, options) {
+        let normalizedColumns = normalizeIndexColumns(columns);
+        let { name, ifNotExists, ...indexOptions } = options ?? {};
+        this.extraStatements.push({
+            kind: 'createIndex',
+            index: {
+                table: this.table,
+                name: name ?? createIndexName(this.table, normalizedColumns),
+                columns: normalizedColumns,
+                ...indexOptions,
+            },
+            ifNotExists,
+        });
+    }
+    dropIndex(name) {
+        this.extraStatements.push({
+            kind: 'dropIndex',
+            table: this.table,
+            name,
+        });
+    }
+    comment(text) {
+        this.alterChanges.push({ kind: 'setTableComment', comment: text });
+    }
+}
+export function createMigrationSchema(db, emit, options) {
+    return {
+        async createTable(table, options) {
+            let operation = lowerTableForCreate(table);
+            operation.ifNotExists = options?.ifNotExists;
+            await emit(operation);
+        },
+        async alterTable(input, migrate, options) {
+            let tableRef = asTableRef(input);
+            let builder = new AlterTableBuilderRuntime(tableRef);
+            migrate(builder);
+            if (builder.alterChanges.length > 0) {
+                await emit({
+                    kind: 'alterTable',
+                    table: tableRef,
+                    changes: builder.alterChanges,
+                    ifExists: options?.ifExists,
+                });
+            }
+            for (let operation of builder.extraStatements) {
+                await emit(operation);
+            }
+        },
+        async renameTable(from, to) {
+            await emit({ kind: 'renameTable', from: asTableRef(from), to: toTableRef(to) });
+        },
+        async dropTable(table, options) {
+            await emit({
+                kind: 'dropTable',
+                table: asTableRef(table),
+                ifExists: options?.ifExists,
+                cascade: options?.cascade,
+            });
+        },
+        async createIndex(table, columns, options) {
+            let tableRef = asTableRef(table);
+            let normalizedColumns = normalizeIndexColumns(columns);
+            let { name, ifNotExists, ...indexOptions } = options ?? {};
+            await emit({
+                kind: 'createIndex',
+                index: {
+                    table: tableRef,
+                    name: name ?? createIndexName(tableRef, normalizedColumns),
+                    columns: normalizedColumns,
+                    ...indexOptions,
+                },
+                ifNotExists,
+            });
+        },
+        async dropIndex(table, name, options) {
+            await emit({
+                kind: 'dropIndex',
+                table: asTableRef(table),
+                name,
+                ifExists: options?.ifExists,
+            });
+        },
+        async renameIndex(table, from, to) {
+            await emit({
+                kind: 'renameIndex',
+                table: asTableRef(table),
+                from,
+                to,
+            });
+        },
+        async addForeignKey(table, columns, refTable, refColumns, options) {
+            let tableRef = asTableRef(table);
+            let normalizedColumns = normalizeKeyColumns(columns);
+            let referenceTable = asTableRef(refTable);
+            let normalizedReferenceColumns = refColumns ? normalizeKeyColumns(refColumns) : ['id'];
+            await emit({
+                kind: 'addForeignKey',
+                table: tableRef,
+                constraint: {
+                    columns: normalizedColumns,
+                    references: {
+                        table: referenceTable,
+                        columns: normalizedReferenceColumns,
+                    },
+                    name: options?.name ??
+                        createForeignKeyName(tableRef, normalizedColumns, referenceTable, normalizedReferenceColumns),
+                    onDelete: options?.onDelete,
+                    onUpdate: options?.onUpdate,
+                },
+            });
+        },
+        async dropForeignKey(table, name) {
+            await emit({
+                kind: 'dropForeignKey',
+                table: asTableRef(table),
+                name,
+            });
+        },
+        async addCheck(table, expression, options) {
+            let tableRef = asTableRef(table);
+            await emit({
+                kind: 'addCheck',
+                table: tableRef,
+                constraint: {
+                    expression,
+                    name: options?.name ?? createCheckName(tableRef, expression),
+                },
+            });
+        },
+        async dropCheck(table, name) {
+            await emit({
+                kind: 'dropCheck',
+                table: asTableRef(table),
+                name,
+            });
+        },
+        async plan(sql) {
+            let statement = typeof sql === 'string' ? rawSql(sql) : sql;
+            await emit({
+                kind: 'raw',
+                sql: statement,
+            });
+        },
+        async hasTable(table) {
+            return db.adapter.hasTable(asTableRef(table), options?.transaction);
+        },
+        async hasColumn(table, columnName) {
+            return db.adapter.hasColumn(asTableRef(table), columnName, options?.transaction);
+        },
+    };
+}

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

@@ -0,0 +1,17 @@
+import type { MigrationDescriptor } from './migrations.ts';
+/**
+ * Loads migration modules 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.
+ * @returns A sorted list of loaded migration descriptors.
+ * @example
+ * ```ts
+ * import { loadMigrations } from 'remix/data-table/migrations/node'
+ *
+ * let migrations = await loadMigrations('./app/db/migrations')
+ * ```
+ */
+export declare function loadMigrations(directory: string): Promise<MigrationDescriptor[]>;
+//# sourceMappingURL=migrations-node.d.ts.map

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

@@ -0,0 +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"}

package/dist/lib/migrations-node.js

@@ -0,0 +1,65 @@
+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";
+/**
+ * Loads migration modules 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.
+ * @returns A sorted list of loaded migration descriptors.
+ * @example
+ * ```ts
+ * import { loadMigrations } from 'remix/data-table/migrations/node'
+ *
+ * let migrations = await loadMigrations('./app/db/migrations')
+ * ```
+ */
+export async function loadMigrations(directory) {
+    let allFiles = (await fs.readdir(directory, { withFileTypes: true }))
+        .filter((entry) => entry.isFile())
+        .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 + '"');
+        }
+        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(...)');
+        }
+        migrations.push({
+            id: entry.id,
+            name: entry.name,
+            path: fullPath,
+            checksum,
+            migration,
+        });
+    }
+    return migrations;
+}

package/dist/lib/migrations.d.ts

@@ -0,0 +1,292 @@
+import type { Database } from './database.ts';
+import type { ColumnDefinition, ForeignKeyAction, IndexDefinition } from './adapter.ts';
+import type { ColumnBuilder } from './column.ts';
+import type { SqlStatement } from './sql.ts';
+import type { AnyTable } from './table.ts';
+/**
+ * Controls how each migration is wrapped in transactions.
+ */
+export type MigrationTransactionMode = 'auto' | 'required' | 'none';
+/**
+ * Runtime context passed to migration `up`/`down` handlers.
+ */
+export type MigrationContext = {
+    /**
+     * Immediate data runtime (`query/create/update/exec/transaction`).
+     */
+    db: Database;
+    /**
+     * Migration schema runtime (`createTable/alterTable/createIndex/...`).
+     */
+    schema: MigrationSchema;
+};
+/**
+ * Authoring shape for `createMigration(...)`.
+ */
+export type CreateMigrationInput = {
+    up: (context: MigrationContext) => Promise<void> | void;
+    down: (context: MigrationContext) => Promise<void> | void;
+    transaction?: MigrationTransactionMode;
+};
+/**
+ * Normalized migration object consumed by the registry/runner.
+ */
+export type Migration = {
+    up: CreateMigrationInput['up'];
+    down: CreateMigrationInput['down'];
+    transaction: MigrationTransactionMode;
+};
+/**
+ * Creates a migration descriptor with normalized defaults.
+ * @param input Migration handlers and transaction mode.
+ * @returns A normalized migration object.
+ * @example
+ * ```ts
+ * import { createMigration, column as c } from 'remix/data-table/migrations'
+ * import { table } from 'remix/data-table'
+ *
+ * let users = table({
+ *   name: 'users',
+ *   columns: {
+ *     id: c.integer().primaryKey().autoIncrement(),
+ *     email: c.varchar(255).notNull().unique(),
+ *   },
+ * })
+ *
+ * export default createMigration({
+ *   async up({ db, schema }) {
+ *     await schema.createTable(users)
+ *
+ *     if (db.adapter.dialect === 'sqlite') {
+ *       await db.exec('pragma foreign_keys = on')
+ *     }
+ *   },
+ *   async down({ schema }) {
+ *     await schema.dropTable('users', { ifExists: true })
+ *   },
+ * })
+ * ```
+ */
+export declare function createMigration(input: CreateMigrationInput): Migration;
+/**
+ * Migration metadata stored in registries and returned by loaders.
+ */
+export type MigrationDescriptor = {
+    id: string;
+    name: string;
+    path?: string;
+    checksum?: string;
+    migration: Migration;
+};
+/**
+ * Direction used by migration runner operations.
+ */
+export type MigrationDirection = 'up' | 'down';
+/**
+ * Row shape persisted in the migration journal table.
+ */
+export type MigrationJournalRow = {
+    id: string;
+    name: string;
+    checksum: string;
+    batch: number;
+    appliedAt: Date;
+};
+/**
+ * Effective status for a known migration.
+ */
+export type MigrationStatus = 'applied' | 'pending' | 'drifted';
+/**
+ * Status row returned by `runner.status()` and `runner.up/down(...)`.
+ */
+export type MigrationStatusEntry = {
+    id: string;
+    name: string;
+    status: MigrationStatus;
+    appliedAt?: Date;
+    batch?: number;
+    checksum?: string;
+};
+/**
+ * Common options for `runner.up(...)` and `runner.down(...)`.
+ * `to` and `step` are mutually exclusive.
+ */
+export type MigrateOptions = {
+    to: string;
+    step?: never;
+    dryRun?: boolean;
+} | {
+    to?: never;
+    step: number;
+    dryRun?: boolean;
+} | {
+    to?: undefined;
+    step?: undefined;
+    dryRun?: boolean;
+};
+/**
+ * Result shape returned by migration runner commands.
+ */
+export type MigrateResult = {
+    applied: MigrationStatusEntry[];
+    reverted: MigrationStatusEntry[];
+    /**
+     * Compiled SQL statements for operations processed during this run.
+     * Includes planned SQL when running with `dryRun: true`.
+     */
+    sql: SqlStatement[];
+};
+/**
+ * Options for `schema.createTable(...)` migration operations.
+ */
+export type CreateTableOptions = {
+    ifNotExists?: boolean;
+};
+/**
+ * Options for `schema.alterTable(...)` migration operations.
+ */
+export type AlterTableOptions = {
+    ifExists?: boolean;
+};
+/**
+ * Options for `schema.dropTable(...)` migration operations.
+ */
+export type DropTableOptions = {
+    ifExists?: boolean;
+    cascade?: boolean;
+};
+/**
+ * Accepts either one index column or multiple (compound index).
+ */
+export type IndexColumns = string | string[];
+/**
+ * Accepts either one key column or multiple (compound key).
+ */
+export type KeyColumns = string | string[];
+/**
+ * Accepts either a SQL table name or a `table(...)` object.
+ */
+export type TableInput = string | AnyTable;
+/**
+ * Optional name override for constraints and indexes.
+ */
+export type NamedConstraintOptions = {
+    name?: string;
+};
+/**
+ * Foreign key options for migration APIs.
+ */
+export type ForeignKeyOptions = NamedConstraintOptions & {
+    onDelete?: ForeignKeyAction;
+    onUpdate?: ForeignKeyAction;
+};
+/**
+ * Index options for migration APIs.
+ */
+export type CreateIndexOptions = NamedConstraintOptions & Omit<IndexDefinition, 'table' | 'name' | 'columns'> & {
+    ifNotExists?: boolean;
+};
+/**
+ * Builder API available inside `schema.alterTable(name, table => ...)`.
+ */
+export interface AlterTableBuilder {
+    /** Adds a column during an `alterTable` migration. */
+    addColumn(name: string, definition: ColumnDefinition | ColumnBuilder): void;
+    /** Changes an existing column during an `alterTable` migration. */
+    changeColumn(name: string, definition: ColumnDefinition | ColumnBuilder): void;
+    /** Renames a column during an `alterTable` migration. */
+    renameColumn(from: string, to: string): void;
+    /** Drops a column during an `alterTable` migration. */
+    dropColumn(name: string, options?: {
+        ifExists?: boolean;
+    }): void;
+    /** Adds a primary key during an `alterTable` migration. */
+    addPrimaryKey(columns: KeyColumns, options?: NamedConstraintOptions): void;
+    /** Drops a primary key during an `alterTable` migration. */
+    dropPrimaryKey(name: string): void;
+    /** Adds a unique constraint during an `alterTable` migration. */
+    addUnique(columns: KeyColumns, options?: NamedConstraintOptions): void;
+    /** Drops a unique constraint during an `alterTable` migration. */
+    dropUnique(name: string): void;
+    /** Adds a foreign key during an `alterTable` migration. */
+    addForeignKey(columns: KeyColumns, refTable: TableInput, refColumns?: KeyColumns, options?: ForeignKeyOptions): void;
+    /** Drops a foreign key during an `alterTable` migration. */
+    dropForeignKey(name: string): void;
+    /** Adds a check constraint during an `alterTable` migration. */
+    addCheck(expression: string, options?: NamedConstraintOptions): void;
+    /** Drops a check constraint during an `alterTable` migration. */
+    dropCheck(name: string): void;
+    /** Adds an index during an `alterTable` migration. */
+    addIndex(columns: IndexColumns, options?: CreateIndexOptions): void;
+    /** Drops an index during an `alterTable` migration. */
+    dropIndex(name: string): void;
+    /** Sets the table comment during an `alterTable` migration. */
+    comment(text: string): void;
+}
+/**
+ * DDL-focused operations mixed into the migration `db` object.
+ */
+export interface MigrationSchema {
+    /** Creates a table in the migration schema. */
+    createTable<table extends AnyTable>(table: table, options?: CreateTableOptions): Promise<void>;
+    /** Alters an existing table in the migration schema. */
+    alterTable(table: TableInput, migrate: (table: AlterTableBuilder) => void, options?: AlterTableOptions): Promise<void>;
+    /** Renames a table in the migration schema. */
+    renameTable(from: TableInput, to: string): Promise<void>;
+    /** Drops a table from the migration schema. */
+    dropTable(table: TableInput, options?: DropTableOptions): Promise<void>;
+    /** Creates an index in the migration schema. */
+    createIndex(table: TableInput, columns: IndexColumns, options?: CreateIndexOptions): Promise<void>;
+    /** Drops an index from the migration schema. */
+    dropIndex(table: TableInput, name: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /** Renames an index in the migration schema. */
+    renameIndex(table: TableInput, from: string, to: string): Promise<void>;
+    /** Adds a foreign key in the migration schema. */
+    addForeignKey(table: TableInput, columns: KeyColumns, refTable: TableInput, refColumns?: KeyColumns, options?: ForeignKeyOptions): Promise<void>;
+    /** Drops a foreign key in the migration schema. */
+    dropForeignKey(table: TableInput, name: string): Promise<void>;
+    /** Adds a check constraint in the migration schema. */
+    addCheck(table: TableInput, expression: string, options?: NamedConstraintOptions): Promise<void>;
+    /** Drops a check constraint in the migration schema. */
+    dropCheck(table: TableInput, name: string): Promise<void>;
+    /**
+     * Adds raw SQL to the migration plan as a migration operation.
+     */
+    plan(sql: string | SqlStatement): Promise<void>;
+    /**
+     * Returns `true` when the table exists in the current database.
+     */
+    hasTable(table: TableInput): Promise<boolean>;
+    /**
+     * Returns `true` when the column exists on the given table.
+     */
+    hasColumn(table: TableInput, column: string): Promise<boolean>;
+}
+/**
+ * Runtime-agnostic migration registry abstraction.
+ */
+export type MigrationRegistry = {
+    register(migration: MigrationDescriptor): void;
+    list(): MigrationDescriptor[];
+};
+/**
+ * Options for creating a migration runner.
+ */
+export type MigrationRunnerOptions = {
+    /**
+     * Journal table used to record applied migrations.
+     * Defaults to `data_table_migrations`.
+     */
+    journalTable?: string;
+};
+/**
+ * Migration runner API for applying, reverting, and inspecting migration state.
+ */
+export type MigrationRunner = {
+    up(options?: MigrateOptions): Promise<MigrateResult>;
+    down(options?: MigrateOptions): Promise<MigrateResult>;
+    status(): Promise<MigrationStatusEntry[]>;
+};
+//# sourceMappingURL=migrations.d.ts.map