@prisma-next/sql-schema-ir 0.8.0 → 0.9.0-dev.2

package/dist/exports/types.d.mts

@@ -1,2 +1,2 @@
-import { a as SqlIndexIR, c as SqlTableIR, d as SqlUniqueIR, i as SqlForeignKeyIR, l as SqlTypeMetadata, n as SqlAnnotations, o as SqlReferentialAction, r as SqlColumnIR, s as SqlSchemaIR, t as PrimaryKey, u as SqlTypeMetadataRegistry } from "../types-BNW257Ug.mjs";
-export { PrimaryKey, SqlAnnotations, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlReferentialAction, SqlSchemaIR, SqlTableIR, SqlTypeMetadata, SqlTypeMetadataRegistry, SqlUniqueIR };
+import { _ as PrimaryKey, a as SqlTableIR, c as SqlUniqueIRInput, d as SqlForeignKeyIR, f as SqlForeignKeyIRInput, g as SqlColumnIRInput, h as SqlColumnIR, i as SqlSchemaIRInput, l as SqlIndexIR, m as SqlAnnotations, n as SqlTypeMetadataRegistry, o as SqlTableIRInput, p as SqlReferentialAction, r as SqlSchemaIR, s as SqlUniqueIR, t as SqlTypeMetadata, u as SqlIndexIRInput, v as PrimaryKeyInput, y as SqlSchemaIRNode } from "../types-CpDFLYCH.mjs";
+export { PrimaryKey, PrimaryKeyInput, SqlAnnotations, SqlColumnIR, SqlColumnIRInput, SqlForeignKeyIR, SqlForeignKeyIRInput, SqlIndexIR, SqlIndexIRInput, SqlReferentialAction, SqlSchemaIR, SqlSchemaIRInput, SqlSchemaIRNode, SqlTableIR, SqlTableIRInput, SqlTypeMetadata, SqlTypeMetadataRegistry, SqlUniqueIR, SqlUniqueIRInput };

package/dist/exports/types.mjs

@@ -1 +1,2 @@
-export {};
+import { a as SqlForeignKeyIR, c as SqlSchemaIRNode, i as SqlIndexIR, n as SqlTableIR, o as SqlColumnIR, r as SqlUniqueIR, s as PrimaryKey, t as SqlSchemaIR } from "../types-DKwM7vwx.mjs";
+export { PrimaryKey, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIR, SqlSchemaIRNode, SqlTableIR, SqlUniqueIR };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { a as SqlIndexIR, c as SqlTableIR, d as SqlUniqueIR, i as SqlForeignKeyIR, l as SqlTypeMetadata, n as SqlAnnotations, o as SqlReferentialAction, r as SqlColumnIR, s as SqlSchemaIR, t as PrimaryKey, u as SqlTypeMetadataRegistry } from "./types-BNW257Ug.mjs";
-export { PrimaryKey, SqlAnnotations, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlReferentialAction, SqlSchemaIR, SqlTableIR, SqlTypeMetadata, SqlTypeMetadataRegistry, SqlUniqueIR };
+import { _ as PrimaryKey, a as SqlTableIR, c as SqlUniqueIRInput, d as SqlForeignKeyIR, f as SqlForeignKeyIRInput, g as SqlColumnIRInput, h as SqlColumnIR, i as SqlSchemaIRInput, l as SqlIndexIR, m as SqlAnnotations, n as SqlTypeMetadataRegistry, o as SqlTableIRInput, p as SqlReferentialAction, r as SqlSchemaIR, s as SqlUniqueIR, t as SqlTypeMetadata, u as SqlIndexIRInput, v as PrimaryKeyInput, y as SqlSchemaIRNode } from "./types-CpDFLYCH.mjs";
+export { PrimaryKey, PrimaryKeyInput, SqlAnnotations, SqlColumnIR, SqlColumnIRInput, SqlForeignKeyIR, SqlForeignKeyIRInput, SqlIndexIR, SqlIndexIRInput, SqlReferentialAction, SqlSchemaIR, SqlSchemaIRInput, SqlSchemaIRNode, SqlTableIR, SqlTableIRInput, SqlTypeMetadata, SqlTypeMetadataRegistry, SqlUniqueIR, SqlUniqueIRInput };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import "./exports/types.mjs";
-export {};
+import { a as SqlForeignKeyIR, c as SqlSchemaIRNode, i as SqlIndexIR, n as SqlTableIR, o as SqlColumnIR, r as SqlUniqueIR, s as PrimaryKey, t as SqlSchemaIR } from "./types-DKwM7vwx.mjs";
+export { PrimaryKey, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIR, SqlSchemaIRNode, SqlTableIR, SqlUniqueIR };

package/dist/types-CpDFLYCH.d.mts

@@ -0,0 +1,232 @@
+import { IRNodeBase } from "@prisma-next/framework-components/ir";
+
+//#region src/ir/sql-schema-ir-node.d.ts
+/**
+ * SQL Schema IR node base. Carries the family-level
+ * `kind = 'sql-schema-ir'` discriminator and inherits the framework's
+ * `freezeNode` affordance.
+ *
+ * SQL Schema IR represents the actual database state as discovered by
+ * introspection (the parallel to SQL Contract IR, which represents the
+ * desired state). Like the Contract side, today's Schema IR has no
+ * polymorphic dispatch — verifiers and planners walk by structural
+ * position, not by inspecting `kind` — so a single family-level
+ * discriminator is sufficient. Future per-leaf overrides land cleanly
+ * the same way as on the Contract side.
+ *
+ * The discriminator is installed as a non-enumerable own property,
+ * matching the SqlNode pattern. This keeps `JSON.stringify(node)`
+ * canonical (no `kind` field), keeps `toEqual({...})` test assertions
+ * against pre-lift flat shapes passing, and keeps `node.kind` readable
+ * for future polymorphic dispatch.
+ */
+declare abstract class SqlSchemaIRNode extends IRNodeBase {
+  readonly kind?: string;
+  constructor();
+}
+//#endregion
+//#region src/ir/primary-key.d.ts
+interface PrimaryKeyInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+/**
+ * Primary-key Schema IR node. Mirrors the Contract IR `PrimaryKey`
+ * shape (same `columns` + optional `name`) so verification can compare
+ * intent and actual structurally. Defined here independently to avoid
+ * a sql-schema-ir -> sql-contract dependency.
+ */
+declare class PrimaryKey extends SqlSchemaIRNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  constructor(input: PrimaryKeyInput);
+}
+//#endregion
+//#region src/ir/sql-column-ir.d.ts
+/**
+ * Namespaced annotations for extensibility. Each namespace
+ * (e.g. `pg`, `pgvector`) owns its annotations subtree.
+ */
+type SqlAnnotations = {
+  readonly [namespace: string]: unknown;
+};
+interface SqlColumnIRInput {
+  readonly name: string;
+  readonly nativeType: string;
+  readonly nullable: boolean;
+  /** Raw database default expression (e.g. `'hello'::text`, `nextval('seq')`). */
+  readonly default?: string;
+  readonly annotations?: SqlAnnotations;
+}
+/**
+ * Schema IR node for a single column on a table, as observed by
+ * introspection. Unlike the Contract IR `StorageColumn`, this carries
+ * the column's `name` (Schema IR columns are returned as arrays from
+ * introspection queries; the parent table re-keys them into a record
+ * for downstream consumers).
+ */
+declare class SqlColumnIR extends SqlSchemaIRNode {
+  readonly name: string;
+  readonly nativeType: string;
+  readonly nullable: boolean;
+  readonly default?: string;
+  readonly annotations?: SqlAnnotations;
+  constructor(input: SqlColumnIRInput);
+}
+//#endregion
+//#region src/ir/sql-foreign-key-ir.d.ts
+type SqlReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+interface SqlForeignKeyIRInput {
+  readonly columns: readonly string[];
+  readonly referencedTable: string;
+  readonly referencedColumns: readonly string[];
+  readonly name?: string;
+  readonly onDelete?: SqlReferentialAction;
+  readonly onUpdate?: SqlReferentialAction;
+  readonly annotations?: SqlAnnotations;
+}
+/**
+ * Schema IR node for a foreign-key constraint as observed by
+ * introspection. The `referencedTable` / `referencedColumns` field
+ * names match the introspection vocabulary (`pg_constraint.confkey`,
+ * etc.) and intentionally differ from the Contract IR's nested
+ * `references: { table, columns }` shape so that the verifier's
+ * structural comparison stays explicit about which side it's reading.
+ */
+declare class SqlForeignKeyIR extends SqlSchemaIRNode {
+  readonly columns: readonly string[];
+  readonly referencedTable: string;
+  readonly referencedColumns: readonly string[];
+  readonly name?: string;
+  readonly onDelete?: SqlReferentialAction;
+  readonly onUpdate?: SqlReferentialAction;
+  readonly annotations?: SqlAnnotations;
+  constructor(input: SqlForeignKeyIRInput);
+}
+//#endregion
+//#region src/ir/sql-index-ir.d.ts
+interface SqlIndexIRInput {
+  readonly columns: readonly string[];
+  readonly unique: boolean;
+  readonly name?: string;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+  readonly annotations?: SqlAnnotations;
+}
+/**
+ * Schema IR node for a secondary index as observed by introspection.
+ * Unlike the Contract IR `Index`, the Schema IR carries an explicit
+ * `unique` field — introspection sees the underlying index regardless
+ * of whether the user expressed it as `@@index` or `@@unique`, and the
+ * verifier needs to distinguish them when comparing to the Contract.
+ */
+declare class SqlIndexIR extends SqlSchemaIRNode {
+  readonly columns: readonly string[];
+  readonly unique: boolean;
+  readonly name?: string;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+  readonly annotations?: SqlAnnotations;
+  constructor(input: SqlIndexIRInput);
+}
+//#endregion
+//#region src/ir/sql-unique-ir.d.ts
+interface SqlUniqueIRInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  readonly annotations?: SqlAnnotations;
+}
+/**
+ * Schema IR node for a table-level unique constraint as observed by
+ * introspection.
+ */
+declare class SqlUniqueIR extends SqlSchemaIRNode {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  readonly annotations?: SqlAnnotations;
+  constructor(input: SqlUniqueIRInput);
+}
+//#endregion
+//#region src/ir/sql-table-ir.d.ts
+interface SqlTableIRInput {
+  readonly name: string;
+  readonly columns: Record<string, SqlColumnIR | SqlColumnIRInput>;
+  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR | SqlForeignKeyIRInput>;
+  readonly uniques: ReadonlyArray<SqlUniqueIR | SqlUniqueIRInput>;
+  readonly indexes: ReadonlyArray<SqlIndexIR | SqlIndexIRInput>;
+  readonly primaryKey?: PrimaryKey | PrimaryKeyInput;
+  readonly annotations?: SqlAnnotations;
+}
+/**
+ * Schema IR node for a single table as observed by introspection.
+ *
+ * Unlike the Contract IR `StorageTable`, this carries the table's
+ * `name` — introspection queries return tables as arrays and the
+ * verifier keys them into `SqlSchemaIR.tables` afterwards, so the name
+ * stays on the table object for downstream call sites that walk
+ * `Object.values(schema.tables)`.
+ *
+ * The constructor normalises nested IR-class fields so downstream
+ * walks see a uniform AST regardless of whether the input was a
+ * plain-data literal (from introspection) or already-constructed
+ * class instances.
+ */
+declare class SqlTableIR extends SqlSchemaIRNode {
+  readonly name: string;
+  readonly columns: Readonly<Record<string, SqlColumnIR>>;
+  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;
+  readonly uniques: ReadonlyArray<SqlUniqueIR>;
+  readonly indexes: ReadonlyArray<SqlIndexIR>;
+  readonly primaryKey?: PrimaryKey;
+  readonly annotations?: SqlAnnotations;
+  constructor(input: SqlTableIRInput);
+}
+//#endregion
+//#region src/ir/sql-schema-ir.d.ts
+interface SqlSchemaIRInput {
+  readonly tables: Record<string, SqlTableIR | SqlTableIRInput>;
+  readonly annotations?: SqlAnnotations;
+}
+/**
+ * Root Schema IR node representing the complete database schema as
+ * observed by introspection. Target-agnostic; used by both verifiers
+ * (compare against intended Contract storage) and migration planners
+ * (derive operations needed to reconcile).
+ *
+ * The constructor normalises nested `SqlTableIR` instances so
+ * downstream walks see a uniform AST regardless of whether the input
+ * was a plain-data literal or already-constructed class instances.
+ */
+declare class SqlSchemaIR extends SqlSchemaIRNode {
+  readonly tables: Readonly<Record<string, SqlTableIR>>;
+  readonly annotations?: SqlAnnotations;
+  constructor(input: SqlSchemaIRInput);
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * SQL type metadata for control-plane and execution-plane type
+ * availability and mapping. Read-only view of type information
+ * without encode/decode behavior.
+ */
+interface SqlTypeMetadata {
+  /** Namespaced type identifier, e.g. `pg/int4@1`, `pg/text@1`. */
+  readonly typeId: string;
+  /** Contract scalar type IDs this type can handle. */
+  readonly targetTypes: readonly string[];
+  /**
+   * Native database type name (target-specific). Optional because
+   * not all types have a native database representation.
+   */
+  readonly nativeType?: string;
+}
+/**
+ * Registry interface for SQL type metadata. Provides read-only
+ * iteration over type metadata entries.
+ */
+interface SqlTypeMetadataRegistry {
+  values(): IterableIterator<SqlTypeMetadata>;
+}
+//#endregion
+export { PrimaryKey as _, SqlTableIR as a, SqlUniqueIRInput as c, SqlForeignKeyIR as d, SqlForeignKeyIRInput as f, SqlColumnIRInput as g, SqlColumnIR as h, SqlSchemaIRInput as i, SqlIndexIR as l, SqlAnnotations as m, SqlTypeMetadataRegistry as n, SqlTableIRInput as o, SqlReferentialAction as p, SqlSchemaIR as r, SqlUniqueIR as s, SqlTypeMetadata as t, SqlIndexIRInput as u, PrimaryKeyInput as v, SqlSchemaIRNode as y };
+//# sourceMappingURL=types-CpDFLYCH.d.mts.map

package/dist/types-CpDFLYCH.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CpDFLYCH.d.mts","names":[],"sources":["../src/ir/sql-schema-ir-node.ts","../src/ir/primary-key.ts","../src/ir/sql-column-ir.ts","../src/ir/sql-foreign-key-ir.ts","../src/ir/sql-index-ir.ts","../src/ir/sql-unique-ir.ts","../src/ir/sql-table-ir.ts","../src/ir/sql-schema-ir.ts","../src/types.ts"],"mappings":"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"}

package/dist/types-DKwM7vwx.mjs

@@ -0,0 +1,197 @@
+import { IRNodeBase, freezeNode } from "@prisma-next/framework-components/ir";
+//#region src/ir/sql-schema-ir-node.ts
+/**
+* SQL Schema IR node base. Carries the family-level
+* `kind = 'sql-schema-ir'` discriminator and inherits the framework's
+* `freezeNode` affordance.
+*
+* SQL Schema IR represents the actual database state as discovered by
+* introspection (the parallel to SQL Contract IR, which represents the
+* desired state). Like the Contract side, today's Schema IR has no
+* polymorphic dispatch — verifiers and planners walk by structural
+* position, not by inspecting `kind` — so a single family-level
+* discriminator is sufficient. Future per-leaf overrides land cleanly
+* the same way as on the Contract side.
+*
+* The discriminator is installed as a non-enumerable own property,
+* matching the SqlNode pattern. This keeps `JSON.stringify(node)`
+* canonical (no `kind` field), keeps `toEqual({...})` test assertions
+* against pre-lift flat shapes passing, and keeps `node.kind` readable
+* for future polymorphic dispatch.
+*/
+var SqlSchemaIRNode = class extends IRNodeBase {
+	kind;
+	constructor() {
+		super();
+		Object.defineProperty(this, "kind", {
+			value: "sql-schema-ir",
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+};
+//#endregion
+//#region src/ir/primary-key.ts
+/**
+* Primary-key Schema IR node. Mirrors the Contract IR `PrimaryKey`
+* shape (same `columns` + optional `name`) so verification can compare
+* intent and actual structurally. Defined here independently to avoid
+* a sql-schema-ir -> sql-contract dependency.
+*/
+var PrimaryKey = class extends SqlSchemaIRNode {
+	columns;
+	constructor(input) {
+		super();
+		this.columns = input.columns;
+		if (input.name !== void 0) this.name = input.name;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/sql-column-ir.ts
+/**
+* Schema IR node for a single column on a table, as observed by
+* introspection. Unlike the Contract IR `StorageColumn`, this carries
+* the column's `name` (Schema IR columns are returned as arrays from
+* introspection queries; the parent table re-keys them into a record
+* for downstream consumers).
+*/
+var SqlColumnIR = class extends SqlSchemaIRNode {
+	name;
+	nativeType;
+	nullable;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.nativeType = input.nativeType;
+		this.nullable = input.nullable;
+		if (input.default !== void 0) this.default = input.default;
+		if (input.annotations !== void 0) this.annotations = input.annotations;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/sql-foreign-key-ir.ts
+/**
+* Schema IR node for a foreign-key constraint as observed by
+* introspection. The `referencedTable` / `referencedColumns` field
+* names match the introspection vocabulary (`pg_constraint.confkey`,
+* etc.) and intentionally differ from the Contract IR's nested
+* `references: { table, columns }` shape so that the verifier's
+* structural comparison stays explicit about which side it's reading.
+*/
+var SqlForeignKeyIR = class extends SqlSchemaIRNode {
+	columns;
+	referencedTable;
+	referencedColumns;
+	constructor(input) {
+		super();
+		this.columns = input.columns;
+		this.referencedTable = input.referencedTable;
+		this.referencedColumns = input.referencedColumns;
+		if (input.name !== void 0) this.name = input.name;
+		if (input.onDelete !== void 0) this.onDelete = input.onDelete;
+		if (input.onUpdate !== void 0) this.onUpdate = input.onUpdate;
+		if (input.annotations !== void 0) this.annotations = input.annotations;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/sql-index-ir.ts
+/**
+* Schema IR node for a secondary index as observed by introspection.
+* Unlike the Contract IR `Index`, the Schema IR carries an explicit
+* `unique` field — introspection sees the underlying index regardless
+* of whether the user expressed it as `@@index` or `@@unique`, and the
+* verifier needs to distinguish them when comparing to the Contract.
+*/
+var SqlIndexIR = class extends SqlSchemaIRNode {
+	columns;
+	unique;
+	constructor(input) {
+		super();
+		this.columns = input.columns;
+		this.unique = input.unique;
+		if (input.name !== void 0) this.name = input.name;
+		if (input.type !== void 0) this.type = input.type;
+		if (input.options !== void 0) this.options = input.options;
+		if (input.annotations !== void 0) this.annotations = input.annotations;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/sql-unique-ir.ts
+/**
+* Schema IR node for a table-level unique constraint as observed by
+* introspection.
+*/
+var SqlUniqueIR = class extends SqlSchemaIRNode {
+	columns;
+	constructor(input) {
+		super();
+		this.columns = [...input.columns];
+		if (input.name !== void 0) this.name = input.name;
+		if (input.annotations !== void 0) this.annotations = input.annotations;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/sql-table-ir.ts
+/**
+* Schema IR node for a single table as observed by introspection.
+*
+* Unlike the Contract IR `StorageTable`, this carries the table's
+* `name` — introspection queries return tables as arrays and the
+* verifier keys them into `SqlSchemaIR.tables` afterwards, so the name
+* stays on the table object for downstream call sites that walk
+* `Object.values(schema.tables)`.
+*
+* The constructor normalises nested IR-class fields so downstream
+* walks see a uniform AST regardless of whether the input was a
+* plain-data literal (from introspection) or already-constructed
+* class instances.
+*/
+var SqlTableIR = class extends SqlSchemaIRNode {
+	name;
+	columns;
+	foreignKeys;
+	uniques;
+	indexes;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([key, col]) => [key, col instanceof SqlColumnIR ? col : new SqlColumnIR(col)])));
+		this.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk)));
+		this.uniques = Object.freeze(input.uniques.map((u) => u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u)));
+		this.indexes = Object.freeze(input.indexes.map((i) => i instanceof SqlIndexIR ? i : new SqlIndexIR(i)));
+		if (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);
+		if (input.annotations !== void 0) this.annotations = input.annotations;
+		freezeNode(this);
+	}
+};
+//#endregion
+//#region src/ir/sql-schema-ir.ts
+/**
+* Root Schema IR node representing the complete database schema as
+* observed by introspection. Target-agnostic; used by both verifiers
+* (compare against intended Contract storage) and migration planners
+* (derive operations needed to reconcile).
+*
+* The constructor normalises nested `SqlTableIR` instances so
+* downstream walks see a uniform AST regardless of whether the input
+* was a plain-data literal or already-constructed class instances.
+*/
+var SqlSchemaIR = class extends SqlSchemaIRNode {
+	tables;
+	constructor(input) {
+		super();
+		this.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables).map(([key, t]) => [key, t instanceof SqlTableIR ? t : new SqlTableIR(t)])));
+		if (input.annotations !== void 0) this.annotations = input.annotations;
+		freezeNode(this);
+	}
+};
+//#endregion
+export { SqlForeignKeyIR as a, SqlSchemaIRNode as c, SqlIndexIR as i, SqlTableIR as n, SqlColumnIR as o, SqlUniqueIR as r, PrimaryKey as s, SqlSchemaIR as t };
+
+//# sourceMappingURL=types-DKwM7vwx.mjs.map

package/dist/types-DKwM7vwx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DKwM7vwx.mjs","names":[],"sources":["../src/ir/sql-schema-ir-node.ts","../src/ir/primary-key.ts","../src/ir/sql-column-ir.ts","../src/ir/sql-foreign-key-ir.ts","../src/ir/sql-index-ir.ts","../src/ir/sql-unique-ir.ts","../src/ir/sql-table-ir.ts","../src/ir/sql-schema-ir.ts"],"sourcesContent":["import { IRNodeBase } from '@prisma-next/framework-components/ir';\n\n/**\n * SQL Schema IR node base. Carries the family-level\n * `kind = 'sql-schema-ir'` discriminator and inherits the framework's\n * `freezeNode` affordance.\n *\n * SQL Schema IR represents the actual database state as discovered by\n * introspection (the parallel to SQL Contract IR, which represents the\n * desired state). Like the Contract side, today's Schema IR has no\n * polymorphic dispatch — verifiers and planners walk by structural\n * position, not by inspecting `kind` — so a single family-level\n * discriminator is sufficient. Future per-leaf overrides land cleanly\n * the same way as on the Contract side.\n *\n * The discriminator is installed as a non-enumerable own property,\n * matching the SqlNode pattern. This keeps `JSON.stringify(node)`\n * canonical (no `kind` field), keeps `toEqual({...})` test assertions\n * against pre-lift flat shapes passing, and keeps `node.kind` readable\n * for future polymorphic dispatch.\n */\nexport abstract class SqlSchemaIRNode extends IRNodeBase {\n  readonly kind?: string;\n\n  constructor() {\n    super();\n    Object.defineProperty(this, 'kind', {\n      value: 'sql-schema-ir',\n      writable: false,\n      enumerable: false,\n      configurable: false,\n    });\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from './sql-schema-ir-node';\n\nexport interface PrimaryKeyInput {\n  readonly columns: readonly string[];\n  readonly name?: string;\n}\n\n/**\n * Primary-key Schema IR node. Mirrors the Contract IR `PrimaryKey`\n * shape (same `columns` + optional `name`) so verification can compare\n * intent and actual structurally. Defined here independently to avoid\n * a sql-schema-ir -> sql-contract dependency.\n */\nexport class PrimaryKey extends SqlSchemaIRNode {\n  readonly columns: readonly string[];\n  declare readonly name?: string;\n\n  constructor(input: PrimaryKeyInput) {\n    super();\n    this.columns = input.columns;\n    if (input.name !== undefined) this.name = input.name;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from './sql-schema-ir-node';\n\n/**\n * Namespaced annotations for extensibility. Each namespace\n * (e.g. `pg`, `pgvector`) owns its annotations subtree.\n */\nexport type SqlAnnotations = {\n  readonly [namespace: string]: unknown;\n};\n\nexport interface SqlColumnIRInput {\n  readonly name: string;\n  readonly nativeType: string;\n  readonly nullable: boolean;\n  /** Raw database default expression (e.g. `'hello'::text`, `nextval('seq')`). */\n  readonly default?: string;\n  readonly annotations?: SqlAnnotations;\n}\n\n/**\n * Schema IR node for a single column on a table, as observed by\n * introspection. Unlike the Contract IR `StorageColumn`, this carries\n * the column's `name` (Schema IR columns are returned as arrays from\n * introspection queries; the parent table re-keys them into a record\n * for downstream consumers).\n */\nexport class SqlColumnIR extends SqlSchemaIRNode {\n  readonly name: string;\n  readonly nativeType: string;\n  readonly nullable: boolean;\n  declare readonly default?: string;\n  declare readonly annotations?: SqlAnnotations;\n\n  constructor(input: SqlColumnIRInput) {\n    super();\n    this.name = input.name;\n    this.nativeType = input.nativeType;\n    this.nullable = input.nullable;\n    if (input.default !== undefined) this.default = input.default;\n    if (input.annotations !== undefined) this.annotations = input.annotations;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport type { SqlAnnotations } from './sql-column-ir';\nimport { SqlSchemaIRNode } from './sql-schema-ir-node';\n\nexport type SqlReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';\n\nexport interface SqlForeignKeyIRInput {\n  readonly columns: readonly string[];\n  readonly referencedTable: string;\n  readonly referencedColumns: readonly string[];\n  readonly name?: string;\n  readonly onDelete?: SqlReferentialAction;\n  readonly onUpdate?: SqlReferentialAction;\n  readonly annotations?: SqlAnnotations;\n}\n\n/**\n * Schema IR node for a foreign-key constraint as observed by\n * introspection. The `referencedTable` / `referencedColumns` field\n * names match the introspection vocabulary (`pg_constraint.confkey`,\n * etc.) and intentionally differ from the Contract IR's nested\n * `references: { table, columns }` shape so that the verifier's\n * structural comparison stays explicit about which side it's reading.\n */\nexport class SqlForeignKeyIR extends SqlSchemaIRNode {\n  readonly columns: readonly string[];\n  readonly referencedTable: string;\n  readonly referencedColumns: readonly string[];\n  declare readonly name?: string;\n  declare readonly onDelete?: SqlReferentialAction;\n  declare readonly onUpdate?: SqlReferentialAction;\n  declare readonly annotations?: SqlAnnotations;\n\n  constructor(input: SqlForeignKeyIRInput) {\n    super();\n    this.columns = input.columns;\n    this.referencedTable = input.referencedTable;\n    this.referencedColumns = input.referencedColumns;\n    if (input.name !== undefined) this.name = input.name;\n    if (input.onDelete !== undefined) this.onDelete = input.onDelete;\n    if (input.onUpdate !== undefined) this.onUpdate = input.onUpdate;\n    if (input.annotations !== undefined) this.annotations = input.annotations;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport type { SqlAnnotations } from './sql-column-ir';\nimport { SqlSchemaIRNode } from './sql-schema-ir-node';\n\nexport interface SqlIndexIRInput {\n  readonly columns: readonly string[];\n  readonly unique: boolean;\n  readonly name?: string;\n  readonly type?: string;\n  readonly options?: Record<string, unknown>;\n  readonly annotations?: SqlAnnotations;\n}\n\n/**\n * Schema IR node for a secondary index as observed by introspection.\n * Unlike the Contract IR `Index`, the Schema IR carries an explicit\n * `unique` field — introspection sees the underlying index regardless\n * of whether the user expressed it as `@@index` or `@@unique`, and the\n * verifier needs to distinguish them when comparing to the Contract.\n */\nexport class SqlIndexIR extends SqlSchemaIRNode {\n  readonly columns: readonly string[];\n  readonly unique: boolean;\n  declare readonly name?: string;\n  declare readonly type?: string;\n  declare readonly options?: Record<string, unknown>;\n  declare readonly annotations?: SqlAnnotations;\n\n  constructor(input: SqlIndexIRInput) {\n    super();\n    this.columns = input.columns;\n    this.unique = input.unique;\n    if (input.name !== undefined) this.name = input.name;\n    if (input.type !== undefined) this.type = input.type;\n    if (input.options !== undefined) this.options = input.options;\n    if (input.annotations !== undefined) this.annotations = input.annotations;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport type { SqlAnnotations } from './sql-column-ir';\nimport { SqlSchemaIRNode } from './sql-schema-ir-node';\n\nexport interface SqlUniqueIRInput {\n  readonly columns: readonly string[];\n  readonly name?: string;\n  readonly annotations?: SqlAnnotations;\n}\n\n/**\n * Schema IR node for a table-level unique constraint as observed by\n * introspection.\n */\nexport class SqlUniqueIR extends SqlSchemaIRNode {\n  readonly columns: readonly string[];\n  declare readonly name?: string;\n  declare readonly annotations?: SqlAnnotations;\n\n  constructor(input: SqlUniqueIRInput) {\n    super();\n    this.columns = [...input.columns];\n    if (input.name !== undefined) this.name = input.name;\n    if (input.annotations !== undefined) this.annotations = input.annotations;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport { PrimaryKey, type PrimaryKeyInput } from './primary-key';\nimport { type SqlAnnotations, SqlColumnIR, type SqlColumnIRInput } from './sql-column-ir';\nimport { SqlForeignKeyIR, type SqlForeignKeyIRInput } from './sql-foreign-key-ir';\nimport { SqlIndexIR, type SqlIndexIRInput } from './sql-index-ir';\nimport { SqlSchemaIRNode } from './sql-schema-ir-node';\nimport { SqlUniqueIR, type SqlUniqueIRInput } from './sql-unique-ir';\n\nexport interface SqlTableIRInput {\n  readonly name: string;\n  readonly columns: Record<string, SqlColumnIR | SqlColumnIRInput>;\n  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR | SqlForeignKeyIRInput>;\n  readonly uniques: ReadonlyArray<SqlUniqueIR | SqlUniqueIRInput>;\n  readonly indexes: ReadonlyArray<SqlIndexIR | SqlIndexIRInput>;\n  readonly primaryKey?: PrimaryKey | PrimaryKeyInput;\n  readonly annotations?: SqlAnnotations;\n}\n\n/**\n * Schema IR node for a single table as observed by introspection.\n *\n * Unlike the Contract IR `StorageTable`, this carries the table's\n * `name` — introspection queries return tables as arrays and the\n * verifier keys them into `SqlSchemaIR.tables` afterwards, so the name\n * stays on the table object for downstream call sites that walk\n * `Object.values(schema.tables)`.\n *\n * The constructor normalises nested IR-class fields so downstream\n * walks see a uniform AST regardless of whether the input was a\n * plain-data literal (from introspection) or already-constructed\n * class instances.\n */\nexport class SqlTableIR extends SqlSchemaIRNode {\n  readonly name: string;\n  readonly columns: Readonly<Record<string, SqlColumnIR>>;\n  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;\n  readonly uniques: ReadonlyArray<SqlUniqueIR>;\n  readonly indexes: ReadonlyArray<SqlIndexIR>;\n  declare readonly primaryKey?: PrimaryKey;\n  declare readonly annotations?: SqlAnnotations;\n\n  constructor(input: SqlTableIRInput) {\n    super();\n    this.name = input.name;\n    this.columns = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.columns).map(([key, col]) => [\n          key,\n          col instanceof SqlColumnIR ? col : new SqlColumnIR(col),\n        ]),\n      ),\n    );\n    this.foreignKeys = Object.freeze(\n      input.foreignKeys.map((fk) => (fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk))),\n    );\n    this.uniques = Object.freeze(\n      input.uniques.map((u) => (u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u))),\n    );\n    this.indexes = Object.freeze(\n      input.indexes.map((i) => (i instanceof SqlIndexIR ? i : new SqlIndexIR(i))),\n    );\n    if (input.primaryKey !== undefined) {\n      this.primaryKey =\n        input.primaryKey instanceof PrimaryKey\n          ? input.primaryKey\n          : new PrimaryKey(input.primaryKey);\n    }\n    if (input.annotations !== undefined) this.annotations = input.annotations;\n    freezeNode(this);\n  }\n}\n","import { freezeNode } from '@prisma-next/framework-components/ir';\nimport type { SqlAnnotations } from './sql-column-ir';\nimport { SqlSchemaIRNode } from './sql-schema-ir-node';\nimport { SqlTableIR, type SqlTableIRInput } from './sql-table-ir';\n\nexport interface SqlSchemaIRInput {\n  readonly tables: Record<string, SqlTableIR | SqlTableIRInput>;\n  readonly annotations?: SqlAnnotations;\n}\n\n/**\n * Root Schema IR node representing the complete database schema as\n * observed by introspection. Target-agnostic; used by both verifiers\n * (compare against intended Contract storage) and migration planners\n * (derive operations needed to reconcile).\n *\n * The constructor normalises nested `SqlTableIR` instances so\n * downstream walks see a uniform AST regardless of whether the input\n * was a plain-data literal or already-constructed class instances.\n */\nexport class SqlSchemaIR extends SqlSchemaIRNode {\n  readonly tables: Readonly<Record<string, SqlTableIR>>;\n  declare readonly annotations?: SqlAnnotations;\n\n  constructor(input: SqlSchemaIRInput) {\n    super();\n    this.tables = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.tables).map(([key, t]) => [\n          key,\n          t instanceof SqlTableIR ? t : new SqlTableIR(t),\n        ]),\n      ),\n    );\n    if (input.annotations !== undefined) this.annotations = input.annotations;\n    freezeNode(this);\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@prisma-next/sql-schema-ir",
-  "version": "0.8.0",
+  "version": "0.9.0-dev.2",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL Schema IR types for schema introspection and verification",
   "dependencies": {
-    "@prisma-next/contract": "0.8.0"
+    "@prisma-next/contract": "0.9.0-dev.2",
+    "@prisma-next/framework-components": "0.9.0-dev.2"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.8.0",
-    "@prisma-next/tsconfig": "0.8.0",
-    "@prisma-next/tsdown": "0.8.0",
+    "@prisma-next/test-utils": "0.9.0-dev.2",
+    "@prisma-next/tsconfig": "0.9.0-dev.2",
+    "@prisma-next/tsdown": "0.9.0-dev.2",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.5"
@@ -29,8 +30,6 @@
     "./types": "./dist/exports/types.mjs",
     "./package.json": "./package.json"
   },
-  "main": "./dist/index.mjs",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "repository": {
     "type": "git",

package/src/exports/types.ts

@@ -1,13 +1,24 @@
 export type {
-  PrimaryKey,
+  PrimaryKeyInput,
   SqlAnnotations,
+  SqlColumnIRInput,
+  SqlForeignKeyIRInput,
+  SqlIndexIRInput,
+  SqlReferentialAction,
+  SqlSchemaIRInput,
+  SqlTableIRInput,
+  SqlTypeMetadata,
+  SqlTypeMetadataRegistry,
+  SqlUniqueIRInput,
+} from '../types';
+
+export {
+  PrimaryKey,
   SqlColumnIR,
   SqlForeignKeyIR,
   SqlIndexIR,
-  SqlReferentialAction,
   SqlSchemaIR,
+  SqlSchemaIRNode,
   SqlTableIR,
-  SqlTypeMetadata,
-  SqlTypeMetadataRegistry,
   SqlUniqueIR,
 } from '../types';

package/src/ir/primary-key.ts

@@ -0,0 +1,25 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlSchemaIRNode } from './sql-schema-ir-node';
+
+export interface PrimaryKeyInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+}
+
+/**
+ * Primary-key Schema IR node. Mirrors the Contract IR `PrimaryKey`
+ * shape (same `columns` + optional `name`) so verification can compare
+ * intent and actual structurally. Defined here independently to avoid
+ * a sql-schema-ir -> sql-contract dependency.
+ */
+export class PrimaryKey extends SqlSchemaIRNode {
+  readonly columns: readonly string[];
+  declare readonly name?: string;
+
+  constructor(input: PrimaryKeyInput) {
+    super();
+    this.columns = input.columns;
+    if (input.name !== undefined) this.name = input.name;
+    freezeNode(this);
+  }
+}

package/src/ir/sql-column-ir.ts

@@ -0,0 +1,44 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlSchemaIRNode } from './sql-schema-ir-node';
+
+/**
+ * Namespaced annotations for extensibility. Each namespace
+ * (e.g. `pg`, `pgvector`) owns its annotations subtree.
+ */
+export type SqlAnnotations = {
+  readonly [namespace: string]: unknown;
+};
+
+export interface SqlColumnIRInput {
+  readonly name: string;
+  readonly nativeType: string;
+  readonly nullable: boolean;
+  /** Raw database default expression (e.g. `'hello'::text`, `nextval('seq')`). */
+  readonly default?: string;
+  readonly annotations?: SqlAnnotations;
+}
+
+/**
+ * Schema IR node for a single column on a table, as observed by
+ * introspection. Unlike the Contract IR `StorageColumn`, this carries
+ * the column's `name` (Schema IR columns are returned as arrays from
+ * introspection queries; the parent table re-keys them into a record
+ * for downstream consumers).
+ */
+export class SqlColumnIR extends SqlSchemaIRNode {
+  readonly name: string;
+  readonly nativeType: string;
+  readonly nullable: boolean;
+  declare readonly default?: string;
+  declare readonly annotations?: SqlAnnotations;
+
+  constructor(input: SqlColumnIRInput) {
+    super();
+    this.name = input.name;
+    this.nativeType = input.nativeType;
+    this.nullable = input.nullable;
+    if (input.default !== undefined) this.default = input.default;
+    if (input.annotations !== undefined) this.annotations = input.annotations;
+    freezeNode(this);
+  }
+}

package/src/ir/sql-foreign-key-ir.ts

@@ -0,0 +1,45 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import type { SqlAnnotations } from './sql-column-ir';
+import { SqlSchemaIRNode } from './sql-schema-ir-node';
+
+export type SqlReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
+
+export interface SqlForeignKeyIRInput {
+  readonly columns: readonly string[];
+  readonly referencedTable: string;
+  readonly referencedColumns: readonly string[];
+  readonly name?: string;
+  readonly onDelete?: SqlReferentialAction;
+  readonly onUpdate?: SqlReferentialAction;
+  readonly annotations?: SqlAnnotations;
+}
+
+/**
+ * Schema IR node for a foreign-key constraint as observed by
+ * introspection. The `referencedTable` / `referencedColumns` field
+ * names match the introspection vocabulary (`pg_constraint.confkey`,
+ * etc.) and intentionally differ from the Contract IR's nested
+ * `references: { table, columns }` shape so that the verifier's
+ * structural comparison stays explicit about which side it's reading.
+ */
+export class SqlForeignKeyIR extends SqlSchemaIRNode {
+  readonly columns: readonly string[];
+  readonly referencedTable: string;
+  readonly referencedColumns: readonly string[];
+  declare readonly name?: string;
+  declare readonly onDelete?: SqlReferentialAction;
+  declare readonly onUpdate?: SqlReferentialAction;
+  declare readonly annotations?: SqlAnnotations;
+
+  constructor(input: SqlForeignKeyIRInput) {
+    super();
+    this.columns = input.columns;
+    this.referencedTable = input.referencedTable;
+    this.referencedColumns = input.referencedColumns;
+    if (input.name !== undefined) this.name = input.name;
+    if (input.onDelete !== undefined) this.onDelete = input.onDelete;
+    if (input.onUpdate !== undefined) this.onUpdate = input.onUpdate;
+    if (input.annotations !== undefined) this.annotations = input.annotations;
+    freezeNode(this);
+  }
+}

package/src/ir/sql-index-ir.ts

@@ -0,0 +1,39 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import type { SqlAnnotations } from './sql-column-ir';
+import { SqlSchemaIRNode } from './sql-schema-ir-node';
+
+export interface SqlIndexIRInput {
+  readonly columns: readonly string[];
+  readonly unique: boolean;
+  readonly name?: string;
+  readonly type?: string;
+  readonly options?: Record<string, unknown>;
+  readonly annotations?: SqlAnnotations;
+}
+
+/**
+ * Schema IR node for a secondary index as observed by introspection.
+ * Unlike the Contract IR `Index`, the Schema IR carries an explicit
+ * `unique` field — introspection sees the underlying index regardless
+ * of whether the user expressed it as `@@index` or `@@unique`, and the
+ * verifier needs to distinguish them when comparing to the Contract.
+ */
+export class SqlIndexIR extends SqlSchemaIRNode {
+  readonly columns: readonly string[];
+  readonly unique: boolean;
+  declare readonly name?: string;
+  declare readonly type?: string;
+  declare readonly options?: Record<string, unknown>;
+  declare readonly annotations?: SqlAnnotations;
+
+  constructor(input: SqlIndexIRInput) {
+    super();
+    this.columns = input.columns;
+    this.unique = input.unique;
+    if (input.name !== undefined) this.name = input.name;
+    if (input.type !== undefined) this.type = input.type;
+    if (input.options !== undefined) this.options = input.options;
+    if (input.annotations !== undefined) this.annotations = input.annotations;
+    freezeNode(this);
+  }
+}

package/src/ir/sql-schema-ir-node.ts

@@ -0,0 +1,34 @@
+import { IRNodeBase } from '@prisma-next/framework-components/ir';
+
+/**
+ * SQL Schema IR node base. Carries the family-level
+ * `kind = 'sql-schema-ir'` discriminator and inherits the framework's
+ * `freezeNode` affordance.
+ *
+ * SQL Schema IR represents the actual database state as discovered by
+ * introspection (the parallel to SQL Contract IR, which represents the
+ * desired state). Like the Contract side, today's Schema IR has no
+ * polymorphic dispatch — verifiers and planners walk by structural
+ * position, not by inspecting `kind` — so a single family-level
+ * discriminator is sufficient. Future per-leaf overrides land cleanly
+ * the same way as on the Contract side.
+ *
+ * The discriminator is installed as a non-enumerable own property,
+ * matching the SqlNode pattern. This keeps `JSON.stringify(node)`
+ * canonical (no `kind` field), keeps `toEqual({...})` test assertions
+ * against pre-lift flat shapes passing, and keeps `node.kind` readable
+ * for future polymorphic dispatch.
+ */
+export abstract class SqlSchemaIRNode extends IRNodeBase {
+  readonly kind?: string;
+
+  constructor() {
+    super();
+    Object.defineProperty(this, 'kind', {
+      value: 'sql-schema-ir',
+      writable: false,
+      enumerable: false,
+      configurable: false,
+    });
+  }
+}

package/src/ir/sql-schema-ir.ts

@@ -0,0 +1,38 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import type { SqlAnnotations } from './sql-column-ir';
+import { SqlSchemaIRNode } from './sql-schema-ir-node';
+import { SqlTableIR, type SqlTableIRInput } from './sql-table-ir';
+
+export interface SqlSchemaIRInput {
+  readonly tables: Record<string, SqlTableIR | SqlTableIRInput>;
+  readonly annotations?: SqlAnnotations;
+}
+
+/**
+ * Root Schema IR node representing the complete database schema as
+ * observed by introspection. Target-agnostic; used by both verifiers
+ * (compare against intended Contract storage) and migration planners
+ * (derive operations needed to reconcile).
+ *
+ * The constructor normalises nested `SqlTableIR` instances so
+ * downstream walks see a uniform AST regardless of whether the input
+ * was a plain-data literal or already-constructed class instances.
+ */
+export class SqlSchemaIR extends SqlSchemaIRNode {
+  readonly tables: Readonly<Record<string, SqlTableIR>>;
+  declare readonly annotations?: SqlAnnotations;
+
+  constructor(input: SqlSchemaIRInput) {
+    super();
+    this.tables = Object.freeze(
+      Object.fromEntries(
+        Object.entries(input.tables).map(([key, t]) => [
+          key,
+          t instanceof SqlTableIR ? t : new SqlTableIR(t),
+        ]),
+      ),
+    );
+    if (input.annotations !== undefined) this.annotations = input.annotations;
+    freezeNode(this);
+  }
+}

package/src/ir/sql-table-ir.ts

@@ -0,0 +1,71 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { PrimaryKey, type PrimaryKeyInput } from './primary-key';
+import { type SqlAnnotations, SqlColumnIR, type SqlColumnIRInput } from './sql-column-ir';
+import { SqlForeignKeyIR, type SqlForeignKeyIRInput } from './sql-foreign-key-ir';
+import { SqlIndexIR, type SqlIndexIRInput } from './sql-index-ir';
+import { SqlSchemaIRNode } from './sql-schema-ir-node';
+import { SqlUniqueIR, type SqlUniqueIRInput } from './sql-unique-ir';
+
+export interface SqlTableIRInput {
+  readonly name: string;
+  readonly columns: Record<string, SqlColumnIR | SqlColumnIRInput>;
+  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR | SqlForeignKeyIRInput>;
+  readonly uniques: ReadonlyArray<SqlUniqueIR | SqlUniqueIRInput>;
+  readonly indexes: ReadonlyArray<SqlIndexIR | SqlIndexIRInput>;
+  readonly primaryKey?: PrimaryKey | PrimaryKeyInput;
+  readonly annotations?: SqlAnnotations;
+}
+
+/**
+ * Schema IR node for a single table as observed by introspection.
+ *
+ * Unlike the Contract IR `StorageTable`, this carries the table's
+ * `name` — introspection queries return tables as arrays and the
+ * verifier keys them into `SqlSchemaIR.tables` afterwards, so the name
+ * stays on the table object for downstream call sites that walk
+ * `Object.values(schema.tables)`.
+ *
+ * The constructor normalises nested IR-class fields so downstream
+ * walks see a uniform AST regardless of whether the input was a
+ * plain-data literal (from introspection) or already-constructed
+ * class instances.
+ */
+export class SqlTableIR extends SqlSchemaIRNode {
+  readonly name: string;
+  readonly columns: Readonly<Record<string, SqlColumnIR>>;
+  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;
+  readonly uniques: ReadonlyArray<SqlUniqueIR>;
+  readonly indexes: ReadonlyArray<SqlIndexIR>;
+  declare readonly primaryKey?: PrimaryKey;
+  declare readonly annotations?: SqlAnnotations;
+
+  constructor(input: SqlTableIRInput) {
+    super();
+    this.name = input.name;
+    this.columns = Object.freeze(
+      Object.fromEntries(
+        Object.entries(input.columns).map(([key, col]) => [
+          key,
+          col instanceof SqlColumnIR ? col : new SqlColumnIR(col),
+        ]),
+      ),
+    );
+    this.foreignKeys = Object.freeze(
+      input.foreignKeys.map((fk) => (fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk))),
+    );
+    this.uniques = Object.freeze(
+      input.uniques.map((u) => (u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u))),
+    );
+    this.indexes = Object.freeze(
+      input.indexes.map((i) => (i instanceof SqlIndexIR ? i : new SqlIndexIR(i))),
+    );
+    if (input.primaryKey !== undefined) {
+      this.primaryKey =
+        input.primaryKey instanceof PrimaryKey
+          ? input.primaryKey
+          : new PrimaryKey(input.primaryKey);
+    }
+    if (input.annotations !== undefined) this.annotations = input.annotations;
+    freezeNode(this);
+  }
+}

package/src/ir/sql-unique-ir.ts

@@ -0,0 +1,27 @@
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import type { SqlAnnotations } from './sql-column-ir';
+import { SqlSchemaIRNode } from './sql-schema-ir-node';
+
+export interface SqlUniqueIRInput {
+  readonly columns: readonly string[];
+  readonly name?: string;
+  readonly annotations?: SqlAnnotations;
+}
+
+/**
+ * Schema IR node for a table-level unique constraint as observed by
+ * introspection.
+ */
+export class SqlUniqueIR extends SqlSchemaIRNode {
+  readonly columns: readonly string[];
+  declare readonly name?: string;
+  declare readonly annotations?: SqlAnnotations;
+
+  constructor(input: SqlUniqueIRInput) {
+    super();
+    this.columns = [...input.columns];
+    if (input.name !== undefined) this.name = input.name;
+    if (input.annotations !== undefined) this.annotations = input.annotations;
+    freezeNode(this);
+  }
+}

package/src/types.ts

@@ -1,133 +1,54 @@
 /**
  * SQL Schema IR types for target-agnostic schema representation.
  *
- * These types represent the canonical in-memory representation of SQL schemas
- * for the SQL family, used for verification and future migration planning.
- */
-
-/**
- * Primary key definition matching Contract format.
- * Defined here to avoid circular dependency with sql-contract.
- */
-export type PrimaryKey = {
-  readonly columns: readonly string[];
-  readonly name?: string;
-};
-
-/**
- * Namespaced annotations for extensibility.
- * Each namespace (e.g., 'pg', 'pgvector') owns its annotations.
- */
-export type SqlAnnotations = {
-  readonly [namespace: string]: unknown;
-};
-
-/**
- * SQL column IR representing a column in a table.
- */
-export type SqlColumnIR = {
-  readonly name: string;
-  readonly nativeType: string; // explicit DB type, e.g. 'integer', 'vector'
-  readonly nullable: boolean;
-  readonly default?: string; // Raw database default expression (e.g., "'hello'::text", "nextval('seq')")
-  readonly annotations?: SqlAnnotations; // column-level metadata
-};
-
-/**
- * Referential action for foreign keys in the schema IR.
- * Defined here independently from the contract package to avoid coupling.
- */
-export type SqlReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
-
-/**
- * SQL foreign key IR.
- */
-export type SqlForeignKeyIR = {
-  readonly columns: readonly string[];
-  readonly referencedTable: string;
-  readonly referencedColumns: readonly string[];
-  readonly name?: string;
-  readonly onDelete?: SqlReferentialAction;
-  readonly onUpdate?: SqlReferentialAction;
-  readonly annotations?: SqlAnnotations;
-};
-
-/**
- * SQL unique constraint IR.
- */
-export type SqlUniqueIR = {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly annotations?: SqlAnnotations;
-};
-
-/**
- * SQL index IR.
- */
-export type SqlIndexIR = {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly unique: boolean;
-  readonly type?: string;
-  readonly options?: Record<string, unknown>;
-  readonly annotations?: SqlAnnotations;
-};
-
-/**
- * SQL table IR representing a table in the schema.
- * Primary key format matches Contract for consistency.
- */
-export type SqlTableIR = {
-  readonly name: string;
-  readonly columns: Record<string, SqlColumnIR>;
-  readonly primaryKey?: PrimaryKey; // Matches Contract format: { columns: string[]; name?: string }
-  readonly foreignKeys: readonly SqlForeignKeyIR[];
-  readonly uniques: readonly SqlUniqueIR[];
-  readonly indexes: readonly SqlIndexIR[];
-  readonly annotations?: SqlAnnotations; // table-level metadata
-};
-
-/**
- * SQL Schema IR representing the complete database schema.
- * This is the target-agnostic representation used for verification and migration planning.
- */
-export type SqlSchemaIR = {
-  readonly tables: Record<string, SqlTableIR>;
-  readonly annotations?: SqlAnnotations; // extensible global metadata
-};
-
-/**
- * SQL type metadata for control-plane and execution-plane type availability and mapping.
- * This abstraction provides a read-only view of type information without encode/decode behavior.
+ * These classes represent the canonical in-memory representation of
+ * SQL schemas for the SQL family, used for verification and migration
+ * planning. Each class extends `SqlSchemaIRNode` (the family base
+ * declared in `ir/sql-schema-ir-node.ts`) and carries `freezeNode`
+ * sealing in its constructor. `Input` interfaces describe the
+ * plain-data shape that introspection adapters produce.
+ */
+
+export { PrimaryKey, type PrimaryKeyInput } from './ir/primary-key';
+export {
+  type SqlAnnotations,
+  SqlColumnIR,
+  type SqlColumnIRInput,
+} from './ir/sql-column-ir';
+export {
+  SqlForeignKeyIR,
+  type SqlForeignKeyIRInput,
+  type SqlReferentialAction,
+} from './ir/sql-foreign-key-ir';
+export { SqlIndexIR, type SqlIndexIRInput } from './ir/sql-index-ir';
+export { SqlSchemaIR, type SqlSchemaIRInput } from './ir/sql-schema-ir';
+export { SqlSchemaIRNode } from './ir/sql-schema-ir-node';
+export { SqlTableIR, type SqlTableIRInput } from './ir/sql-table-ir';
+export { SqlUniqueIR, type SqlUniqueIRInput } from './ir/sql-unique-ir';
+
+/**
+ * SQL type metadata for control-plane and execution-plane type
+ * availability and mapping. Read-only view of type information
+ * without encode/decode behavior.
  */
 export interface SqlTypeMetadata {
-  /**
-   * Namespaced type identifier in format 'namespace/name@version'
-   * Examples: 'pg/int4@1', 'pg/text@1', 'pg/timestamptz@1'
-   */
+  /** Namespaced type identifier, e.g. `pg/int4@1`, `pg/text@1`. */
   readonly typeId: string;
 
-  /**
-   * Contract scalar type IDs that this type can handle.
-   * Examples: ['text'], ['int4', 'float8'], ['timestamp', 'timestamptz']
-   */
+  /** Contract scalar type IDs this type can handle. */
   readonly targetTypes: readonly string[];
 
   /**
-   * Native database type name (target-specific).
-   * Examples: 'integer', 'text', 'character varying', 'timestamp with time zone'
-   * This is optional because not all types have a native database representation.
+   * Native database type name (target-specific). Optional because
+   * not all types have a native database representation.
    */
   readonly nativeType?: string;
 }
 
 /**
- * Registry interface for SQL type metadata.
- * Provides read-only iteration over type metadata entries.
+ * Registry interface for SQL type metadata. Provides read-only
+ * iteration over type metadata entries.
  */
 export interface SqlTypeMetadataRegistry {
-  /**
-   * Returns an iterator over all type metadata entries.
-   */
   values(): IterableIterator<SqlTypeMetadata>;
 }

package/dist/types-BNW257Ug.d.mts

@@ -1,124 +0,0 @@
-//#region src/types.d.ts
-/**
- * SQL Schema IR types for target-agnostic schema representation.
- *
- * These types represent the canonical in-memory representation of SQL schemas
- * for the SQL family, used for verification and future migration planning.
- */
-/**
- * Primary key definition matching Contract format.
- * Defined here to avoid circular dependency with sql-contract.
- */
-type PrimaryKey = {
-  readonly columns: readonly string[];
-  readonly name?: string;
-};
-/**
- * Namespaced annotations for extensibility.
- * Each namespace (e.g., 'pg', 'pgvector') owns its annotations.
- */
-type SqlAnnotations = {
-  readonly [namespace: string]: unknown;
-};
-/**
- * SQL column IR representing a column in a table.
- */
-type SqlColumnIR = {
-  readonly name: string;
-  readonly nativeType: string;
-  readonly nullable: boolean;
-  readonly default?: string;
-  readonly annotations?: SqlAnnotations;
-};
-/**
- * Referential action for foreign keys in the schema IR.
- * Defined here independently from the contract package to avoid coupling.
- */
-type SqlReferentialAction = 'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault';
-/**
- * SQL foreign key IR.
- */
-type SqlForeignKeyIR = {
-  readonly columns: readonly string[];
-  readonly referencedTable: string;
-  readonly referencedColumns: readonly string[];
-  readonly name?: string;
-  readonly onDelete?: SqlReferentialAction;
-  readonly onUpdate?: SqlReferentialAction;
-  readonly annotations?: SqlAnnotations;
-};
-/**
- * SQL unique constraint IR.
- */
-type SqlUniqueIR = {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly annotations?: SqlAnnotations;
-};
-/**
- * SQL index IR.
- */
-type SqlIndexIR = {
-  readonly columns: readonly string[];
-  readonly name?: string;
-  readonly unique: boolean;
-  readonly type?: string;
-  readonly options?: Record<string, unknown>;
-  readonly annotations?: SqlAnnotations;
-};
-/**
- * SQL table IR representing a table in the schema.
- * Primary key format matches Contract for consistency.
- */
-type SqlTableIR = {
-  readonly name: string;
-  readonly columns: Record<string, SqlColumnIR>;
-  readonly primaryKey?: PrimaryKey;
-  readonly foreignKeys: readonly SqlForeignKeyIR[];
-  readonly uniques: readonly SqlUniqueIR[];
-  readonly indexes: readonly SqlIndexIR[];
-  readonly annotations?: SqlAnnotations;
-};
-/**
- * SQL Schema IR representing the complete database schema.
- * This is the target-agnostic representation used for verification and migration planning.
- */
-type SqlSchemaIR = {
-  readonly tables: Record<string, SqlTableIR>;
-  readonly annotations?: SqlAnnotations;
-};
-/**
- * SQL type metadata for control-plane and execution-plane type availability and mapping.
- * This abstraction provides a read-only view of type information without encode/decode behavior.
- */
-interface SqlTypeMetadata {
-  /**
-   * Namespaced type identifier in format 'namespace/name@version'
-   * Examples: 'pg/int4@1', 'pg/text@1', 'pg/timestamptz@1'
-   */
-  readonly typeId: string;
-  /**
-   * Contract scalar type IDs that this type can handle.
-   * Examples: ['text'], ['int4', 'float8'], ['timestamp', 'timestamptz']
-   */
-  readonly targetTypes: readonly string[];
-  /**
-   * Native database type name (target-specific).
-   * Examples: 'integer', 'text', 'character varying', 'timestamp with time zone'
-   * This is optional because not all types have a native database representation.
-   */
-  readonly nativeType?: string;
-}
-/**
- * Registry interface for SQL type metadata.
- * Provides read-only iteration over type metadata entries.
- */
-interface SqlTypeMetadataRegistry {
-  /**
-   * Returns an iterator over all type metadata entries.
-   */
-  values(): IterableIterator<SqlTypeMetadata>;
-}
-//#endregion
-export { SqlIndexIR as a, SqlTableIR as c, SqlUniqueIR as d, SqlForeignKeyIR as i, SqlTypeMetadata as l, SqlAnnotations as n, SqlReferentialAction as o, SqlColumnIR as r, SqlSchemaIR as s, PrimaryKey as t, SqlTypeMetadataRegistry as u };
-//# sourceMappingURL=types-BNW257Ug.d.mts.map

package/dist/types-BNW257Ug.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-BNW257Ug.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;AAWA;;;;;AASA;;;;AAAA,KATY,UAAA;EAAA,SACD,OAAA;EAAA,SACA,IAAA;AAAA;;;;;KAOC,cAAA;EAAA,UACA,SAAA;AAAA;;;AAkBZ;KAZY,WAAA;EAAA,SACD,IAAA;EAAA,SACA,UAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,WAAA,GAAc,cAAA;AAAA;;;;;KAOb,oBAAA;;;;KAKA,eAAA;EAAA,SACD,OAAA;EAAA,SACA,eAAA;EAAA,SACA,iBAAA;EAAA,SACA,IAAA;EAAA,SACA,QAAA,GAAW,oBAAA;EAAA,SACX,QAAA,GAAW,oBAAA;EAAA,SACX,WAAA,GAAc,cAAA;AAAA;AAMzB;;;AAAA,KAAY,WAAA;EAAA,SACD,OAAA;EAAA,SACA,IAAA;EAAA,SACA,WAAA,GAAc,cAAA;AAAA;;;AAMzB;KAAY,UAAA;EAAA,SACD,OAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA,GAAU,MAAA;EAAA,SACV,WAAA,GAAc,cAAA;AAAA;;;;;KAOb,UAAA;EAAA,SACD,IAAA;EAAA,SACA,OAAA,EAAS,MAAA,SAAe,WAAA;EAAA,SACxB,UAAA,GAAa,UAAA;EAAA,SACb,WAAA,WAAsB,eAAA;EAAA,SACtB,OAAA,WAAkB,WAAA;EAAA,SAClB,OAAA,WAAkB,UAAA;EAAA,SAClB,WAAA,GAAc,cAAA;AAAA;;;;;KAOb,WAAA;EAAA,SACD,MAAA,EAAQ,MAAA,SAAe,UAAA;EAAA,SACvB,WAAA,GAAc,cAAA;AAAA;;;;;UAOR,eAAA;EAlBY;;;;EAAA,SAuBlB,MAAA;EArB4B;;AAOvC;;EAPuC,SA2B5B,WAAA;EAnBuB;;;;;EAAA,SA0BvB,UAAA;AAAA;;;;;UAOM,uBAAA;EAzBA;;;EA6Bf,MAAA,IAAU,gBAAA,CAAiB,eAAA;AAAA"}