@prisma-next/sql-schema-ir 0.14.0-dev.8 → 0.14.0-dev.81

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

@@ -1,6 +1,9 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
 import { freezeNode } from '@prisma-next/framework-components/ir';
+import { blindCast } from '@prisma-next/utils/casts';
+import { RelationalSchemaNodeKind } from './schema-node-kinds';
 import type { SqlAnnotations } from './sql-column-ir';
-import { SqlSchemaIRNode } from './sql-schema-ir-node';
+import { assertNode, SqlSchemaIRNode } from './sql-schema-ir-node';
 
 export interface SqlIndexIRInput {
   readonly columns: readonly string[];
@@ -17,8 +20,18 @@ export interface SqlIndexIRInput {
  * `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.
+ *
+ * Implements `DiffableNode` so an index is directly a table's diff-tree
+ * child. Indexes are frequently unnamed, so `id` is derived from the column
+ * tuple — the same tuple that makes two indexes the same index, so it
+ * doubles as the pairing key. `isEqualTo` is symmetric structural equality
+ * on the remaining attributes: `unique`, `type`, and `options`. A unique
+ * index and a non-unique index on the same columns are different objects
+ * and are not equal — there is no "stronger satisfies weaker".
  */
-export class SqlIndexIR extends SqlSchemaIRNode {
+export class SqlIndexIR extends SqlSchemaIRNode implements DiffableNode {
+  override readonly nodeKind = RelationalSchemaNodeKind.index;
+
   readonly columns: readonly string[];
   readonly unique: boolean;
   declare readonly name?: string;
@@ -36,4 +49,62 @@ export class SqlIndexIR extends SqlSchemaIRNode {
     if (input.annotations !== undefined) this.annotations = input.annotations;
     freezeNode(this);
   }
+
+  get id(): string {
+    return `index:${this.columns.join(',')}`;
+  }
+
+  children(): readonly DiffableNode[] {
+    return [];
+  }
+
+  static is(node: SqlSchemaIRNode): node is SqlIndexIR {
+    return node.nodeKind === RelationalSchemaNodeKind.index;
+  }
+
+  /**
+   * Symmetric structural equality: two paired index nodes are equal iff their
+   * `unique` flag, `type`, and (loosely-compared) `options` all match. There
+   * is no satisfaction — a unique index does not equal a non-unique index.
+   * `options` compares loosely (introspection stringifies reloptions); `type`
+   * compares strictly after the introspection-side btree→undefined
+   * normalization done at construction.
+   */
+  isEqualTo(other: DiffableNode): boolean {
+    const node = blindCast<
+      SqlSchemaIRNode,
+      'every diff-tree node the differ pairs is a SqlSchemaIRNode'
+    >(other);
+    assertNode(node, 'SqlIndexIR', SqlIndexIR.is);
+    return (
+      this.unique === node.unique &&
+      this.type === node.type &&
+      indexOptionsLooselyEqual(this.options, node.options)
+    );
+  }
+}
+
+/**
+ * Option-bag equality ported from the relational walk: same key set, values
+ * compared via `String()` coercion — Postgres introspection returns
+ * reloptions values as raw strings (`'70'`, `'false'`) while contract option
+ * leaves are typed (number, boolean, string).
+ */
+function indexOptionsLooselyEqual(
+  a: Record<string, unknown> | undefined,
+  b: Record<string, unknown> | undefined,
+): boolean {
+  const aKeys = a ? Object.keys(a).sort() : [];
+  const bKeys = b ? Object.keys(b).sort() : [];
+  if (aKeys.length !== bKeys.length) return false;
+  for (let i = 0; i < aKeys.length; i += 1) {
+    if (aKeys[i] !== bKeys[i]) return false;
+  }
+  if (aKeys.length === 0) return true;
+  for (const key of aKeys) {
+    if (String(a?.[key]) !== String(b?.[key])) {
+      return false;
+    }
+  }
+  return true;
 }

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

@@ -7,20 +7,32 @@ import { IRNodeBase } from '@prisma-next/framework-components/ir';
  *
  * 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.
+ * desired state).
  *
  * 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.
+ * for dispatch.
+ *
+ * Both `kind` and `nodeKind` are required: every concrete leaf is a node
+ * the generic differ can pair and compare, so every leaf must declare which
+ * node it is. `nodeKind` has no default here — every direct subclass sets its
+ * own literal value (the relational leaves via `RelationalSchemaNodeKind`,
+ * target concretions via their own vocabulary, e.g. `PostgresSchemaNodeKind`).
  */
 export abstract class SqlSchemaIRNode extends IRNodeBase {
-  readonly kind?: string;
+  declare readonly kind: string;
+
+  /**
+   * Enumerable discriminant identifying which node this is (column / primary
+   * key / foreign key / unique / index / check / database / namespace /
+   * table / policy / role / …). Concretions set a unique value; the
+   * `.is`/`.assert` guards compare against it. Unlike `kind`, it is
+   * enumerable, so it survives a spread that flattens a node into a plain
+   * object.
+   */
+  abstract readonly nodeKind: string;
 
   constructor() {
     super();
@@ -32,3 +44,42 @@ export abstract class SqlSchemaIRNode extends IRNodeBase {
     });
   }
 }
+
+/**
+ * Asserts `node` matches `predicate`, narrowing its type to `T`. The one
+ * shared implementation every node class's `static assert` and `isEqualTo`
+ * reach for, instead of each hand-writing its own throw: the message names
+ * the class the caller expected.
+ */
+export function assertNode<T extends SqlSchemaIRNode>(
+  node: SqlSchemaIRNode | undefined,
+  className: string,
+  predicate: (node: SqlSchemaIRNode) => node is T,
+): asserts node is T {
+  if (node === undefined || !predicate(node)) {
+    throw new Error(`Expected a ${className} but got nodeKind=${node?.nodeKind ?? 'undefined'}`);
+  }
+}
+
+/**
+ * Defines a non-enumerable own property, the same treatment `kind` gets
+ * above: a derivation-time render-support field stays out of
+ * `JSON.stringify`, `toEqual({...})` structural assertions, and spreads,
+ * while remaining directly readable (`node.field`) for the one consumer
+ * that resolves it at plan time. A no-op when `value` is `undefined` — the
+ * property is simply absent, matching every other optional field on these
+ * nodes.
+ */
+export function defineNonEnumerable<T extends object>(
+  target: T,
+  key: string,
+  value: unknown,
+): void {
+  if (value === undefined) return;
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    writable: false,
+    configurable: false,
+  });
+}

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

@@ -1,4 +1,6 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
 import { freezeNode } from '@prisma-next/framework-components/ir';
+import { RelationalSchemaNodeKind } from './schema-node-kinds';
 import type { SqlAnnotations } from './sql-column-ir';
 import { SqlSchemaIRNode } from './sql-schema-ir-node';
 import { SqlTableIR, type SqlTableIRInput } from './sql-table-ir';
@@ -17,8 +19,15 @@ export interface SqlSchemaIRInput {
  * 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.
+ *
+ * Implements `DiffableNode` as the root of a flat (single-schema) diff
+ * tree: `id` is the fixed sentinel `'database'` (roots have no siblings),
+ * `isEqualTo` is identity (a container has no own attributes), and
+ * `children()` yields the table nodes.
  */
-export class SqlSchemaIR extends SqlSchemaIRNode {
+export class SqlSchemaIR extends SqlSchemaIRNode implements DiffableNode {
+  override readonly nodeKind = RelationalSchemaNodeKind.schema;
+
   readonly tables: Readonly<Record<string, SqlTableIR>>;
   declare readonly annotations?: SqlAnnotations;
 
@@ -35,4 +44,16 @@ export class SqlSchemaIR extends SqlSchemaIRNode {
     if (input.annotations !== undefined) this.annotations = input.annotations;
     freezeNode(this);
   }
+
+  get id(): string {
+    return 'database';
+  }
+
+  isEqualTo(other: DiffableNode): boolean {
+    return this.id === other.id;
+  }
+
+  children(): readonly DiffableNode[] {
+    return Object.values(this.tables);
+  }
 }

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

@@ -1,5 +1,7 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { PrimaryKey, type PrimaryKeyInput } from './primary-key';
+import { RelationalSchemaNodeKind } from './schema-node-kinds';
 import { SqlCheckConstraintIR, type SqlCheckConstraintIRInput } from './sql-check-constraint-ir';
 import { type SqlAnnotations, SqlColumnIR, type SqlColumnIRInput } from './sql-column-ir';
 import { SqlForeignKeyIR, type SqlForeignKeyIRInput } from './sql-foreign-key-ir';
@@ -32,8 +34,17 @@ export interface SqlTableIRInput {
  * walks see a uniform AST regardless of whether the input was a
  * plain-data literal (from introspection) or already-constructed
  * class instances.
+ *
+ * Implements `DiffableNode` so a flat (single-schema) tree is directly
+ * diffable: `id` is the table name; `isEqualTo` is identity (the table's
+ * structural drift is entirely expressed by its children); `children()`
+ * yields every column, the primary key (when present), every foreign key,
+ * unique, index, and check constraint — the same composition and order as
+ * the Postgres table node, minus policies.
  */
-export class SqlTableIR extends SqlSchemaIRNode {
+export class SqlTableIR extends SqlSchemaIRNode implements DiffableNode {
+  override readonly nodeKind = RelationalSchemaNodeKind.table;
+
   readonly name: string;
   readonly columns: Readonly<Record<string, SqlColumnIR>>;
   readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;
@@ -79,4 +90,23 @@ export class SqlTableIR extends SqlSchemaIRNode {
     }
     freezeNode(this);
   }
+
+  get id(): string {
+    return this.name;
+  }
+
+  isEqualTo(other: DiffableNode): boolean {
+    return this.id === other.id;
+  }
+
+  children(): readonly DiffableNode[] {
+    return [
+      ...Object.values(this.columns),
+      ...(this.primaryKey ? [this.primaryKey] : []),
+      ...this.foreignKeys,
+      ...this.uniques,
+      ...this.indexes,
+      ...(this.checks ?? []),
+    ];
+  }
 }

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

@@ -1,6 +1,9 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
 import { freezeNode } from '@prisma-next/framework-components/ir';
+import { blindCast } from '@prisma-next/utils/casts';
+import { RelationalSchemaNodeKind } from './schema-node-kinds';
 import type { SqlAnnotations } from './sql-column-ir';
-import { SqlSchemaIRNode } from './sql-schema-ir-node';
+import { assertNode, SqlSchemaIRNode } from './sql-schema-ir-node';
 
 export interface SqlUniqueIRInput {
   readonly columns: readonly string[];
@@ -11,8 +14,17 @@ export interface SqlUniqueIRInput {
 /**
  * Schema IR node for a table-level unique constraint as observed by
  * introspection.
+ *
+ * Implements `DiffableNode` so a unique constraint is directly a table's
+ * diff-tree child. Unique constraints are frequently unnamed, so `id` is
+ * derived from the column tuple rather than `name` — the column tuple is
+ * also what makes two unique constraints the same constraint, so it doubles
+ * as the pairing key. There are no further attributes to compare once
+ * columns are equal (the differ pairs on `id`), so `isEqualTo` is identity.
  */
-export class SqlUniqueIR extends SqlSchemaIRNode {
+export class SqlUniqueIR extends SqlSchemaIRNode implements DiffableNode {
+  override readonly nodeKind = RelationalSchemaNodeKind.unique;
+
   readonly columns: readonly string[];
   declare readonly name?: string;
   declare readonly annotations?: SqlAnnotations;
@@ -24,4 +36,25 @@ export class SqlUniqueIR extends SqlSchemaIRNode {
     if (input.annotations !== undefined) this.annotations = input.annotations;
     freezeNode(this);
   }
+
+  get id(): string {
+    return `unique:${this.columns.join(',')}`;
+  }
+
+  children(): readonly DiffableNode[] {
+    return [];
+  }
+
+  static is(node: SqlSchemaIRNode): node is SqlUniqueIR {
+    return node.nodeKind === RelationalSchemaNodeKind.unique;
+  }
+
+  isEqualTo(other: DiffableNode): boolean {
+    const node = blindCast<
+      SqlSchemaIRNode,
+      'every diff-tree node the differ pairs is a SqlSchemaIRNode'
+    >(other);
+    assertNode(node, 'SqlUniqueIR', SqlUniqueIR.is);
+    return this.id === node.id;
+  }
 }

package/src/types.ts

@@ -10,10 +10,19 @@
  */
 
 export { PrimaryKey, type PrimaryKeyInput } from './ir/primary-key';
+export {
+  RelationalSchemaNodeKind,
+  relationalNodeEntityKind,
+  relationalNodeGranularity,
+} from './ir/schema-node-kinds';
 export {
   SqlCheckConstraintIR,
   type SqlCheckConstraintIRInput,
 } from './ir/sql-check-constraint-ir';
+export {
+  SqlColumnDefaultIR,
+  type SqlColumnDefaultIRInput,
+} from './ir/sql-column-default-ir';
 export {
   type SqlAnnotations,
   SqlColumnIR,
@@ -26,7 +35,7 @@ export {
 } 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 { assertNode, 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';
 

package/dist/types-C0WFfEkA.mjs

@@ -1,220 +0,0 @@
-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-check-constraint-ir.ts
-/**
-* Schema IR node for a table-level check constraint that restricts a
-* column to a set of permitted values (an enum-style `IN (...)` check).
-*
-* Carries the **resolved values** rather than a raw SQL predicate so
-* callers can compare value-sets without parsing SQL.
-*/
-var SqlCheckConstraintIR = class extends SqlSchemaIRNode {
-	name;
-	column;
-	permittedValues;
-	constructor(input) {
-		super();
-		this.name = input.name;
-		this.column = input.column;
-		this.permittedValues = Object.freeze([...input.permittedValues]);
-		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.referencedSchema !== void 0) this.referencedSchema = input.referencedSchema;
-		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;
-		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((c) => c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c)));
-		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, PrimaryKey as c, SqlIndexIR as i, SqlSchemaIRNode as l, SqlTableIR as n, SqlColumnIR as o, SqlUniqueIR as r, SqlCheckConstraintIR as s, SqlSchemaIR as t };
-
-//# sourceMappingURL=types-C0WFfEkA.mjs.map

package/dist/types-C0WFfEkA.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-C0WFfEkA.mjs","names":[],"sources":["../src/ir/sql-schema-ir-node.ts","../src/ir/primary-key.ts","../src/ir/sql-check-constraint-ir.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\nexport interface SqlCheckConstraintIRInput {\n  /** Constraint name as stored in the database catalog. */\n  readonly name: string;\n  /** Column the check restricts. */\n  readonly column: string;\n  /** Permitted values the column must be IN. */\n  readonly permittedValues: readonly string[];\n}\n\n/**\n * Schema IR node for a table-level check constraint that restricts a\n * column to a set of permitted values (an enum-style `IN (...)` check).\n *\n * Carries the **resolved values** rather than a raw SQL predicate so\n * callers can compare value-sets without parsing SQL.\n */\nexport class SqlCheckConstraintIR extends SqlSchemaIRNode {\n  readonly name: string;\n  readonly column: string;\n  readonly permittedValues: readonly string[];\n\n  constructor(input: SqlCheckConstraintIRInput) {\n    super();\n    this.name = input.name;\n    this.column = input.column;\n    this.permittedValues = Object.freeze([...input.permittedValues]);\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  /** Schema (namespace) of the referenced table — populated by adapters that introspect cross-schema FKs. */\n  readonly referencedSchema?: 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 referencedSchema?: 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.referencedSchema !== undefined) this.referencedSchema = input.referencedSchema;\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 { SqlCheckConstraintIR, type SqlCheckConstraintIRInput } from './sql-check-constraint-ir';\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  /** Optional check constraints for enum-restricted columns. Omitted when none present. */\n  readonly checks?: ReadonlyArray<SqlCheckConstraintIR | SqlCheckConstraintIRInput>;\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  declare readonly checks?: ReadonlyArray<SqlCheckConstraintIR>;\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    if (input.checks !== undefined && input.checks.length > 0) {\n      this.checks = Object.freeze(\n        input.checks.map((c) =>\n          c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c),\n        ),\n      );\n    }\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":";;;;;;;;;;;;;;;;;;;;;AAqBA,IAAsB,kBAAtB,cAA8C,WAAW;CACvD;CAEA,cAAc;EACZ,MAAM;EACN,OAAO,eAAe,MAAM,QAAQ;GAClC,OAAO;GACP,UAAU;GACV,YAAY;GACZ,cAAc;EAChB,CAAC;CACH;AACF;;;;;;;;;ACnBA,IAAa,aAAb,cAAgC,gBAAgB;CAC9C;CAGA,YAAY,OAAwB;EAClC,MAAM;EACN,KAAK,UAAU,MAAM;EACrB,IAAI,MAAM,SAAS,KAAA,GAAW,KAAK,OAAO,MAAM;EAChD,WAAW,IAAI;CACjB;AACF;;;;;;;;;;ACLA,IAAa,uBAAb,cAA0C,gBAAgB;CACxD;CACA;CACA;CAEA,YAAY,OAAkC;EAC5C,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,SAAS,MAAM;EACpB,KAAK,kBAAkB,OAAO,OAAO,CAAC,GAAG,MAAM,eAAe,CAAC;EAC/D,WAAW,IAAI;CACjB;AACF;;;;;;;;;;ACJA,IAAa,cAAb,cAAiC,gBAAgB;CAC/C;CACA;CACA;CAIA,YAAY,OAAyB;EACnC,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,aAAa,MAAM;EACxB,KAAK,WAAW,MAAM;EACtB,IAAI,MAAM,YAAY,KAAA,GAAW,KAAK,UAAU,MAAM;EACtD,IAAI,MAAM,gBAAgB,KAAA,GAAW,KAAK,cAAc,MAAM;EAC9D,WAAW,IAAI;CACjB;AACF;;;;;;;;;;;ACjBA,IAAa,kBAAb,cAAqC,gBAAgB;CACnD;CACA;CACA;CAOA,YAAY,OAA6B;EACvC,MAAM;EACN,KAAK,UAAU,MAAM;EACrB,KAAK,kBAAkB,MAAM;EAC7B,KAAK,oBAAoB,MAAM;EAC/B,IAAI,MAAM,qBAAqB,KAAA,GAAW,KAAK,mBAAmB,MAAM;EACxE,IAAI,MAAM,SAAS,KAAA,GAAW,KAAK,OAAO,MAAM;EAChD,IAAI,MAAM,aAAa,KAAA,GAAW,KAAK,WAAW,MAAM;EACxD,IAAI,MAAM,aAAa,KAAA,GAAW,KAAK,WAAW,MAAM;EACxD,IAAI,MAAM,gBAAgB,KAAA,GAAW,KAAK,cAAc,MAAM;EAC9D,WAAW,IAAI;CACjB;AACF;;;;;;;;;;AC5BA,IAAa,aAAb,cAAgC,gBAAgB;CAC9C;CACA;CAMA,YAAY,OAAwB;EAClC,MAAM;EACN,KAAK,UAAU,MAAM;EACrB,KAAK,SAAS,MAAM;EACpB,IAAI,MAAM,SAAS,KAAA,GAAW,KAAK,OAAO,MAAM;EAChD,IAAI,MAAM,SAAS,KAAA,GAAW,KAAK,OAAO,MAAM;EAChD,IAAI,MAAM,YAAY,KAAA,GAAW,KAAK,UAAU,MAAM;EACtD,IAAI,MAAM,gBAAgB,KAAA,GAAW,KAAK,cAAc,MAAM;EAC9D,WAAW,IAAI;CACjB;AACF;;;;;;;ACxBA,IAAa,cAAb,cAAiC,gBAAgB;CAC/C;CAIA,YAAY,OAAyB;EACnC,MAAM;EACN,KAAK,UAAU,CAAC,GAAG,MAAM,OAAO;EAChC,IAAI,MAAM,SAAS,KAAA,GAAW,KAAK,OAAO,MAAM;EAChD,IAAI,MAAM,gBAAgB,KAAA,GAAW,KAAK,cAAc,MAAM;EAC9D,WAAW,IAAI;CACjB;AACF;;;;;;;;;;;;;;;;;ACSA,IAAa,aAAb,cAAgC,gBAAgB;CAC9C;CACA;CACA;CACA;CACA;CAKA,YAAY,OAAwB;EAClC,MAAM;EACN,KAAK,OAAO,MAAM;EAClB,KAAK,UAAU,OAAO,OACpB,OAAO,YACL,OAAO,QAAQ,MAAM,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,SAAS,CAChD,KACA,eAAe,cAAc,MAAM,IAAI,YAAY,GAAG,CACxD,CAAC,CACH,CACF;EACA,KAAK,cAAc,OAAO,OACxB,MAAM,YAAY,KAAK,OAAQ,cAAc,kBAAkB,KAAK,IAAI,gBAAgB,EAAE,CAAE,CAC9F;EACA,KAAK,UAAU,OAAO,OACpB,MAAM,QAAQ,KAAK,MAAO,aAAa,cAAc,IAAI,IAAI,YAAY,CAAC,CAAE,CAC9E;EACA,KAAK,UAAU,OAAO,OACpB,MAAM,QAAQ,KAAK,MAAO,aAAa,aAAa,IAAI,IAAI,WAAW,CAAC,CAAE,CAC5E;EACA,IAAI,MAAM,eAAe,KAAA,GACvB,KAAK,aACH,MAAM,sBAAsB,aACxB,MAAM,aACN,IAAI,WAAW,MAAM,UAAU;EAEvC,IAAI,MAAM,gBAAgB,KAAA,GAAW,KAAK,cAAc,MAAM;EAC9D,IAAI,MAAM,WAAW,KAAA,KAAa,MAAM,OAAO,SAAS,GACtD,KAAK,SAAS,OAAO,OACnB,MAAM,OAAO,KAAK,MAChB,aAAa,uBAAuB,IAAI,IAAI,qBAAqB,CAAC,CACpE,CACF;EAEF,WAAW,IAAI;CACjB;AACF;;;;;;;;;;;;;AC7DA,IAAa,cAAb,cAAiC,gBAAgB;CAC/C;CAGA,YAAY,OAAyB;EACnC,MAAM;EACN,KAAK,SAAS,OAAO,OACnB,OAAO,YACL,OAAO,QAAQ,MAAM,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,OAAO,CAC7C,KACA,aAAa,aAAa,IAAI,IAAI,WAAW,CAAC,CAChD,CAAC,CACH,CACF;EACA,IAAI,MAAM,gBAAgB,KAAA,GAAW,KAAK,cAAc,MAAM;EAC9D,WAAW,IAAI;CACjB;AACF"}