@vibeorm/migrate 1.3.1 → 2.0.0-alpha.2

package/dist/introspect/mysql.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MySQL introspection: live database → SchemaIR, from
+ * `information_schema.{tables,views,columns,statistics,key_column_usage,
+ * referential_constraints}` (scoped to `DATABASE()`).
+ *
+ * Representation mirrors introspect/postgres.ts exactly (shared.ts carries
+ * the one relation/join-table rule). MySQL-specific decisions:
+ *
+ * - `COLUMN_TYPE` is the reverse-mapping source: `tinyint(1)` → Boolean (the
+ *   marker), `varchar(191)` → String, `enum('A','B')` → an enum whose values
+ *   are parsed from the type and whose NAME is synthesized as
+ *   `<Table>_<column>` — mysql enums are nameless, so the schema-declared
+ *   name is unrecoverable. The differ compares enum columns by VALUE LIST
+ *   (normalize.ts), so the synthetic names never produce phantom steps.
+ * - `EXTRA = auto_increment` → `@default(autoincrement())`;
+ *   `DEFAULT_GENERATED` expressions → `dbgenerated` (CURRENT_TIMESTAMP(…) →
+ *   `now` first).
+ * - Non-canonical column types keep `COLUMN_TYPE` in `nativeType`; unknown
+ *   types become `isUnsupported` fields (F3: keep, don't drop).
+ * - Indexes named like an FK constraint on the same table are SKIPPED: mysql
+ *   auto-creates them for FKs without a covering index, and surfacing them
+ *   would churn round-trips with phantom index steps.
+ * - The `_vibe_migrations` bookkeeping table is skipped.
+ */
+import type { SchemaIR } from "@vibeorm/schema";
+import type { SqlExecutor } from "../types.ts";
+/** Introspect a live mysql database (current schema) into SchemaIR. */
+export declare function introspectMysql(params: {
+    executor: SqlExecutor;
+}): Promise<SchemaIR>;
+//# sourceMappingURL=mysql.d.ts.map

package/dist/introspect/mysql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysql.d.ts","sourceRoot":"","sources":["../../src/introspect/mysql.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EASV,QAAQ,EACT,MAAM,iBAAiB,CAAC;AASzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA0G/C,uEAAuE;AACvE,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CA0K1F"}

package/dist/introspect/postgres.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Postgres / PGlite introspection: live database → SchemaIR.
+ *
+ * Representation contract (the differ's round-trip depends on it, LEARNINGS):
+ *
+ * - Type mapping is the REVERSE of dialect-matrix §2; `nativeType` is set only
+ *   when the column's type is NOT the canonical mapping for its scalar.
+ * - Identity columns and `nextval(...)` defaults → `@default(autoincrement())`.
+ * - Enum ARRAY columns (`data_type = 'ARRAY'`, `udt_name = '_EnumName'`) are
+ *   enum lists — never `String[]`.
+ * - Unknown column types (tsvector, geometry, …) become `isUnsupported` fields
+ *   with the raw type in `nativeType` — kept, not dropped.
+ * - FK/join-table representation comes from introspect/shared.ts — the ONE
+ *   structural rule every dialect introspector uses.
+ * - Views (`isView: true`) are returned with their columns only.
+ * - The `_vibe_migrations` bookkeeping table is skipped.
+ * - Hardcoded to the `public` schema (v1 parity).
+ */
+import type { SchemaIR } from "@vibeorm/schema";
+import type { SqlExecutor } from "../types.ts";
+/** Introspect a live postgres/pglite database (public schema) into SchemaIR. */
+export declare function introspectPostgres(params: {
+    executor: SqlExecutor;
+}): Promise<SchemaIR>;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/introspect/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../src/introspect/postgres.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAQV,QAAQ,EACT,MAAM,iBAAiB,CAAC;AASzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAsK/C,gFAAgF;AAChF,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAwK7F"}

package/dist/introspect/shared.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Introspection helpers shared by ALL dialect introspectors — the join-table
+ * detection rule and the relation/naming conventions live HERE, once
+ * (LEARNINGS: implicit-M2M conventions must never be re-implemented per
+ * consumer). Every dialect introspector produces the same representation:
+ *
+ * - FKs become an UNNAMED `manyToOne` on the owning model plus an UNNAMED
+ *   `oneToMany` list side on the target — EXCEPT when the model pair carries
+ *   more than one unnamed relation pair (mutual FKs, twin FKs to one target,
+ *   an FK alongside a default-named join table): those FK pairs get a
+ *   synthesized `@relation` name so `db pull` output re-parses (the parser
+ *   rejects the unnamed shape as `ambiguous-relation`) and implicit-M2M
+ *   detection keeps its name keys unique.
+ * - A table matching the implicit join-table shape (name `_X`, exactly columns
+ *   "A" and "B", two single-column FKs, a unique index on (A, B)) is NOT a
+ *   model: it becomes two unnamed `oneToMany` list sides on the joined models,
+ *   carrying `relationName` when the physical name differs from the default
+ *   `_AToB`.
+ */
+import type { CascadeAction, ModelIR } from "@vibeorm/schema";
+/** A grouped foreign key (composite-capable), dialect-independent. */
+export type FkGroup = {
+    readonly constraintName: string;
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly refTable: string;
+    readonly refColumns: readonly string[];
+    readonly onDelete: CascadeAction;
+    readonly onUpdate: CascadeAction;
+    /** Every FK column NOT NULL (drives isOptional on the relation). */
+    readonly required: boolean;
+};
+/** An introspected index in the shape join-table detection needs. */
+export type IntrospectedIndex = {
+    readonly table: string;
+    readonly name: string;
+    readonly unique: boolean;
+    readonly kind: string;
+    readonly columns: readonly {
+        readonly name: string;
+        readonly desc: boolean;
+    }[];
+    readonly where?: string;
+};
+/** A detected physical join table. */
+export type JoinTableInfo = {
+    readonly tableA: string;
+    readonly tableB: string;
+    readonly relationName?: string;
+};
+/**
+ * Detect whether a physical table is an implicit many-to-many join table:
+ * name starts with `_`, columns are exactly "A"/"B", two single-column FKs
+ * cover them, and a unique index spans (A, B). Purely structural — never
+ * reads relation types (round-trip stability, LEARNINGS).
+ */
+export declare function detectJoinTable(params: {
+    table: string;
+    columnNames: readonly string[];
+    fkGroups: readonly FkGroup[];
+    indexes: readonly IntrospectedIndex[];
+}): JoinTableInfo | null;
+/** Add manyToOne + inverse oneToMany relation pairs for every FK group. */
+export declare function addFkRelations(params: {
+    models: ModelIR[];
+    fkGroups: readonly FkGroup[];
+    joinTables: ReadonlyMap<string, JoinTableInfo>;
+}): void;
+/** Add the two unnamed oneToMany list sides for every detected join table. */
+export declare function addJoinTableRelations(params: {
+    models: ModelIR[];
+    joinTables: ReadonlyMap<string, JoinTableInfo>;
+}): void;
+/** Lower-case the first character (relation field names from table names). */
+export declare function lowerFirst(value: string): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/introspect/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/introspect/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAc,MAAM,iBAAiB,CAAC;AAI1E,sEAAsE;AACtE,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,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,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,qEAAqE;AACrE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;KAAE,EAAE,CAAC;IAC/E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,sCAAsC;AACtC,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC,CAAC;AAIF;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACvC,GAAG,aAAa,GAAG,IAAI,CA8BvB;AAID,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACrC,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAChD,GAAG,IAAI,CA+CP;AAED,8EAA8E;AAC9E,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAC5C,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAChD,GAAG,IAAI,CAuCP;AAmGD,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/introspect/sqlite.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SQLite introspection: live database → SchemaIR, from `sqlite_master` (table
+ * and index SQL text) plus `PRAGMA table_info / index_list / index_xinfo /
+ * foreign_key_list`.
+ *
+ * THE TEXT-TYPE AMBIGUITY, stated honestly: sqlite stores only the four
+ * storage classes we emit, so the reverse mapping is TEXT→String,
+ * INTEGER→Int, REAL→Float, BLOB→Bytes — ALWAYS. A DateTime/Decimal/Json
+ * column pulls back as String and a Boolean/BigInt as Int; there is no marker
+ * to recover the richer type. The differ compensates by comparing columns by
+ * storage class on sqlite (normalize.ts), so round-trips stay diff-clean.
+ * Two markers DO survive:
+ * - enums: our named CHECK constraints (`<table>_<column>_enum_<Enum>`)
+ *   recover both the enum's name and values;
+ * - autoincrement: the literal `PRIMARY KEY AUTOINCREMENT` text on a
+ *   single-column INTEGER PK.
+ * Any other declared type (VARCHAR(30), DATETIME, … from a foreign database)
+ * becomes an `isUnsupported` field with the raw type preserved in
+ * `nativeType` (F3: keep, don't drop).
+ *
+ * Representation mirrors introspect/postgres.ts exactly (shared.ts is the one
+ * relation/join-table rule): unnamed relation pairs, structural join-table
+ * detection, single-column uniques folded into `isUnique`, composite PKs on
+ * `model.primaryKey` (PK columns are never optional), views with columns
+ * only. Skipped: the `_vibe_migrations` table, `sqlite_*` internals
+ * (sqlite_sequence comes with AUTOINCREMENT), and expression indexes
+ * (index_xinfo reports no column name for them).
+ *
+ * Every row-returning query passes `values: []` — through `toSqlExecutor` a
+ * value-less text runs on the adapter's multi-statement batch path, which
+ * returns no rows (adapter-sqlite contract).
+ */
+import type { SchemaIR } from "@vibeorm/schema";
+import type { SqlExecutor } from "../types.ts";
+/** Introspect a live sqlite database into SchemaIR. */
+export declare function introspectSqlite(params: {
+    executor: SqlExecutor;
+}): Promise<SchemaIR>;
+/**
+ * Recover an expression index's column list from its `sqlite_master.sql`
+ * (SQLITE-2). Only shapes WE emit parse — plain quoted columns and
+ * `CAST("col" AS REAL)`, each with an optional direction; a trailing partial
+ * WHERE clause is fine (it sits OUTSIDE the column list — closure item 2).
+ * Anything else (other expressions, COLLATE clauses) returns null and the
+ * caller skips the index as before.
+ */
+export declare function parseIndexColumnsFromSql(params: {
+    sql: string | null;
+}): {
+    name: string;
+    desc: boolean;
+}[] | null;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/introspect/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/introspect/sqlite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAQV,QAAQ,EACT,MAAM,iBAAiB,CAAC;AAUzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAyB/C,uDAAuD;AACvD,wBAAsB,gBAAgB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAwH3F;AAwGD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAC/C,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,EAAE,GAAG,IAAI,CAqD3C"}

package/dist/mysql-types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * MySQL column-type mapping (IR → column type and back), native-type
+ * normalization, comparison keys and default rendering.
+ *
+ * dialect-matrix §2: String → varchar(191) by default (191 because
+ * utf8mb4 × 4 bytes keeps the column inside the 767-byte legacy index-key
+ * limit; `@db.Text` opts into TEXT, which we never index), Boolean →
+ * tinyint(1) (THE marker that lets introspection recover Boolean),
+ * Int → int, BigInt → bigint, Float → double, Decimal → decimal(65,30),
+ * DateTime → datetime(3), Json → json, Bytes → longblob, enums → inline
+ * `ENUM('A', 'B')` — nameless in the database, so comparison keys use the
+ * VALUE LIST (like sqlite) and a pulled schema synthesizes
+ * `<Table>_<column>` enum names. Scalar lists are unsupported.
+ */
+import type { EnumIR, FieldIR, ScalarType } from "@vibeorm/schema";
+/** IR scalar → canonical mysql column type (information_schema spelling). */
+export declare const SCALAR_TO_MYSQL: Readonly<Record<ScalarType, string>>;
+/** Render-time backstop for scalar-list columns (the differ refuses earlier). */
+export declare function refuseMysqlScalarList(params: {
+    field: FieldIR;
+}): never;
+/**
+ * Normalize a mysql type string for comparison: lowercase, whitespace
+ * stripped, base de-aliased, integer display widths dropped (mysql 8.0.19+
+ * omits them; older catalogs report `int(11)`) — EXCEPT `tinyint(1)`, which is
+ * the Boolean marker and must survive normalization.
+ */
+export declare function normalizeMysqlType(params: {
+    raw: string;
+}): string;
+/**
+ * Comparison key for a column on mysql. Enum columns key on their VALUE LIST
+ * (order-sensitive — mysql ENUM order defines sort order); a native type equal
+ * to the scalar's canonical mapping is dropped so `String` and
+ * `String @db.VarChar(191)` compare equal.
+ */
+export declare function mysqlColumnTypeKey(params: {
+    field: FieldIR;
+    enums: ReadonlyMap<string, EnumIR>;
+}): string;
+/**
+ * Default fingerprint on mysql: postgres rules verbatim — tinyint(1) lets the
+ * introspector map `DEFAULT '1'` back to a boolean literal, so booleans keep
+ * their `bool:` fingerprint (unlike sqlite).
+ */
+export declare function mysqlDefaultFingerprint(params: {
+    field: FieldIR;
+}): string | null;
+/** Render the mysql column type for a field (no NOT NULL, no default). */
+export declare function mysqlColumnTypeSql(params: {
+    field: FieldIR;
+    enums: ReadonlyMap<string, EnumIR>;
+}): string;
+/**
+ * Render the `DEFAULT` expression for a field on mysql, or `undefined` when
+ * the column takes none. `now()` renders `CURRENT_TIMESTAMP(3)` (precision
+ * must match the datetime(3) column); booleans store as 1/0.
+ */
+export declare function mysqlDefaultSql(params: {
+    field: FieldIR;
+}): string | undefined;
+/** Parse an information_schema `COLUMN_TYPE` of form `enum('A','B')`. */
+export declare function parseMysqlEnumColumnType(params: {
+    columnType: string;
+}): string[] | null;
+//# sourceMappingURL=mysql-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mysql-types.d.ts","sourceRoot":"","sources":["../src/mysql-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAMnE,6EAA6E;AAC7E,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAUhE,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,KAAK,CAMvE;AAaD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CASlE;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,GAAG,MAAM,CAgBT;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAEjF;AAID,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,GAAG,MAAM,CA8BT;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAuB9E;AAID,yEAAyE;AACzE,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,EAAE,GAAG,IAAI,CAQxF"}

package/dist/normalize.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Schema-IR normalization for diffing.
+ *
+ * Both sides of a diff (a parsed/DSL schema and an introspected one) collapse
+ * into the same normalized shape, so representation differences never produce
+ * phantom steps. The normalizations, each pinned by a differ test:
+ *
+ * - `@unique` on a field and a `kind: "unique"` model index are the same
+ *   unique index (the database stores both identically).
+ * - A single `@id` field and a single-field `@@id` are the same primary key.
+ * - Field names resolve to db names (`@map` / `@@map`) everywhere.
+ * - FK cascade actions resolve Prisma's defaults (required → Restrict,
+ *   optional → SetNull, onUpdate → Cascade) before comparing.
+ * - App-level defaults (uuid/cuid/nanoid/ulid) compare as "no database
+ *   default"; `isUpdatedAt` is app-level and ignored entirely.
+ * - Implicit M2M pairs collapse to their join table regardless of whether the
+ *   sides are parser `manyToMany` fields or introspected unnamed `oneToMany`
+ *   list sides (structural detection, LEARNINGS).
+ * - Views never join the table diff (migrate does not manage view DDL in this
+ *   wave) but ARE collected by db name, so the differ can emit DROP VIEW for
+ *   views the target schema no longer declares (board #26).
+ */
+import type { CascadeAction, Dialect, EnumIR, FieldIR, ModelIR, SchemaIR } from "@vibeorm/schema";
+import type { IndexColumn, JoinTableEnd } from "./types.ts";
+/** A column ready for comparison. */
+export type NormalizedColumn = {
+    /** Column db name. */
+    readonly name: string;
+    readonly field: FieldIR;
+    readonly typeKey: string;
+    readonly nullable: boolean;
+    readonly defaultKey: string | null;
+};
+/** An index (unique or not) ready for comparison. `key` ignores the name. */
+export type NormalizedIndex = {
+    readonly key: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly unique: boolean;
+    readonly columns: readonly IndexColumn[];
+    readonly where?: string;
+};
+/** A foreign key ready for comparison. `key` excludes the cascade actions. */
+export type NormalizedFk = {
+    readonly key: string;
+    readonly constraintName: string;
+    readonly columns: readonly string[];
+    readonly refTable: string;
+    readonly refColumns: readonly string[];
+    readonly onDelete: CascadeAction;
+    readonly onUpdate: CascadeAction;
+};
+/** A model collapsed to its database shape. */
+export type NormalizedTable = {
+    readonly model: ModelIR;
+    /** Table db name. */
+    readonly table: string;
+    readonly columns: ReadonlyMap<string, NormalizedColumn>;
+    /** Primary-key column db names (empty = none). */
+    readonly pk: readonly string[];
+    readonly indexes: ReadonlyMap<string, NormalizedIndex>;
+    readonly fks: ReadonlyMap<string, NormalizedFk>;
+};
+/** An implicit M2M join table collapsed to its database shape. */
+export type NormalizedJoinTable = {
+    readonly table: string;
+    readonly a: JoinTableEnd;
+    readonly b: JoinTableEnd;
+};
+/** A whole schema, ready for diffing. */
+export type NormalizedSchema = {
+    readonly tables: ReadonlyMap<string, NormalizedTable>;
+    readonly joinTables: ReadonlyMap<string, NormalizedJoinTable>;
+    /** Enums keyed by db name. */
+    readonly enums: ReadonlyMap<string, EnumIR>;
+    /** View models keyed by db name — present for drop detection only (#26). */
+    readonly views: ReadonlyMap<string, ModelIR>;
+};
+/**
+ * Collapse a SchemaIR into its comparable database shape. `dialect` (default
+ * postgres) selects the column comparison keys: on sqlite columns compare by
+ * STORAGE CLASS (TEXT/INTEGER/REAL/BLOB — the TEXT-ambiguity rule), on mysql
+ * by mysql column type; enum columns on both compare by VALUE LIST, never by
+ * name (the database does not store one).
+ */
+export declare function normalizeSchema(params: {
+    schema: SchemaIR;
+    dialect?: Dialect;
+}): NormalizedSchema;
+/** Dialect-routed column type comparison key. */
+export declare function columnTypeKeyFor(params: {
+    field: FieldIR;
+    dialect: Dialect;
+    enums: ReadonlyMap<string, EnumIR>;
+}): string;
+/** Dialect-routed default fingerprint. */
+export declare function defaultFingerprintFor(params: {
+    field: FieldIR;
+    dialect: Dialect;
+}): string | null;
+/**
+ * Partial-index predicates are compared loosely: postgres re-serializes the
+ * expression (extra parentheses, quoted identifiers), so the comparison key
+ * strips quoting, parentheses, whitespace and case. `::type` casts postgres
+ * adds during normalization (e.g. `'x'::text`) are stripped too.
+ */
+export declare function normalizeWhere(params: {
+    where: string | undefined;
+}): string;
+/** Resolve a field name to its db column name on a model. */
+export declare function fieldDbName(params: {
+    model: ModelIR;
+    name: string;
+}): string;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"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"}

package/dist/postgres-types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Postgres column-type mapping (IR → pg text and back), native-type
+ * normalization, default-value fingerprints/rendering, and cascade-action
+ * resolution.
+ *
+ * The forward mapping implements dialect-matrix §2; the fingerprint helpers are
+ * the differ's normalization layer — both the differ and the introspector lean
+ * on them so `diff(introspect(push(X)), X) = []` holds by construction.
+ */
+import type { CascadeAction, FieldIR, ScalarType } from "@vibeorm/schema";
+/** IR scalar → canonical postgres column type. */
+export declare const SCALAR_TO_PG: Readonly<Record<ScalarType, string>>;
+/**
+ * Normalize a native type string for comparison: lowercase, whitespace
+ * stripped, base name de-aliased. `"VarChar(191)"` and `"character varying(191)"`
+ * both become `"varchar(191)"`.
+ */
+export declare function normalizeNativeType(params: {
+    raw: string;
+}): string;
+/**
+ * Comparison key for a column's type. Two columns with equal keys need no
+ * ALTER. A native type equal to the scalar's canonical mapping is dropped, so
+ * `DateTime` and `DateTime @db.Timestamptz` compare equal — and so do the
+ * mapping's `CANONICAL_EQUIVALENTS` (`@db.Timestamptz(6)`, the same type
+ * spelled explicitly, and `@db.Timestamptz(3)`, what the 2.0 alphas created).
+ * Any other precision stays distinct and still diffs.
+ */
+export declare function columnTypeKey(params: {
+    field: FieldIR;
+}): string;
+/**
+ * True when a type change from `from` to `to` is the safe scalar→array repair
+ * (same base type, scalar becomes a one-element array via a `USING` clause —
+ * the LEARNINGS enum-array lesson). Every other type change is treated as
+ * potentially narrowing, i.e. destructive.
+ */
+export declare function isScalarToArrayChange(params: {
+    from: FieldIR;
+    to: FieldIR;
+}): boolean;
+/** Render the postgres column type for a field (no identity, no default). */
+export declare function columnTypeSql(params: {
+    field: FieldIR;
+}): string;
+/** True when the field renders as an identity column (autoincrement Int/BigInt). */
+export declare function isIdentityColumn(params: {
+    field: FieldIR;
+}): boolean;
+/**
+ * Normalized fingerprint of a column default for diffing, or `null` when the
+ * database carries no default. App-level id generators (uuid / cuid / nanoid /
+ * ulid) fingerprint as `null`: the runtime injects them client-side, so the
+ * database honestly has no default — this is what keeps introspection
+ * round-trips stable for `@default(uuid())` columns.
+ */
+export declare function defaultFingerprint(params: {
+    field: FieldIR;
+}): string | null;
+/**
+ * Render the `DEFAULT` expression for a field, or `undefined` when the column
+ * takes no database default (no default declared, app-level generators,
+ * autoincrement — which renders as identity instead).
+ */
+export declare function defaultSql(params: {
+    field: FieldIR;
+}): string | undefined;
+/** True for scalars whose defaults postgres reports back as numeric literals. */
+export declare function isNumericScalar(params: {
+    type: ScalarType;
+}): boolean;
+/**
+ * `pg_constraint.confdeltype` / `confupdtype` single-char codes → IR actions
+ * (used by the introspector).
+ */
+export declare const PG_CHAR_TO_CASCADE_ACTION: Readonly<Record<string, CascadeAction>>;
+/** CascadeAction → SQL clause body. */
+export declare const CASCADE_ACTION_SQL: Readonly<Record<CascadeAction, string>>;
+/**
+ * Effective onDelete with Prisma's postgres defaults applied (LEARNINGS):
+ * required FK → Restrict, optional FK → SetNull.
+ */
+export declare function resolveOnDelete(params: {
+    explicit: CascadeAction | undefined;
+    required: boolean;
+}): CascadeAction;
+/** Effective onUpdate — Prisma's postgres default is Cascade. */
+export declare function resolveOnUpdate(params: {
+    explicit: CascadeAction | undefined;
+}): CascadeAction;
+/** Quote a postgres string literal (single quotes, doubled embedded quotes). */
+export declare function quotePgString(params: {
+    value: string;
+}): string;
+//# sourceMappingURL=postgres-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-types.d.ts","sourceRoot":"","sources":["../src/postgres-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAK1E,kDAAkD;AAClD,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAU7D,CAAC;AA+CF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAMnE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAmBhE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAMrF;AAID,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAsBhE;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAQpE;AAID;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAmC5E;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAuBzE;AAKD,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,OAAO,CAGrE;AAID;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAM7E,CAAC;AAEF,uCAAuC;AACvC,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAMtE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IACtC,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC,QAAQ,EAAE,OAAO,CAAC;CACnB,GAAG,aAAa,CAGhB;AAED,iEAAiE;AACjE,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,aAAa,GAAG,SAAS,CAAA;CAAE,GAAG,aAAa,CAE9F;AAID,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAE/D"}

package/dist/push.d.ts

@@ -0,0 +1,45 @@
+/**
+ * `db push` / `db pull` at library level (the CLI wires these).
+ *
+ * push = introspect → diff → render → apply, routed per dialect
+ * (`providerToDialect(schema.datasource.provider)`):
+ *
+ * - postgres/pglite: all statements in ONE transaction (transactional DDL).
+ * - sqlite: transactional too, UNLESS the script contains a table-rebuild
+ *   block — those manage their own `PRAGMA foreign_keys` + BEGIN/COMMIT
+ *   sequence (ddl/sqlite.ts) and run unwrapped; `PRAGMA foreign_key_check`
+ *   violations become VIBE_MIGRATION errors (execute.ts).
+ * - mysql: DDL auto-commits — statements run sequentially, no wrap.
+ *
+ * Destructive steps are REFUSED unless `acceptDataLoss` is set — the error
+ * lists every destructive step, loudly (dialect honesty: never silently drop
+ * data).
+ */
+import type { Dialect, SchemaIR, VibeExtension } from "@vibeorm/schema";
+import type { PushResult, SqlExecutor } from "./types.ts";
+/**
+ * Make the live database match `schema`. Returns the steps that were applied
+ * and the SQL executed (both empty when the database already matched — pushing
+ * twice is a no-op by the differ's round-trip property).
+ *
+ * @throws VibeError VIBE_SCHEMA_INVALID when the target schema fails validation.
+ * @throws VibeError VIBE_UNSUPPORTED_CAPABILITY for dialect-impossible constructs
+ *   (scalar lists on sqlite/mysql, partial indexes on mysql, enum-value removal).
+ * @throws VibeError VIBE_MIGRATION when destructive steps exist and `acceptDataLoss` is not set.
+ */
+export declare function push(params: {
+    executor: SqlExecutor;
+    schema: SchemaIR;
+    acceptDataLoss?: boolean;
+    /** Configured extension instances — their artifacts apply with the diff. */
+    extensions?: readonly VibeExtension[];
+}): Promise<PushResult>;
+/**
+ * Introspect the live database into SchemaIR (the CLI's `db pull`).
+ * `dialect` selects the introspector — postgres if omitted (back-compat).
+ */
+export declare function pull(params: {
+    executor: SqlExecutor;
+    dialect?: Dialect;
+}): Promise<SchemaIR>;
+//# sourceMappingURL=push.d.ts.map

package/dist/push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../src/push.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAoBxE,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE1D;;;;;;;;;GASG;AACH,wBAAsB,IAAI,CAAC,MAAM,EAAE;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,MAAM,EAAE,QAAQ,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,SAAS,aAAa,EAAE,CAAC;CACvC,GAAG,OAAO,CAAC,UAAU,CAAC,CA8EtB;AAED;;;GAGG;AACH,wBAAsB,IAAI,CAAC,MAAM,EAAE;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAEpB"}

package/dist/relations.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Implicit many-to-many detection on Schema IR.
+ *
+ * ONE structural rule, kept in lock-step with the parser's
+ * `findImplicitM2MCounterpart` (see LEARNINGS): two relation fields form an
+ * implicit M:N **iff** both are lists that declare no FK columns, they are
+ * distinct fields (self-exclusion — a 1:N self-relation must never pair with
+ * itself), their relation names match symmetrically (both unnamed, or both
+ * the same name), and each side is the OTHER'S SOLE counterpart under that
+ * name key. Detection never reads `relation.type`, because an introspected
+ * schema represents a real join table as two unnamed `oneToMany` list sides —
+ * trusting the type would break round-trip stability.
+ *
+ * The sole-counterpart requirement is the phantom-join-table fix, round two:
+ * two models holding foreign keys INTO EACH OTHER introspect as an unnamed
+ * fieldless list on each side (every FK synthesizes one on its target), and
+ * name-matching alone would marry those lists into a join table that exists
+ * nowhere. Counting EVERY relation under the name key — FK-owning sides
+ * included — disambiguates: the parser rejects the same shape as
+ * `ambiguous-relation` at parse time, so parsed and introspected schemas
+ * resolve identically.
+ *
+ * The join-table naming itself comes from the ONE shared convention in
+ * `@vibeorm/schema` (`implicitJoinTable`) — never re-derived here.
+ */
+import type { SchemaIR } from "@vibeorm/schema";
+/** A detected implicit many-to-many relation. `modelA` sorts before `modelB`. */
+export type ImplicitM2MPair = {
+    readonly modelA: string;
+    readonly modelB: string;
+    /** Shared explicit relation name, when both sides declare one. */
+    readonly relationName?: string;
+    /** Join table name per the shared convention (`_PostToTag`, `_tags`). */
+    readonly tableName: string;
+};
+/** Detect every implicit many-to-many pair in a schema. */
+export declare function detectImplicitM2MPairs(params: {
+    schema: SchemaIR;
+}): ImplicitM2MPair[];
+//# sourceMappingURL=relations.d.ts.map

package/dist/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../src/relations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAuB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAErE,iFAAiF;AACjF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kEAAkE;IAClE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,2DAA2D;AAC3D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GAAG,eAAe,EAAE,CAwCtF"}