@vibeorm/migrate 1.3.1 → 2.0.0-alpha.2

package/dist/runner.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Migration runner: generate named migrations from IR diffs, apply them with
+ * bookkeeping in `_vibe_migrations`, report status, and repair records.
+ *
+ * Concurrency: `applyMigrations` takes an advisory lock for the whole run —
+ * `pg_advisory_lock(1447645253)` on postgres ("VIBE" in ASCII, blocking,
+ * released in a finally), `GET_LOCK('vibeorm_migrate', 60)` on mysql (throws
+ * VIBE_MIGRATION on timeout). sqlite needs none: it is single-writer and
+ * `BEGIN` serializes. Locks are session-scoped — the SqlExecutor contract
+ * (types.ts) requires one session for the whole operation.
+ *
+ * Execution strategy per dialect (`DIALECT_CAPABILITIES[dialect]`):
+ *
+ * - transactionalDdl (postgres, sqlite): each migration runs inside
+ *   BEGIN/COMMIT with its bookkeeping INSERT — atomic. EXCEPT sqlite scripts
+ *   containing a table-rebuild block, which manage their own transactions
+ *   (execute.ts `usesSelfManagedTransactions`); those run unwrapped and are
+ *   re-runnable (the rebuild recipe is effectively idempotent), with the
+ *   record written after the script completes.
+ * - mysql (transactionalDdl: false — DDL auto-commits): the runner records
+ *   PER-STATEMENT progress instead. The row is inserted up front
+ *   (statement_index 0), advanced after every statement, and on failure the
+ *   error lands in the `error` column. Re-running RESUMES from the recorded
+ *   statement_index — and REFUSES if the migration's checksum changed since
+ *   the partial application. A row is "complete" when its statement_index
+ *   reaches the statement count (or its checksum is empty — resolveMigration
+ *   records, which store statement_index 2147483647).
+ *
+ * Checksums (sha256 over the joined SQL) pin a migration's content:
+ * re-applying a renamed-or-edited migration is a VIBE_MIGRATION error, never
+ * a silent divergence.
+ */
+import type { Dialect, SchemaIR, VibeExtension } from "@vibeorm/schema";
+import type { AppliedResult, MigrationFile, MigrationStatus, SqlExecutor } from "./types.ts";
+/** Name of the migrations bookkeeping table (skipped by introspection). */
+export declare const MIGRATIONS_TABLE_NAME: string;
+/** Create the bookkeeping table when missing. */
+export declare function ensureMigrationsTable(params: {
+    executor: SqlExecutor;
+    dialect?: Dialect;
+}): Promise<void>;
+/** sha256 hex over the migration's statements — its identity across runs. */
+export declare function migrationChecksum(params: {
+    sql: readonly string[];
+}): string;
+/**
+ * Diff two IRs and render a named migration for a dialect (postgres if
+ * omitted). `destructive` aggregates the steps' flags so callers can gate
+ * confirmation before applying.
+ */
+export declare function generateMigration(params: {
+    from: SchemaIR;
+    to: SchemaIR;
+    name: string;
+    /** Rendering dialect; postgres if omitted. */
+    dialect?: Dialect;
+    /** Configured extension instances — their artifacts land in the migration. */
+    extensions?: readonly VibeExtension[];
+}): MigrationFile;
+/**
+ * Apply migrations in order under an advisory lock (see module doc).
+ * Already-recorded migrations are checksum-verified and skipped; a mismatch
+ * throws VIBE_MIGRATION (a recorded migration whose SQL changed is
+ * corruption, not drift to paper over). On mysql, a partially-applied
+ * migration RESUMES from its recorded statement_index. Records created by
+ * `resolveMigration` (empty checksum) skip verification.
+ */
+export declare function applyMigrations(params: {
+    executor: SqlExecutor;
+    migrations: readonly MigrationFile[];
+    /** Execution dialect; postgres if omitted. */
+    dialect?: Dialect;
+}): Promise<AppliedResult>;
+/** Compare known migrations against the bookkeeping table. */
+export declare function migrationStatus(params: {
+    executor: SqlExecutor;
+    migrations: readonly MigrationFile[];
+    /** Bookkeeping dialect; postgres if omitted. */
+    dialect?: Dialect;
+}): Promise<MigrationStatus>;
+/**
+ * Repair the bookkeeping table without running SQL: mark a migration as
+ * `"applied"` (upsert its record; pass `checksum` to also pin its content —
+ * omitted, the record stores an empty checksum and later runs skip
+ * verification for it) or `"rolled-back"` (delete its record).
+ */
+export declare function resolveMigration(params: {
+    executor: SqlExecutor;
+    name: string;
+    as: "applied" | "rolled-back";
+    checksum?: string;
+    /** Bookkeeping dialect; postgres if omitted. */
+    dialect?: Dialect;
+}): Promise<void>;
+/**
+ * Roll back ONE applied migration by executing its `downSql` and deleting its
+ * bookkeeping row, under the same advisory lock as `applyMigrations`.
+ *
+ * Guards, in order: the migration must carry `downSql` (older migrations
+ * predate down-migration support), must be recorded as applied, and — when
+ * the record pins a checksum — its up SQL must still match (rolling back with
+ * drifted files would run a down that no longer mirrors what was applied).
+ *
+ * Dialect behavior mirrors apply: postgres/sqlite run the down inside
+ * BEGIN/COMMIT with the bookkeeping DELETE (atomic; sqlite rebuild scripts
+ * run unwrapped, see module doc). mysql DDL auto-commits, so progress is
+ * recorded per-statement in the existing `statement_index` column, NEGATIVE
+ * to mark the rollback direction: after k down statements, the row stores
+ * -(k+1). A failed mysql rollback resumes from the recorded statement on the
+ * next call; `applyMigrations` refuses a mid-rollback record. A partially
+ * APPLIED mysql migration cannot be rolled back — its down mirrors the full
+ * up; finish applying (apply resumes) or repair with `resolveMigration`.
+ */
+export declare function rollbackMigration(params: {
+    executor: SqlExecutor;
+    migration: MigrationFile;
+    /** Execution dialect; postgres if omitted. */
+    dialect?: Dialect;
+}): Promise<void>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAexE,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAI7F,2EAA2E;AAC3E,eAAO,MAAM,qBAAqB,EAAE,MAA2B,CAAC;AAsChE,iDAAiD;AACjD,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;AAED,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG,MAAM,CAE5E;AAID;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACxC,IAAI,EAAE,QAAQ,CAAC;IACf,EAAE,EAAE,QAAQ,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACvC,GAAG,aAAa,CA6BhB;AAID;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IACrC,8CAA8C;IAC9C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CAAC,aAAa,CAAC,CA6DzB;AAID,8DAA8D;AAC9D,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IACrC,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CAAC,eAAe,CAAC,CAqC3B;AAID;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAC7C,QAAQ,EAAE,WAAW,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,SAAS,GAAG,aAAa,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE;IAC9C,QAAQ,EAAE,WAAW,CAAC;IACtB,SAAS,EAAE,aAAa,CAAC;IACzB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsDhB"}

package/dist/sqlite-types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * SQLite column-type mapping (IR → storage class and back), comparison keys,
+ * default rendering/fingerprints, and the enum CHECK-constraint convention.
+ *
+ * dialect-matrix §2: sqlite columns use the four storage classes only —
+ * String/DateTime/Decimal/Json → TEXT, Boolean/Int/BigInt → INTEGER,
+ * Float → REAL, Bytes → BLOB. Enums are TEXT plus a named CHECK constraint
+ * (`CONSTRAINT "<table>_<column>_enum_<Enum>" CHECK ("<column>" IN (…))`) —
+ * the constraint NAME is the marker that lets introspection recover the enum's
+ * name, and the IN list recovers its values. Scalar lists are unsupported
+ * (refused by the differ; this module throws as the render-time backstop).
+ *
+ * THE TEXT AMBIGUITY, stated honestly: DateTime, Decimal and Json all live in
+ * TEXT, and Boolean/BigInt live in INTEGER — a pulled schema reports such
+ * columns as String/Int (there is no marker to say otherwise). Column
+ * comparison is therefore STORAGE-CLASS based on sqlite (`sqliteColumnTypeKey`
+ * compares what the database actually stores), so `diff(introspect(push(X)),
+ * X)` stays [] even though the introspected IR says String where X said
+ * DateTime.
+ */
+import type { FieldIR, ScalarType } from "@vibeorm/schema";
+import type { EnumIR } from "@vibeorm/schema";
+/** IR scalar → sqlite storage class. */
+export declare const SCALAR_TO_SQLITE: Readonly<Record<ScalarType, string>>;
+/** Render-time backstop for scalar-list columns (the differ refuses earlier). */
+export declare function refuseSqliteScalarList(params: {
+    field: FieldIR;
+}): never;
+/**
+ * Storage class for a column. Unsupported columns render their nativeType
+ * verbatim (fidelity over guessing); enums are TEXT (the CHECK is separate).
+ */
+export declare function sqliteStorageType(params: {
+    field: FieldIR;
+}): string;
+/**
+ * Comparison key for a column on sqlite: the STORAGE CLASS, not the IR type —
+ * String and DateTime are both `t:TEXT` because the database cannot tell them
+ * apart. Enum columns key on their VALUE LIST (`e:A|B`), never their name
+ * (the name only lives in our CHECK-constraint convention): adding an enum
+ * value changes the key and flows through `alterColumn` → table rebuild with
+ * the widened CHECK.
+ */
+export declare function sqliteColumnTypeKey(params: {
+    field: FieldIR;
+    enums: ReadonlyMap<string, EnumIR>;
+}): string;
+/**
+ * Default fingerprint on sqlite: postgres rules, except booleans compare as
+ * their INTEGER storage (`true` → `num:1`) — an introspected sqlite schema can
+ * only ever report `DEFAULT 1`, and the fingerprint must not churn on that.
+ */
+export declare function sqliteDefaultFingerprint(params: {
+    field: FieldIR;
+}): string | null;
+/**
+ * Render the `DEFAULT` expression for a field on sqlite, or `undefined` when
+ * the column takes none (app-level generators, autoincrement — which renders
+ * as `INTEGER PRIMARY KEY AUTOINCREMENT` instead). Booleans store as 1/0.
+ */
+export declare function sqliteDefaultSql(params: {
+    field: FieldIR;
+}): string | undefined;
+/**
+ * Name of the enum CHECK constraint for a column — the `_enum_` infix is the
+ * introspection marker that recovers the enum's name from `sqlite_master.sql`.
+ */
+export declare function sqliteEnumCheckName(params: {
+    table: string;
+    column: string;
+    enumName: string;
+}): string;
+/** One parsed enum CHECK constraint from a table's `sqlite_master.sql`. */
+export type ParsedEnumCheck = {
+    readonly column: string;
+    readonly enumName: string;
+    readonly values: readonly string[];
+};
+/**
+ * Recover enum columns from a table's `sqlite_master.sql` text. Only checks
+ * following OUR naming convention are recognized; foreign CHECK constraints
+ * are ignored (and — documented limitation — do not survive a table rebuild).
+ */
+export declare function parseSqliteEnumChecks(params: {
+    tableSql: string;
+}): ParsedEnumCheck[];
+//# sourceMappingURL=sqlite-types.d.ts.map

package/dist/sqlite-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-types.d.ts","sourceRoot":"","sources":["../src/sqlite-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAI9C,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAUjE,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,KAAK,CAMxE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAepE;AAID;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,GAAG,MAAM,CAWT;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAOlF;AAID;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAuB/E;AAID;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,MAAM,CAET;AAED,2EAA2E;AAC3E,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,CAAC;AAKF;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,eAAe,EAAE,CAYrF"}

package/dist/types.d.ts

@@ -0,0 +1,217 @@
+/**
+ * Public types of @vibeorm/migrate: the executor contract, the dialect-neutral
+ * migration step model, and the runner's file/result shapes.
+ *
+ * Steps carry Schema-IR fragments (FieldIR, EnumIR) — never SQL text. SQL is
+ * produced exclusively by the per-dialect renderers (ddl-postgres.ts), so every
+ * SQL-text decision stays reviewable in one place (constitution rule 3/4).
+ */
+import type { CascadeAction, EnumIR, FieldIR } from "@vibeorm/schema";
+/**
+ * Minimal SQL execution contract the migrate engine runs on. Structurally
+ * identical to @vibeorm/runtime's `SqlExecutor` (its `toSqlExecutor` bridges a
+ * DatabaseAdapter to this shape) — declared here so the dependency direction
+ * stays schema ← sql ← migrate.
+ *
+ * SESSION AFFINITY: the migrate engine issues session-scoped statements
+ * through this contract (BEGIN/COMMIT, `PRAGMA foreign_keys`, advisory locks
+ * `pg_advisory_lock` / `GET_LOCK`), so every call MUST hit the same database
+ * session. Single-connection adapters (pglite, sqlite) satisfy this by
+ * construction; pool-backed executors must pin one connection for the whole
+ * migrate operation.
+ */
+export type SqlExecutor = (params: {
+    text: string;
+    values?: unknown[];
+}) => Promise<Record<string, unknown>[]>;
+/** Which aspects of a column an `alterColumn` step changes. */
+export type AlterColumnAspect = "type" | "nullability" | "default";
+/** One column of an index, with its sort direction. */
+export type IndexColumn = {
+    readonly name: string;
+    readonly desc: boolean;
+    /**
+     * The field is a Decimal (SQLITE-2, SQL review round 2). Inert everywhere
+     * except the sqlite DDL renderer: Decimal stores as TEXT there and every
+     * compare/order site reads `CAST(col AS REAL)` (B4), which a plain-column
+     * index can never serve (EQP-proven SCAN) — sqlite renders an EXPRESSION
+     * index over the same cast instead. Not part of the index comparison key:
+     * both sides compare by column name + direction.
+     */
+    readonly decimal?: boolean;
+};
+/** One side of an implicit many-to-many join table. */
+export type JoinTableEnd = {
+    /** Referenced table (db name). */
+    readonly table: string;
+    /** Referenced primary-key column (db name). */
+    readonly column: string;
+    /** The referenced primary-key field — its type renders the join column's type. */
+    readonly field: FieldIR;
+};
+/**
+ * A dialect-neutral migration step produced by `diffSchemas`. `destructive`
+ * marks steps that can lose data (dropTable / dropJoinTable / dropColumn /
+ * dropEnum / narrowing type changes) — `push` refuses them without
+ * `acceptDataLoss`, and `generateMigration` surfaces the flag.
+ */
+export type MigrationStep = {
+    readonly kind: "createEnum";
+    readonly enumDef: EnumIR;
+    readonly destructive: false;
+} | {
+    readonly kind: "dropEnum";
+    readonly enumName: string;
+    readonly destructive: true;
+} | {
+    readonly kind: "addEnumValue";
+    readonly enumName: string;
+    readonly value: string;
+    readonly destructive: false;
+} | {
+    readonly kind: "createTable";
+    readonly table: string;
+    readonly columns: readonly FieldIR[];
+    /** Primary-key column db names (empty = no PK). */
+    readonly primaryKey: readonly string[];
+    readonly destructive: false;
+} | {
+    readonly kind: "dropTable";
+    readonly table: string;
+    readonly destructive: true;
+} | {
+    readonly kind: "addColumn";
+    readonly table: string;
+    readonly column: FieldIR;
+    readonly destructive: false;
+} | {
+    readonly kind: "dropColumn";
+    readonly table: string;
+    readonly column: string;
+    readonly destructive: true;
+} | {
+    readonly kind: "alterColumn";
+    readonly table: string;
+    /** Column db name. */
+    readonly column: string;
+    readonly from: FieldIR;
+    readonly to: FieldIR;
+    readonly changes: readonly AlterColumnAspect[];
+    readonly destructive: boolean;
+} | {
+    readonly kind: "createIndex";
+    readonly table: string;
+    readonly name: string;
+    /** IR index kind ("btree", "gin", …) — `unique` indexes are always btree. */
+    readonly indexKind: string;
+    readonly unique: boolean;
+    readonly columns: readonly IndexColumn[];
+    /** Partial-index predicate, raw SQL. */
+    readonly where?: string;
+    readonly destructive: false;
+} | {
+    readonly kind: "dropIndex";
+    readonly name: string;
+    /**
+     * Table the index belongs to. Optional for postgres/sqlite (their DROP
+     * INDEX is schema-global) but REQUIRED by the mysql renderer
+     * (`DROP INDEX … ON table`); the differ always fills it.
+     */
+    readonly table?: string;
+    readonly destructive: false;
+} | {
+    readonly kind: "addForeignKey";
+    readonly table: string;
+    readonly constraintName: string;
+    readonly columns: readonly string[];
+    readonly refTable: string;
+    readonly refColumns: readonly string[];
+    readonly onDelete: CascadeAction;
+    readonly onUpdate: CascadeAction;
+    readonly destructive: false;
+} | {
+    readonly kind: "dropForeignKey";
+    readonly table: string;
+    readonly constraintName: string;
+    readonly destructive: false;
+} | {
+    readonly kind: "createJoinTable";
+    readonly table: string;
+    readonly a: JoinTableEnd;
+    readonly b: JoinTableEnd;
+    readonly destructive: false;
+} | {
+    readonly kind: "dropJoinTable";
+    readonly table: string;
+    readonly destructive: true;
+} | {
+    readonly kind: "addPrimaryKey";
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly destructive: false;
+} | {
+    readonly kind: "dropPrimaryKey";
+    readonly table: string;
+    readonly destructive: false;
+} | {
+    /**
+     * Drop a view present in the live database but absent from the target
+     * schema (board #26). Ordered FIRST — postgres refuses dropping a column
+     * a leftover view depends on (2BP01), so removed views must go before
+     * the table/column changes they block. Destructive: the view definition
+     * is not stored in the IR, so the drop cannot be reversed.
+     */
+    readonly kind: "dropView";
+    /** View db name. */
+    readonly table: string;
+    readonly destructive: true;
+};
+/** One-line human description of a step (refusal messages, CLI output). */
+export declare function describeStep(params: {
+    step: MigrationStep;
+}): string;
+/** A named migration: ordered SQL statements plus its aggregate destructiveness. */
+export type MigrationFile = {
+    readonly name: string;
+    /** One SQL string per statement, in execution order. */
+    readonly sql: readonly string[];
+    /** True when any underlying step can lose data. */
+    readonly destructive: boolean;
+    /**
+     * Reverse statements (`down.sql`), when the migration carries them.
+     * Migrations generated before down-migration support have none —
+     * `rollbackMigration` refuses those with a clear error.
+     */
+    readonly downSql?: readonly string[];
+};
+/** Result of `applyMigrations`. */
+export type AppliedResult = {
+    /** Migrations executed by this call, in order. */
+    readonly applied: readonly string[];
+    /** Migrations already recorded and verified, skipped. */
+    readonly skipped: readonly string[];
+};
+/** Result of `migrationStatus`. */
+export type MigrationStatus = {
+    /** Recorded migrations whose checksum matches. */
+    readonly applied: readonly string[];
+    /** Migrations with no record yet. */
+    readonly pending: readonly string[];
+    /** Recorded migrations whose checksum no longer matches their SQL. */
+    readonly mismatched: readonly string[];
+    /**
+     * Migrations whose rollback started but did not finish (mysql only — its
+     * DDL is non-transactional, so `rollbackMigration` records per-statement
+     * progress). Re-run the rollback to resume, or repair with
+     * `resolveMigration`.
+     */
+    readonly rollingBack: readonly string[];
+};
+/** Result of `push`. */
+export type PushResult = {
+    /** The diff that was applied (empty = database already matched). */
+    readonly steps: readonly MigrationStep[];
+    /** The SQL statements that were executed, in order. */
+    readonly applied: readonly string[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAItE;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;CACpB,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;AAIzC,+DAA+D;AAC/D,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,aAAa,GAAG,SAAS,CAAC;AAEnE,uDAAuD;AACvD,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,uDAAuD;AACvD,MAAM,MAAM,YAAY,GAAG;IACzB,kCAAkC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kFAAkF;IAClF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;AAIF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GACrB;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;CAC5B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC;IACrC,mDAAmD;IACnD,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;CAC5B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;CAC5B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sBAAsB;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC/C,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,wCAAwC;IACxC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC;IACzB,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;CAC5B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC;CAC7B,GACD;IACE;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,oBAAoB;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC;CAC5B,CAAC;AAEN,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,GAAG,MAAM,CAsCpE;AAID,oFAAoF;AACpF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,mDAAmD;IACnD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC,CAAC;AAEF,mCAAmC;AACnC,MAAM,MAAM,aAAa,GAAG;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC,CAAC;AAEF,mCAAmC;AACnC,MAAM,MAAM,eAAe,GAAG;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,qCAAqC;IACrC,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC,CAAC;AAEF,wBAAwB;AACxB,MAAM,MAAM,UAAU,GAAG;IACvB,oEAAoE;IACpE,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IACzC,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC,CAAC"}

package/package.json

@@ -1,42 +1,52 @@
 {
   "name": "@vibeorm/migrate",
-  "version": "1.3.1",
-  "description": "Migration, introspection, and schema diff toolkit for VibeORM",
-  "license": "MIT",
+  "version": "2.0.0-alpha.2",
+  "description": "Migration engine for VibeORM v2 — IR differ, per-dialect DDL, migration runner, introspection",
   "keywords": [
     "orm",
-    "migrations",
-    "postgresql",
-    "bun",
     "typescript",
-    "introspection"
+    "sql",
+    "database",
+    "bun",
+    "type-safe",
+    "migrations",
+    "ddl",
+    "introspection",
+    "schema-diff",
+    "postgres",
+    "mysql",
+    "sqlite"
   ],
+  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/migrate#readme",
+  "bugs": {
+    "url": "https://github.com/vibeorm/vibeorm/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vibeorm/vibeorm.git",
+    "directory": "packages/migrate"
+  },
+  "license": "MIT",
+  "author": "VibeORM contributors",
   "type": "module",
   "exports": {
     ".": {
-      "default": "./src/index.ts",
-      "types": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "files": [
-    "src"
+    "dist",
+    "README.md"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/vibeorm/vibeorm.git",
-    "directory": "packages/migrate"
+  "engines": {
+    "bun": ">=1.2.0"
   },
-  "homepage": "https://github.com/vibeorm/vibeorm/tree/master/packages/migrate",
-  "bugs": {
-    "url": "https://github.com/vibeorm/vibeorm/issues"
+  "dependencies": {
+    "@vibeorm/schema": "2.0.0-alpha.1",
+    "@vibeorm/sql": "2.0.0-alpha.1"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "engines": {
-    "bun": ">=1.1.0"
-  },
-  "dependencies": {
-    "@vibeorm/parser": "1.3.1"
   }
 }

package/src/cascade-actions.ts

@@ -1,88 +0,0 @@
-/**
- * Cascade-action resolution and SQL serialisation.
- *
- * Translates a `CascadeAction` from the parser IR into a Postgres
- * `ON DELETE`/`ON UPDATE` clause, applying Prisma-compatible defaults when
- * the schema doesn't specify an action explicitly.
- *
- * Defaults (matching Prisma's Postgres behaviour):
- *   - `onDelete`: required FK → `Restrict`, optional FK → `SetNull`
- *   - `onUpdate`: always → `Cascade`
- */
-
-import type { CascadeAction, RelationField } from "@vibeorm/parser";
-
-const ACTION_TO_SQL: Record<CascadeAction, string> = {
-  Cascade: "CASCADE",
-  Restrict: "RESTRICT",
-  NoAction: "NO ACTION",
-  SetNull: "SET NULL",
-  SetDefault: "SET DEFAULT",
-};
-
-/**
- * Inverse of {@link ACTION_TO_SQL} — used by the introspector when reading
- * `pg_constraint.confdeltype`/`confupdtype`. The single-char codes are
- * Postgres's catalog representation.
- */
-export const PG_CHAR_TO_CASCADE_ACTION: Record<string, CascadeAction> = {
-  a: "NoAction",
-  r: "Restrict",
-  c: "Cascade",
-  n: "SetNull",
-  d: "SetDefault",
-};
-
-/**
- * Resolve the effective onDelete action for a relation, applying the Prisma
- * default when the schema didn't say anything explicit.
- *
- * `isRequired` is the FK column's nullability (Prisma's "required relation").
- */
-export function resolveOnDelete(params: {
-  explicit: CascadeAction | undefined;
-  isRequired: boolean;
-}): CascadeAction {
-  if (params.explicit) return params.explicit;
-  return params.isRequired ? "Restrict" : "SetNull";
-}
-
-/** Resolve the effective onUpdate action. Prisma's Postgres default is Cascade. */
-export function resolveOnUpdate(params: {
-  explicit: CascadeAction | undefined;
-}): CascadeAction {
-  return params.explicit ?? "Cascade";
-}
-
-/** Convenience: serialise a CascadeAction to its Postgres clause body. */
-export function cascadeActionSql(params: { action: CascadeAction }): string {
-  return ACTION_TO_SQL[params.action];
-}
-
-/**
- * Build the full `ON DELETE X ON UPDATE Y` clause for a relation field,
- * applying defaults as needed.
- */
-export function buildFkActionClause(params: { rel: RelationField }): string {
-  const { rel } = params;
-  const onDelete = resolveOnDelete({
-    explicit: rel.relation.onDelete,
-    isRequired: rel.isRequired,
-  });
-  const onUpdate = resolveOnUpdate({ explicit: rel.relation.onUpdate });
-  return `ON DELETE ${ACTION_TO_SQL[onDelete]} ON UPDATE ${ACTION_TO_SQL[onUpdate]}`;
-}
-
-/**
- * Stable comparison key for whether two relations have the same effective
- * cascade behaviour. Used by the differ to detect drift even when the schema
- * was written without explicit actions (defaults must still be considered).
- */
-export function fkActionFingerprint(params: { rel: RelationField }): string {
-  const onDelete = resolveOnDelete({
-    explicit: params.rel.relation.onDelete,
-    isRequired: params.rel.isRequired,
-  });
-  const onUpdate = resolveOnUpdate({ explicit: params.rel.relation.onUpdate });
-  return `${onDelete}|${onUpdate}`;
-}