@momentumcms/migrations 0.3.0

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@momentumcms/migrations",
+  "version": "0.3.0",
+  "description": "Database migration system for Momentum CMS",
+  "license": "MIT",
+  "main": "./index.cjs",
+  "types": "./src/index.d.ts",
+  "peerDependencies": {
+    "@momentumcms/core": ">=0.0.1",
+    "pg": "^8.0.0"
+  },
+  "module": "./index.js"
+}

package/src/cli/generate.d.ts

@@ -0,0 +1 @@
+export {};

package/src/cli/rollback.d.ts

@@ -0,0 +1 @@
+export {};

package/src/cli/run.d.ts

@@ -0,0 +1 @@
+export {};

package/src/cli/shared.d.ts

@@ -0,0 +1,57 @@
+import type { ResolvedMomentumConfig, DatabaseAdapter } from '@momentumcms/core';
+import type { DatabaseDialect } from '../lib/schema/column-type-map';
+import type { TrackerQueryFn } from '../lib/tracking/migration-tracker';
+import type { MigrationContext } from '../lib/migration.types';
+import type { PushRunnerDb } from '../lib/runner/push-runner';
+import type { CloneCapableDb } from '../lib/runner/clone-test-apply';
+import type { DatabaseSchemaSnapshot } from '../lib/schema/schema-snapshot';
+/**
+ * Load a MomentumConfig from a file path using dynamic import.
+ */
+export declare function loadMomentumConfig(configPath: string): Promise<ResolvedMomentumConfig>;
+/**
+ * Resolve the database dialect from an adapter.
+ * Throws if the adapter doesn't declare its dialect.
+ */
+export declare function resolveDialect(adapter: DatabaseAdapter): DatabaseDialect;
+/**
+ * Bridge a DatabaseAdapter to TrackerQueryFn.
+ */
+export declare function buildTrackerFromAdapter(adapter: DatabaseAdapter): TrackerQueryFn;
+/**
+ * Bridge a DatabaseAdapter to MigrationContext.
+ */
+export declare function buildContextFromAdapter(adapter: DatabaseAdapter, dialect: DatabaseDialect): MigrationContext;
+/**
+ * Bridge a DatabaseAdapter to PushRunnerDb.
+ */
+export declare function buildPushDbFromAdapter(adapter: DatabaseAdapter): PushRunnerDb;
+/**
+ * Bridge a DatabaseAdapter to CloneCapableDb.
+ */
+export declare function buildCloneDbFromAdapter(adapter: DatabaseAdapter): CloneCapableDb;
+/**
+ * Build an introspection function from a DatabaseAdapter.
+ */
+export declare function buildIntrospector(adapter: DatabaseAdapter, dialect: DatabaseDialect): () => Promise<DatabaseSchemaSnapshot>;
+/**
+ * Parsed CLI arguments for migration commands.
+ */
+export interface MigrationCliArgs {
+    /** Path to momentum.config.ts */
+    configPath: string;
+    /** Migration name (for generate) */
+    name?: string;
+    /** Dry run — show changes without writing files */
+    dryRun?: boolean;
+    /** Test only — run clone test but don't apply to real DB */
+    testOnly?: boolean;
+    /** Skip clone test safety pipeline */
+    skipCloneTest?: boolean;
+}
+/**
+ * Parse CLI arguments for migration commands.
+ *
+ * Usage: npx tsx <command>.ts <configPath> [--name <name>] [--dry-run] [--test-only] [--skip-clone-test]
+ */
+export declare function parseMigrationArgs(args: string[]): MigrationCliArgs;

package/src/cli/status.d.ts

@@ -0,0 +1 @@
+export {};

package/src/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @momentumcms/migrations
+ *
+ * Database migration system for Momentum CMS.
+ * Provides schema introspection, diffing, generation, and execution.
+ */
+export * from './lib/schema/schema-snapshot';
+export * from './lib/schema/column-type-map';
+export { introspectPostgres } from './lib/schema/introspect-postgres';
+export type { QueryFunction } from './lib/schema/introspect-postgres';
+export { introspectSqlite } from './lib/schema/introspect-sqlite';
+export type { SqliteQueryFunction } from './lib/schema/introspect-sqlite';
+export { collectionToTableSnapshot, collectionsToSchema } from './lib/schema/collections-to-schema';
+export { diffSchemas } from './lib/schema/schema-diff';
+export type { SchemaDiffOptions, SchemaDiffResult } from './lib/schema/schema-diff';
+export * from './lib/operations/operation.types';
+export { operationToSql, operationToReverseSql, operationsToUpSql, operationsToDownSql, } from './lib/generator/sql-generator';
+export { generateMigrationName, generateMigrationFileContent, } from './lib/generator/migration-file-generator';
+export type { GenerateMigrationOptions } from './lib/generator/migration-file-generator';
+export { ensureTrackingTable, getAppliedMigrations, getNextBatchNumber, recordMigration, removeMigrationRecord, getMigrationsByBatch, getLatestBatchNumber, isMigrationApplied, } from './lib/tracking/migration-tracker';
+export type { TrackerQueryFn } from './lib/tracking/migration-tracker';
+export { detectDangers } from './lib/danger/danger-detector';
+export type { DangerSeverity, DangerWarning, DangerDetectionResult, } from './lib/danger/danger-detector';
+export { runPush } from './lib/runner/push-runner';
+export type { PushRunnerDb, PushRunnerOptions, PushResult } from './lib/runner/push-runner';
+export { runMigrations, rollbackBatch, getMigrationStatus } from './lib/runner/migrate-runner';
+export type { LoadedMigration, MigrationRunResult, MigrateResult, MigrateRunnerOptions, MigrationStatusEntry, } from './lib/runner/migrate-runner';
+export { cloneTestApply } from './lib/runner/clone-test-apply';
+export type { CloneCapableDb, CloneTestApplyOptions, CloneTestApplyResult, } from './lib/runner/clone-test-apply';
+export { createDataHelpers } from './lib/helpers/data-helpers';
+export type { DataHelperDb } from './lib/helpers/data-helpers';
+export { loadMigrationsFromDisk } from './lib/loader/migration-loader';
+export { readSnapshot, writeSnapshot, getSnapshotPath } from './lib/loader/snapshot-manager';
+export { resolveDialect, buildTrackerFromAdapter, buildContextFromAdapter, buildPushDbFromAdapter, buildCloneDbFromAdapter, buildIntrospector, parseMigrationArgs, } from './cli/shared';
+export type { MigrationCliArgs } from './cli/shared';
+export * from './lib/migration.types';

package/src/lib/danger/danger-detector.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Dangerous Operation Detection
+ *
+ * Inspired by Rails' strong_migrations, analyzes migration operations
+ * for patterns that could cause data loss, downtime, or failures.
+ *
+ * Each danger has a severity, a human-readable message, and a suggested fix.
+ */
+import type { MigrationOperation } from '../operations/operation.types';
+import type { DatabaseDialect } from '../schema/column-type-map';
+/**
+ * Severity levels for dangerous operations.
+ */
+export type DangerSeverity = 'error' | 'warning' | 'info';
+/**
+ * A detected dangerous operation.
+ */
+export interface DangerWarning {
+    /** Severity of the issue */
+    severity: DangerSeverity;
+    /** Which operation triggered this warning */
+    operation: MigrationOperation;
+    /** The index of the operation in the operations array */
+    operationIndex: number;
+    /** Human-readable description of the danger */
+    message: string;
+    /** Suggested alternative or fix */
+    suggestion: string;
+}
+/**
+ * Result of danger detection.
+ */
+export interface DangerDetectionResult {
+    /** All detected warnings, ordered by severity (errors first) */
+    warnings: DangerWarning[];
+    /** Whether any errors were found (should block migration) */
+    hasErrors: boolean;
+    /** Whether any warnings were found */
+    hasWarnings: boolean;
+}
+/**
+ * Analyze migration operations for dangerous patterns.
+ */
+export declare function detectDangers(operations: MigrationOperation[], dialect: DatabaseDialect): DangerDetectionResult;

package/src/lib/generator/migration-file-generator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Migration File Generator
+ *
+ * Produces TypeScript migration file content from a SchemaDiffResult.
+ * These files implement the MigrationFile interface (meta, up, down).
+ */
+import type { SchemaDiffResult } from '../schema/schema-diff';
+import type { DatabaseDialect } from '../schema/column-type-map';
+/**
+ * Options for generating a migration file.
+ */
+export interface GenerateMigrationOptions {
+    /** Migration name (used as filename and in meta) */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Database dialect for SQL generation */
+    dialect: DatabaseDialect;
+}
+/**
+ * Generate a timestamp-prefixed migration name.
+ * Format: YYYYMMDDHHMMSS_name
+ */
+export declare function generateMigrationName(name: string, timestamp?: Date): string;
+/**
+ * Generate the TypeScript content for a migration file.
+ */
+export declare function generateMigrationFileContent(diff: SchemaDiffResult, options: GenerateMigrationOptions): string;

package/src/lib/generator/sql-generator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SQL Generator
+ *
+ * Converts MigrationOperations into raw SQL strings for a given dialect.
+ * Used by both the migration file generator and the push-mode runner.
+ */
+import type { MigrationOperation } from '../operations/operation.types';
+import type { DatabaseDialect } from '../schema/column-type-map';
+/**
+ * Generate SQL for a single migration operation.
+ */
+export declare function operationToSql(op: MigrationOperation, dialect: DatabaseDialect): string;
+/**
+ * Generate SQL for the reverse (down) of an operation.
+ */
+export declare function operationToReverseSql(op: MigrationOperation, dialect: DatabaseDialect): string | null;
+/**
+ * Generate all up SQL statements for a set of operations.
+ */
+export declare function operationsToUpSql(operations: MigrationOperation[], dialect: DatabaseDialect): string[];
+/**
+ * Generate all down SQL statements for a set of operations (in reverse order).
+ */
+export declare function operationsToDownSql(operations: MigrationOperation[], dialect: DatabaseDialect): string[];

package/src/lib/helpers/data-helpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Data Migration Helpers
+ *
+ * Provides batched, safe data transformation operations for use
+ * within migration up/down functions via MigrationContext.data.
+ */
+import type { DataMigrationHelpers } from '../migration.types';
+import type { DatabaseDialect } from '../schema/column-type-map';
+/**
+ * Database interface needed by data helpers.
+ */
+export interface DataHelperDb {
+    execute(sql: string, params?: unknown[]): Promise<number>;
+    query<T extends Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+}
+/**
+ * Create a DataMigrationHelpers instance bound to a database.
+ */
+export declare function createDataHelpers(db: DataHelperDb, dialect: DatabaseDialect): DataMigrationHelpers;

package/src/lib/loader/migration-loader.d.ts

@@ -0,0 +1,11 @@
+import type { LoadedMigration } from '../runner/migrate-runner';
+/**
+ * Load all migration files from a directory.
+ *
+ * Scans for `.ts` files matching the YYYYMMDDHHMMSS_name.ts pattern,
+ * dynamically imports each one, validates the exports, and returns
+ * them sorted by filename (timestamp prefix ensures correct order).
+ *
+ * @returns Sorted array of loaded migrations (empty if directory is missing/empty)
+ */
+export declare function loadMigrationsFromDisk(directory: string): Promise<LoadedMigration[]>;

package/src/lib/loader/snapshot-manager.d.ts

@@ -0,0 +1,15 @@
+import type { DatabaseSchemaSnapshot } from '../schema/schema-snapshot';
+/**
+ * Read the schema snapshot from the migrations directory.
+ * Returns null if no snapshot file exists.
+ */
+export declare function readSnapshot(directory: string): DatabaseSchemaSnapshot | null;
+/**
+ * Write a schema snapshot to the migrations directory.
+ * Creates the directory if it doesn't exist.
+ */
+export declare function writeSnapshot(directory: string, snapshot: DatabaseSchemaSnapshot): void;
+/**
+ * Get the full path to the snapshot file.
+ */
+export declare function getSnapshotPath(directory: string): string;

package/src/lib/migration.types.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Migration System Core Types
+ *
+ * Defines the migration file interface, context, and tracking types.
+ */
+import type { DatabaseDialect } from './schema/column-type-map';
+/**
+ * Helpers for data transformations within migrations.
+ */
+export interface DataMigrationHelpers {
+    /**
+     * Backfill a column with a static value.
+     * Uses batched updates to avoid long-running transactions.
+     */
+    backfill(table: string, column: string, value: unknown, options?: {
+        where?: string;
+        batchSize?: number;
+    }): Promise<number>;
+    /**
+     * Transform values in a column using a SQL expression.
+     * @example transform('posts', 'slug', "LOWER(REPLACE(title, ' ', '-'))")
+     */
+    transform(table: string, column: string, sqlExpression: string, options?: {
+        where?: string;
+        batchSize?: number;
+    }): Promise<number>;
+    /**
+     * Safe column rename: add new column, copy data, drop old column.
+     * Safer than ALTER TABLE RENAME COLUMN for production.
+     */
+    renameColumn(table: string, from: string, to: string, columnType: string): Promise<void>;
+    /**
+     * Split a column into multiple columns via SQL expressions.
+     */
+    splitColumn(table: string, sourceColumn: string, targets: Array<{
+        name: string;
+        type: string;
+        expression: string;
+    }>): Promise<void>;
+    /**
+     * Merge multiple columns into one.
+     */
+    mergeColumns(table: string, sourceColumns: string[], targetColumn: string, targetType: string, mergeExpression: string): Promise<void>;
+    /**
+     * Copy data between tables with optional transformation.
+     */
+    copyData(sourceTable: string, targetTable: string, columnMapping: Record<string, string | {
+        expression: string;
+    }>, options?: {
+        where?: string;
+        batchSize?: number;
+    }): Promise<number>;
+    /**
+     * Move a flat column's data into a JSONB field.
+     */
+    columnToJson(table: string, sourceColumn: string, jsonColumn: string, jsonKey: string): Promise<void>;
+    /**
+     * Extract a key from a JSONB column into a new flat column.
+     */
+    jsonToColumn(table: string, jsonColumn: string, jsonKey: string, targetColumn: string, targetType: string): Promise<void>;
+    /**
+     * Deduplicate rows before adding a unique constraint.
+     * Keeps the row based on the chosen strategy.
+     * @returns Number of rows deleted
+     */
+    dedup(table: string, columns: string[], keepStrategy?: 'latest' | 'earliest' | 'first'): Promise<number>;
+}
+/**
+ * Context passed to migration up/down functions.
+ */
+export interface MigrationContext {
+    /** Execute raw SQL (DDL or DML) */
+    sql(query: string, params?: unknown[]): Promise<void>;
+    /** Query raw SQL and return rows */
+    query<T extends Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+    /** Data migration helpers */
+    data: DataMigrationHelpers;
+    /** Current database dialect */
+    dialect: DatabaseDialect;
+    /** Logger */
+    log: {
+        info(message: string): void;
+        warn(message: string): void;
+    };
+}
+/**
+ * Metadata for a migration file.
+ */
+export interface MigrationMeta {
+    /** Migration name (filename without extension) */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** Operations this migration will apply (for danger detection) */
+    operations?: ReadonlyArray<{
+        type: string;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * A migration file's exports.
+ */
+export interface MigrationFile {
+    /** Migration metadata */
+    meta: MigrationMeta;
+    /** Apply the migration */
+    up(ctx: MigrationContext): Promise<void>;
+    /** Revert the migration */
+    down(ctx: MigrationContext): Promise<void>;
+}
+/**
+ * Internal tracking record for an applied migration.
+ * Stored in the _momentum_migrations table.
+ */
+export interface MigrationTrackingRecord {
+    /** Auto-generated UUID primary key */
+    id: string;
+    /** Migration name (matches filename without extension) */
+    name: string;
+    /** Batch number (migrations applied together share a batch) */
+    batch: number;
+    /** SHA-256 checksum of the migration file content */
+    checksum: string;
+    /** When the migration was applied (ISO string) */
+    appliedAt: string;
+    /** Execution time in milliseconds */
+    executionMs: number;
+}
+/**
+ * Slug for the internal migration tracking table.
+ */
+export declare const MIGRATION_TRACKING_TABLE = "_momentum_migrations";

package/src/lib/operations/operation.types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Migration Operation Types
+ *
+ * Represents all possible schema change operations.
+ * Generated by the diff engine, consumed by migration file generator and runner.
+ */
+export interface CreateTableOperation {
+    readonly type: 'createTable';
+    readonly table: string;
+    readonly columns: ReadonlyArray<{
+        name: string;
+        type: string;
+        nullable: boolean;
+        defaultValue?: string;
+        primaryKey?: boolean;
+    }>;
+}
+export interface DropTableOperation {
+    readonly type: 'dropTable';
+    readonly table: string;
+}
+export interface RenameTableOperation {
+    readonly type: 'renameTable';
+    readonly from: string;
+    readonly to: string;
+}
+export interface AddColumnOperation {
+    readonly type: 'addColumn';
+    readonly table: string;
+    readonly column: string;
+    readonly columnType: string;
+    readonly nullable: boolean;
+    readonly defaultValue?: string;
+}
+export interface DropColumnOperation {
+    readonly type: 'dropColumn';
+    readonly table: string;
+    readonly column: string;
+    /** Previous type, for generating down() */
+    readonly previousType?: string;
+    readonly previousNullable?: boolean;
+}
+export interface AlterColumnTypeOperation {
+    readonly type: 'alterColumnType';
+    readonly table: string;
+    readonly column: string;
+    readonly fromType: string;
+    readonly toType: string;
+    /** Optional USING clause for PostgreSQL type casts */
+    readonly castExpression?: string;
+}
+export interface AlterColumnNullableOperation {
+    readonly type: 'alterColumnNullable';
+    readonly table: string;
+    readonly column: string;
+    readonly nullable: boolean;
+}
+export interface AlterColumnDefaultOperation {
+    readonly type: 'alterColumnDefault';
+    readonly table: string;
+    readonly column: string;
+    readonly defaultValue: string | null;
+    readonly previousDefault: string | null;
+}
+export interface RenameColumnOperation {
+    readonly type: 'renameColumn';
+    readonly table: string;
+    readonly from: string;
+    readonly to: string;
+}
+export interface AddForeignKeyOperation {
+    readonly type: 'addForeignKey';
+    readonly table: string;
+    readonly constraintName: string;
+    readonly column: string;
+    readonly referencedTable: string;
+    readonly referencedColumn: string;
+    readonly onDelete: string;
+}
+export interface DropForeignKeyOperation {
+    readonly type: 'dropForeignKey';
+    readonly table: string;
+    readonly constraintName: string;
+}
+export interface CreateIndexOperation {
+    readonly type: 'createIndex';
+    readonly table: string;
+    readonly indexName: string;
+    readonly columns: readonly string[];
+    readonly unique: boolean;
+}
+export interface DropIndexOperation {
+    readonly type: 'dropIndex';
+    readonly table: string;
+    readonly indexName: string;
+}
+export interface RawSqlOperation {
+    readonly type: 'rawSql';
+    readonly upSql: string;
+    readonly downSql: string;
+    readonly description: string;
+}
+/**
+ * All possible migration operations.
+ */
+export type MigrationOperation = CreateTableOperation | DropTableOperation | RenameTableOperation | AddColumnOperation | DropColumnOperation | AlterColumnTypeOperation | AlterColumnNullableOperation | AlterColumnDefaultOperation | RenameColumnOperation | AddForeignKeyOperation | DropForeignKeyOperation | CreateIndexOperation | DropIndexOperation | RawSqlOperation;

package/src/lib/runner/clone-test-apply.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Clone-Test-Apply Pipeline
+ *
+ * The crown jewel of the migration system. This pipeline:
+ * 1. Clones the database
+ * 2. Runs migrations on the clone
+ * 3. Detects errors and generates fix suggestions
+ * 4. If clone succeeds, applies to real database
+ * 5. Cleans up the clone
+ *
+ * This ensures migrations are safe before touching production data.
+ */
+import type { MigrationContext } from '../migration.types';
+import type { DatabaseDialect } from '../schema/column-type-map';
+import type { TrackerQueryFn } from '../tracking/migration-tracker';
+import type { LoadedMigration, MigrateResult } from './migrate-runner';
+import type { DangerDetectionResult } from '../danger/danger-detector';
+/**
+ * Database interface needed for clone operations.
+ */
+export interface CloneCapableDb {
+    /** Clone the database to a new instance */
+    cloneDatabase(targetName: string): Promise<string>;
+    /** Drop a cloned database */
+    dropClone(targetName: string): Promise<void>;
+}
+/**
+ * Options for the clone-test-apply pipeline.
+ */
+export interface CloneTestApplyOptions {
+    /** All loaded migrations, in order */
+    migrations: LoadedMigration[];
+    /** Database dialect */
+    dialect: DatabaseDialect;
+    /** Tracker for the real database */
+    tracker: TrackerQueryFn;
+    /** Build a MigrationContext for the real database */
+    buildContext: () => MigrationContext;
+    /** Clone-capable database interface */
+    db: CloneCapableDb;
+    /** Build a TrackerQueryFn for the cloned database */
+    buildCloneTracker: (cloneName: string) => TrackerQueryFn;
+    /** Build a MigrationContext for the cloned database */
+    buildCloneContext: (cloneName: string) => MigrationContext;
+    /** If true, skip applying to real DB after clone test */
+    testOnly?: boolean;
+    /** If true, skip danger detection */
+    skipDangerDetection?: boolean;
+    /** Logger */
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+/**
+ * Result of the clone-test-apply pipeline.
+ */
+export interface CloneTestApplyResult {
+    /** Phase that was reached */
+    phase: 'clone' | 'test' | 'apply' | 'complete' | 'skipped';
+    /** Result from running migrations on the clone */
+    cloneResult: MigrateResult | null;
+    /** Result from running migrations on the real database */
+    applyResult: MigrateResult | null;
+    /** Danger detection result */
+    dangers: DangerDetectionResult | null;
+    /** Whether the clone was cleaned up */
+    cloneCleanedUp: boolean;
+    /** Name of the clone database (for debugging) */
+    cloneName: string;
+    /** Error that caused the pipeline to stop */
+    error?: string;
+    /** Suggested fixes if the clone test failed */
+    suggestions: string[];
+}
+/**
+ * Run the clone-test-apply pipeline.
+ */
+export declare function cloneTestApply(options: CloneTestApplyOptions): Promise<CloneTestApplyResult>;

package/src/lib/runner/migrate-runner.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Migrate Mode Runner
+ *
+ * Runs migration files in order, tracking which have been applied.
+ * Supports forward migration, rollback by batch, and status checking.
+ */
+import type { MigrationFile, MigrationContext } from '../migration.types';
+import type { DatabaseDialect } from '../schema/column-type-map';
+import type { TrackerQueryFn } from '../tracking/migration-tracker';
+import type { DangerDetectionResult } from '../danger/danger-detector';
+/**
+ * A loaded migration with its file content.
+ */
+export interface LoadedMigration {
+    /** Migration name (filename without extension) */
+    name: string;
+    /** The migration file exports */
+    file: MigrationFile;
+}
+/**
+ * Result of running a single migration.
+ */
+export interface MigrationRunResult {
+    name: string;
+    success: boolean;
+    executionMs: number;
+    error?: string;
+    /** SQLSTATE error code from the database driver (e.g., '23505' for unique_violation) */
+    errorCode?: string;
+}
+/**
+ * Result of running all pending migrations.
+ */
+export interface MigrateResult {
+    /** Batch number assigned to these migrations */
+    batch: number;
+    /** Results for each migration that was run */
+    results: MigrationRunResult[];
+    /** Number of successful migrations */
+    successCount: number;
+    /** Number of failed migrations */
+    failCount: number;
+    /** Danger detection result (null if skipped) */
+    dangers: DangerDetectionResult | null;
+}
+/**
+ * Options for the migrate runner.
+ */
+export interface MigrateRunnerOptions {
+    /** All loaded migrations, in order */
+    migrations: LoadedMigration[];
+    /** Database dialect */
+    dialect: DatabaseDialect;
+    /** Tracker DB interface */
+    tracker: TrackerQueryFn;
+    /** Build a MigrationContext for executing migrations */
+    buildContext: () => MigrationContext;
+    /** If true, skip danger detection */
+    skipDangerDetection?: boolean;
+    /** Logger */
+    log?: {
+        info(msg: string): void;
+        warn(msg: string): void;
+    };
+}
+/**
+ * Run all pending migrations forward.
+ */
+export declare function runMigrations(options: MigrateRunnerOptions): Promise<MigrateResult>;
+/**
+ * Rollback the latest batch of migrations.
+ */
+export declare function rollbackBatch(options: MigrateRunnerOptions): Promise<MigrateResult>;
+/**
+ * Get migration status: which are applied, which are pending.
+ */
+export interface MigrationStatusEntry {
+    name: string;
+    status: 'applied' | 'pending';
+    batch?: number;
+    appliedAt?: string;
+}
+export declare function getMigrationStatus(migrations: LoadedMigration[], tracker: TrackerQueryFn, dialect: DatabaseDialect): Promise<MigrationStatusEntry[]>;