@prisma-next/target-postgres 0.14.0-dev.39 → 0.14.0-dev.40

package/dist/postgres-schema-ir-BJl_a3J7.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-schema-ir-BJl_a3J7.d.mts","names":[],"sources":["../src/core/schema-ir/postgres-table-ir.ts","../src/core/schema-ir/postgres-schema-ir.ts"],"mappings":";;;;;;UAeiB,oBAAA,SAA6B,eAAe;EAAA,SAClD,WAAA,YAAuB,iBAAA;AAAA;AADlC;;;;;;;;AACmD;AAenD;;;AAhBA,cAgBa,eAAA,SAAwB,eAAA,YAA2B,YAAA;EAAA,SACrD,IAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,WAAA;EAAA,SACjC,WAAA,EAAa,aAAA,CAAc,eAAA;EAAA,SAC3B,OAAA,EAAS,aAAA,CAAc,WAAA;EAAA,SACvB,OAAA,EAAS,aAAA,CAAc,UAAA;EAAA,SACf,UAAA,GAAa,UAAA;EAAA,SACb,WAAA,GAAc,cAAA;EAAA,SACd,MAAA,GAAS,aAAA,CAAc,oBAAA;EAAA,SAC/B,WAAA,WAAsB,iBAAA;cAEnB,KAAA,EAAO,oBAAA;EAAA,IAsCf,EAAA;EAIJ,SAAA,CAAU,MAAA,EAAQ,YAAA;EAIlB,QAAA,aAAqB,YAAA;AAAA;AAAA,iBAKP,iBAAA,CAAkB,IAAA,EAAM,YAAA,GAAe,IAAA,IAAQ,eAAe;;;UC/E7D,qBAAA;EAAA,SACN,MAAA,EAAQ,MAAA,SAEf,eAAA,IAAmB,eAAA;IAAoB,WAAA,YAAuB,iBAAA;EAAA;EAAA,SAEvD,YAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA,WAAgB,YAAA;EAAA,SAChB,eAAA;EAAA,SACA,mBAAA;AAAA;ADQX;;;;;;;;;;;;;;;;;AAAA,cCYa,gBAAA,SAAyB,eAAA,YAA2B,YAAA;EAAA,SACtD,UAAA,EAAY,eAAA;EAAA,SACZ,MAAA,EAAQ,QAAA,CAAS,MAAA,SAAe,eAAA;EAAA,SACxB,WAAA,GAAc,cAAA;EAAA,SACtB,YAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA,WAAgB,YAAA;EAAA,SAChB,eAAA;EAAA,SACA,mBAAA;cAEG,KAAA,EAAO,qBAAA;EAAA,IAgCf,EAAA;EAAA,IAIA,WAAA,aAAwB,iBAAA;EAI5B,SAAA,CAAU,MAAA,EAAQ,YAAA;EAIlB,QAAA,aAAqB,YAAA;AAAA;;;;;;;;;;;iBAeP,kBAAA,CAAmB,MAAA,EAAQ,WAAA,GAAc,MAAA,IAAU,gBAAgB;AAAA,iBAInE,sBAAA,CAAuB,MAAA,EAAQ,WAAA,WAAsB,MAAA,IAAU,gBAAgB;;;;;;iBAa/E,sBAAA,CAAuB,MAAA,EAAQ,gBAAA,GAAmB,gBAAgB"}

package/dist/postgres-schema-ir-I_FiUndw.mjs

@@ -1,133 +0,0 @@
-import { blindCast } from "@prisma-next/utils/casts";
-import { freezeNode } from "@prisma-next/framework-components/ir";
-import { PrimaryKey, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIRNode, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
-//#region src/core/schema-ir/postgres-table-ir.ts
-/**
-* Postgres-specific table IR node. Carries all `SqlTableIR` fields plus
-* `rlsPolicies`, and implements `DiffableNode` so the table instance is
-* directly the diff-tree node — no separate wrapper needed.
-*
-* Extends `SqlSchemaIRNode` directly rather than `SqlTableIR` because
-* `SqlTableIR` calls `freezeNode` in its own constructor, which prevents
-* subclass field initialisation. Same pattern as `PostgresSchemaIR`.
-*
-* `id` is the table name. `children()` returns the policies on this table.
-* `isEqualTo` is always true — table-level attributes are not diffed yet.
-*/
-var PostgresTableIR = class extends SqlSchemaIRNode {
-	name;
-	columns;
-	foreignKeys;
-	uniques;
-	indexes;
-	rlsPolicies;
-	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)));
-		this.rlsPolicies = Object.freeze([...input.rlsPolicies ?? []]);
-		freezeNode(this);
-	}
-	get id() {
-		return this.name;
-	}
-	isEqualTo(_other) {
-		return true;
-	}
-	children() {
-		return this.rlsPolicies;
-	}
-};
-function isPostgresTableIR(node) {
-	return node instanceof PostgresTableIR;
-}
-//#endregion
-//#region src/core/schema-ir/postgres-schema-ir.ts
-/**
-* Postgres-specific schema IR. Mirrors the structure of `SqlSchemaIR`
-* (same `tables` + optional `annotations` fields) and adds typed fields for
-* data the postgres adapter collects during introspection.
-*
-* Extends `SqlSchemaIRNode` directly rather than `SqlSchemaIR` because
-* `SqlSchemaIR` calls `freezeNode` in its constructor, which prevents
-* subclass field initialisation. `PostgresSchemaIR` replicates the minimal
-* `SqlSchemaIR` structure and freezes itself at the end of its own
-* constructor.
-*
-* `tables` holds `PostgresTableIR` instances which carry their own RLS
-* policies. `children()` returns the tables directly — the table instances
-* ARE the diff-tree nodes.
-*
-* Nothing RLS-specific leaks into the sql-family layer.
-*/
-var PostgresSchemaIR = class extends SqlSchemaIRNode {
-	nodeTarget = "postgres";
-	tables;
-	pgSchemaName;
-	pgVersion;
-	roles;
-	existingSchemas;
-	nativeEnumTypeNames;
-	constructor(input) {
-		super();
-		this.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables).map(([key, t]) => [key, t instanceof PostgresTableIR ? t : new PostgresTableIR(t)])));
-		this.pgSchemaName = input.pgSchemaName;
-		this.pgVersion = input.pgVersion;
-		this.roles = Object.freeze([...input.roles]);
-		this.existingSchemas = Object.freeze([...input.existingSchemas]);
-		this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);
-		this.annotations = { pg: {
-			schema: input.pgSchemaName,
-			...input.nativeEnumTypeNames.length > 0 && { nativeEnumTypeNames: input.nativeEnumTypeNames },
-			...input.existingSchemas.length > 0 && { existingSchemas: input.existingSchemas }
-		} };
-		freezeNode(this);
-	}
-	get id() {
-		return this.pgSchemaName;
-	}
-	get rlsPolicies() {
-		return Object.values(this.tables).flatMap((t) => t.rlsPolicies);
-	}
-	isEqualTo(_other) {
-		return true;
-	}
-	children() {
-		return Object.values(this.tables);
-	}
-};
-/**
-* Structural guard for `PostgresSchemaIR`, narrowing on the `nodeTarget`
-* discriminant rather than `instanceof`. `nodeTarget` is an enumerable own field
-* (a plain class-field initializer), so it survives the `{ ...schema, tables }`
-* spread the multi-space verify path (`projectSchemaToSpace`) produces — that
-* projected object is not a class instance but retains every enumerable own
-* property. The family-level `kind = 'sql-schema-ir'` discriminator is unusable
-* here: it is shared by every SQL schema-IR node and is non-enumerable (dropped
-* by the spread).
-*/
-function isPostgresSchemaIR(schema) {
-	return schema.nodeTarget === "postgres";
-}
-function assertPostgresSchemaIR(schema) {
-	if (!isPostgresSchemaIR(schema)) throw new Error(`planPostgresSchemaDiff: expected a PostgresSchemaIR but got nodeTarget=${String(schema.nodeTarget ?? typeof schema)}`);
-}
-/**
-* Returns `schema` as-is when it is a real `PostgresSchemaIR` instance, or
-* reconstructs one when `projectSchemaToSpace` has spread the class into a
-* plain object (losing prototype methods).
-*/
-function ensurePostgresSchemaIR(schema) {
-	if (schema instanceof PostgresSchemaIR) return schema;
-	return new PostgresSchemaIR(blindCast(schema));
-}
-//#endregion
-export { PostgresTableIR as a, isPostgresSchemaIR as i, assertPostgresSchemaIR as n, isPostgresTableIR as o, ensurePostgresSchemaIR as r, PostgresSchemaIR as t };
-
-//# sourceMappingURL=postgres-schema-ir-I_FiUndw.mjs.map

package/dist/postgres-schema-ir-I_FiUndw.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-schema-ir-I_FiUndw.mjs","names":[],"sources":["../src/core/schema-ir/postgres-table-ir.ts","../src/core/schema-ir/postgres-schema-ir.ts"],"sourcesContent":["import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  PrimaryKey,\n  type SqlAnnotations,\n  SqlCheckConstraintIR,\n  SqlColumnIR,\n  SqlForeignKeyIR,\n  SqlIndexIR,\n  SqlSchemaIRNode,\n  type SqlTableIRInput,\n  SqlUniqueIR,\n} from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\n\nexport interface PostgresTableIRInput extends SqlTableIRInput {\n  readonly rlsPolicies?: readonly PostgresRlsPolicy[];\n}\n\n/**\n * Postgres-specific table IR node. Carries all `SqlTableIR` fields plus\n * `rlsPolicies`, and implements `DiffableNode` so the table instance is\n * directly the diff-tree node — no separate wrapper needed.\n *\n * Extends `SqlSchemaIRNode` directly rather than `SqlTableIR` because\n * `SqlTableIR` calls `freezeNode` in its own constructor, which prevents\n * subclass field initialisation. Same pattern as `PostgresSchemaIR`.\n *\n * `id` is the table name. `children()` returns the policies on this table.\n * `isEqualTo` is always true — table-level attributes are not diffed yet.\n */\nexport class PostgresTableIR extends SqlSchemaIRNode implements DiffableNode {\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  readonly rlsPolicies: readonly PostgresRlsPolicy[];\n\n  constructor(input: PostgresTableIRInput) {\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    this.rlsPolicies = Object.freeze([...(input.rlsPolicies ?? [])]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  isEqualTo(_other: DiffableNode): boolean {\n    return true;\n  }\n\n  children(): readonly DiffableNode[] {\n    return this.rlsPolicies;\n  }\n}\n\nexport function isPostgresTableIR(node: DiffableNode): node is PostgresTableIR {\n  return node instanceof PostgresTableIR;\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  type SqlAnnotations,\n  type SqlSchemaIR,\n  SqlSchemaIRNode,\n  type SqlSchemaTarget,\n  type SqlTableIRInput,\n} from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\nimport type { PostgresRole } from './postgres-role';\nimport { PostgresTableIR } from './postgres-table-ir';\n\nexport interface PostgresSchemaIRInput {\n  readonly tables: Record<\n    string,\n    PostgresTableIR | (SqlTableIRInput & { rlsPolicies?: readonly PostgresRlsPolicy[] })\n  >;\n  readonly pgSchemaName: string;\n  readonly pgVersion: string;\n  readonly roles: readonly PostgresRole[];\n  readonly existingSchemas: readonly string[];\n  readonly nativeEnumTypeNames: readonly string[];\n}\n\n/**\n * Postgres-specific schema IR. Mirrors the structure of `SqlSchemaIR`\n * (same `tables` + optional `annotations` fields) and adds typed fields for\n * data the postgres adapter collects during introspection.\n *\n * Extends `SqlSchemaIRNode` directly rather than `SqlSchemaIR` because\n * `SqlSchemaIR` calls `freezeNode` in its constructor, which prevents\n * subclass field initialisation. `PostgresSchemaIR` replicates the minimal\n * `SqlSchemaIR` structure and freezes itself at the end of its own\n * constructor.\n *\n * `tables` holds `PostgresTableIR` instances which carry their own RLS\n * policies. `children()` returns the tables directly — the table instances\n * ARE the diff-tree nodes.\n *\n * Nothing RLS-specific leaks into the sql-family layer.\n */\nexport class PostgresSchemaIR extends SqlSchemaIRNode implements DiffableNode {\n  readonly nodeTarget: SqlSchemaTarget = 'postgres';\n  readonly tables: Readonly<Record<string, PostgresTableIR>>;\n  declare readonly annotations?: SqlAnnotations;\n  readonly pgSchemaName: string;\n  readonly pgVersion: string;\n  readonly roles: readonly PostgresRole[];\n  readonly existingSchemas: readonly string[];\n  readonly nativeEnumTypeNames: readonly string[];\n\n  constructor(input: PostgresSchemaIRInput) {\n    super();\n    this.tables = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.tables).map(([key, t]) => [\n          key,\n          t instanceof PostgresTableIR ? t : new PostgresTableIR(t),\n        ]),\n      ),\n    );\n    this.pgSchemaName = input.pgSchemaName;\n    this.pgVersion = input.pgVersion;\n    this.roles = Object.freeze([...input.roles]);\n    this.existingSchemas = Object.freeze([...input.existingSchemas]);\n    this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);\n    // Populate the annotations.pg bag with only the subset the family layer\n    // reads (nativeEnumTypeNames for PSL inference, existingSchemas for\n    // namespace presence checks).\n    this.annotations = {\n      pg: {\n        schema: input.pgSchemaName,\n        ...(input.nativeEnumTypeNames.length > 0 && {\n          nativeEnumTypeNames: input.nativeEnumTypeNames,\n        }),\n        ...(input.existingSchemas.length > 0 && {\n          existingSchemas: input.existingSchemas,\n        }),\n      },\n    };\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.pgSchemaName;\n  }\n\n  get rlsPolicies(): readonly PostgresRlsPolicy[] {\n    return Object.values(this.tables).flatMap((t) => t.rlsPolicies);\n  }\n\n  isEqualTo(_other: DiffableNode): boolean {\n    return true;\n  }\n\n  children(): readonly DiffableNode[] {\n    return Object.values(this.tables);\n  }\n}\n\n/**\n * Structural guard for `PostgresSchemaIR`, narrowing on the `nodeTarget`\n * discriminant rather than `instanceof`. `nodeTarget` is an enumerable own field\n * (a plain class-field initializer), so it survives the `{ ...schema, tables }`\n * spread the multi-space verify path (`projectSchemaToSpace`) produces — that\n * projected object is not a class instance but retains every enumerable own\n * property. The family-level `kind = 'sql-schema-ir'` discriminator is unusable\n * here: it is shared by every SQL schema-IR node and is non-enumerable (dropped\n * by the spread).\n */\nexport function isPostgresSchemaIR(schema: SqlSchemaIR): schema is PostgresSchemaIR {\n  return schema.nodeTarget === 'postgres';\n}\n\nexport function assertPostgresSchemaIR(schema: SqlSchemaIR): asserts schema is PostgresSchemaIR {\n  if (!isPostgresSchemaIR(schema)) {\n    throw new Error(\n      `planPostgresSchemaDiff: expected a PostgresSchemaIR but got nodeTarget=${String(schema.nodeTarget ?? typeof schema)}`,\n    );\n  }\n}\n\n/**\n * Returns `schema` as-is when it is a real `PostgresSchemaIR` instance, or\n * reconstructs one when `projectSchemaToSpace` has spread the class into a\n * plain object (losing prototype methods).\n */\nexport function ensurePostgresSchemaIR(schema: PostgresSchemaIR): PostgresSchemaIR {\n  if (schema instanceof PostgresSchemaIR) return schema;\n  return new PostgresSchemaIR(\n    blindCast<\n      PostgresSchemaIRInput,\n      'spread objects from projectSchemaToSpace preserve all own-enumerable fields'\n    >(schema),\n  );\n}\n"],"mappings":"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"}

package/dist/postgres-schema-ir-annotations-BbDSiwx2.mjs

@@ -1,14 +0,0 @@
-import { r as isPostgresSchema } from "./postgres-schema-DLcc3W2-.mjs";
-import { i as isPostgresSchemaIR } from "./postgres-schema-ir-I_FiUndw.mjs";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-//#region src/core/schema-ir/postgres-schema-ir-annotations.ts
-function resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schemaIr) {
-	if (namespaceId === UNBOUND_NAMESPACE_ID) return (schemaIr && isPostgresSchemaIR(schemaIr) ? schemaIr.pgSchemaName : void 0) ?? "public";
-	const namespace = storage.namespaces[namespaceId];
-	if (namespace && isPostgresSchema(namespace)) return namespace.ddlSchemaName(storage);
-	return namespaceId;
-}
-//#endregion
-export { resolveDdlSchemaForNamespaceStorage as t };
-
-//# sourceMappingURL=postgres-schema-ir-annotations-BbDSiwx2.mjs.map

package/dist/postgres-schema-ir-annotations-BbDSiwx2.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-schema-ir-annotations-BbDSiwx2.mjs","names":[],"sources":["../src/core/schema-ir/postgres-schema-ir-annotations.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { isPostgresSchema } from '../postgres-schema';\nimport { isPostgresSchemaIR } from './postgres-schema-ir';\n\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n  schemaIr?: SqlSchemaIR,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return (\n      (schemaIr && isPostgresSchemaIR(schemaIr) ? schemaIr.pgSchemaName : undefined) ?? 'public'\n    );\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;AAMA,SAAgB,oCACd,SACA,aACA,UACQ;CACR,IAAI,gBAAgB,sBAClB,QACG,YAAY,mBAAmB,QAAQ,IAAI,SAAS,eAAe,KAAA,MAAc;CAGtF,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT"}

package/src/core/migrations/contract-to-postgres-schema-ir.ts

@@ -1,91 +0,0 @@
-import type { ContractToSchemaIROptions } from '@prisma-next/family-sql/control';
-import { contractToSchemaIR } from '@prisma-next/family-sql/control';
-import { ifDefined } from '@prisma-next/utils/defined';
-import type { PostgresContract } from '../postgres-schema';
-import { isPostgresSchema } from '../postgres-schema';
-import { PostgresRlsPolicy } from '../schema-ir/postgres-rls-policy';
-import { PostgresSchemaIR } from '../schema-ir/postgres-schema-ir';
-import { resolveDdlSchemaForNamespaceStorage } from '../schema-ir/postgres-schema-ir-annotations';
-import { PostgresTableIR } from '../schema-ir/postgres-table-ir';
-
-export function contractToPostgresSchemaIR(
-  contract: PostgresContract | null,
-  options: ContractToSchemaIROptions,
-): PostgresSchemaIR {
-  const sqlIr = contractToSchemaIR(contract, options);
-  const ownedSchemas =
-    contract === null
-      ? []
-      : Object.values(contract.storage.namespaces)
-          .filter((ns) => isPostgresSchema(ns))
-          .map((ns) => resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id));
-
-  // Build a map of tableName → PostgresRlsPolicy[], resolving the DDL schema
-  // name once per namespace (not per policy).
-  const policiesByTable = new Map<string, PostgresRlsPolicy[]>();
-  if (contract !== null) {
-    for (const ns of Object.values(contract.storage.namespaces)) {
-      if (!isPostgresSchema(ns)) continue;
-      const resolvedSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);
-      for (const policy of Object.values(ns.policy)) {
-        const resolved =
-          resolvedSchema === policy.namespaceId
-            ? policy
-            : new PostgresRlsPolicy({
-                name: policy.name,
-                prefix: policy.prefix,
-                tableName: policy.tableName,
-                namespaceId: resolvedSchema,
-                operation: policy.operation,
-                roles: [...policy.roles],
-                ...ifDefined('using', policy.using),
-                ...ifDefined('withCheck', policy.withCheck),
-                permissive: policy.permissive,
-              });
-        const list = policiesByTable.get(policy.tableName) ?? [];
-        list.push(resolved);
-        policiesByTable.set(policy.tableName, list);
-      }
-    }
-  }
-
-  // Attach policies to each table from the relational projection. A policy that
-  // references a table absent from the schema IR is a malformed contract — the
-  // loop below throws rather than fabricating a stub table.
-  const tables: Record<string, PostgresTableIR> = {};
-  for (const [tableName, sqlTable] of Object.entries(sqlIr.tables)) {
-    tables[tableName] = new PostgresTableIR({
-      name: sqlTable.name,
-      columns: sqlTable.columns,
-      foreignKeys: sqlTable.foreignKeys,
-      uniques: sqlTable.uniques,
-      indexes: sqlTable.indexes,
-      ...(sqlTable.primaryKey !== undefined ? { primaryKey: sqlTable.primaryKey } : {}),
-      ...(sqlTable.annotations !== undefined ? { annotations: sqlTable.annotations } : {}),
-      ...(sqlTable.checks !== undefined ? { checks: sqlTable.checks } : {}),
-      rlsPolicies: policiesByTable.get(tableName) ?? [],
-    });
-  }
-  for (const [tableName, policies] of policiesByTable) {
-    if (!(tableName in tables)) {
-      const policyName = policies[0]?.name ?? '(unknown)';
-      throw new Error(
-        `contract-to-postgres-schema-ir: policy "${policyName}" references table "${tableName}" not present in the schema`,
-      );
-    }
-  }
-
-  return new PostgresSchemaIR({
-    tables,
-    roles:
-      contract === null
-        ? []
-        : Object.values(contract.storage.namespaces).flatMap((ns) =>
-            isPostgresSchema(ns) ? Object.values(ns.role) : [],
-          ),
-    pgSchemaName: 'public',
-    pgVersion: '',
-    existingSchemas: ownedSchemas,
-    nativeEnumTypeNames: [],
-  });
-}

package/src/core/migrations/diff-postgres-schema.ts

@@ -1,55 +0,0 @@
-import type { SchemaDiffIssue } from '@prisma-next/framework-components/control';
-import { diffSchemas } from '@prisma-next/framework-components/control';
-import { isPostgresRlsPolicy, type PostgresRlsPolicy } from '../schema-ir/postgres-rls-policy';
-import { ensurePostgresSchemaIR, type PostgresSchemaIR } from '../schema-ir/postgres-schema-ir';
-
-// Renders a display-only reference string for the diff message. If policy
-// rendering grows, route it through the adapter's SQL renderer so the message
-// can't diverge from the emitted policy SQL.
-function renderPostgresPolicyReference(policy: PostgresRlsPolicy): string {
-  return `policy "${policy.name}" on "${policy.namespaceId}"."${policy.tableName}"`;
-}
-
-/**
- * Computes schema drift between two derived schema IRs.
- *
- * 1. Runs the framework total diff.
- * 2. Filters to policy-subject issues only — this is transitional: the generic
- *    differ walks the whole tree, but the legacy relational verifier still owns
- *    table/column drift, so non-policy issues are dropped here.
- * 3. Remaps the message to a human-readable policy reference.
- *
- * Ownership filtering (dropping `extra` issues in namespaces a contract doesn't
- * own) is the caller's responsibility — use `filterIssuesByOwnership`.
- */
-export function diffPostgresSchema(
-  expected: PostgresSchemaIR,
-  actual: PostgresSchemaIR,
-): readonly SchemaDiffIssue[] {
-  const safeActual = ensurePostgresSchemaIR(actual);
-  const issues = diffSchemas(expected, safeActual);
-
-  return issues
-    .filter((i) => isPostgresRlsPolicy(i.expected ?? i.actual))
-    .map((i) => {
-      const policy = i.expected ?? i.actual;
-      if (!isPostgresRlsPolicy(policy)) return i;
-      return { ...i, message: `${i.outcome}: ${renderPostgresPolicyReference(policy)}` };
-    });
-}
-
-/**
- * Filters `extra` policy issues to those in owned namespaces. Call after
- * `diffPostgresSchema` with the union of namespace ids from the expected IR's
- * policies and its `existingSchemas`.
- */
-export function filterIssuesByOwnership(
-  issues: readonly SchemaDiffIssue[],
-  ownedSchemaNames: ReadonlySet<string>,
-): readonly SchemaDiffIssue[] {
-  return issues.filter(
-    (i) =>
-      i.outcome !== 'extra' ||
-      (isPostgresRlsPolicy(i.actual) && ownedSchemaNames.has(i.actual.namespaceId)),
-  );
-}

package/src/core/schema-ir/postgres-schema-ir.ts

@@ -1,138 +0,0 @@
-import type { DiffableNode } from '@prisma-next/framework-components/control';
-import { freezeNode } from '@prisma-next/framework-components/ir';
-import {
-  type SqlAnnotations,
-  type SqlSchemaIR,
-  SqlSchemaIRNode,
-  type SqlSchemaTarget,
-  type SqlTableIRInput,
-} from '@prisma-next/sql-schema-ir/types';
-import { blindCast } from '@prisma-next/utils/casts';
-import type { PostgresRlsPolicy } from './postgres-rls-policy';
-import type { PostgresRole } from './postgres-role';
-import { PostgresTableIR } from './postgres-table-ir';
-
-export interface PostgresSchemaIRInput {
-  readonly tables: Record<
-    string,
-    PostgresTableIR | (SqlTableIRInput & { rlsPolicies?: readonly PostgresRlsPolicy[] })
-  >;
-  readonly pgSchemaName: string;
-  readonly pgVersion: string;
-  readonly roles: readonly PostgresRole[];
-  readonly existingSchemas: readonly string[];
-  readonly nativeEnumTypeNames: readonly string[];
-}
-
-/**
- * Postgres-specific schema IR. Mirrors the structure of `SqlSchemaIR`
- * (same `tables` + optional `annotations` fields) and adds typed fields for
- * data the postgres adapter collects during introspection.
- *
- * Extends `SqlSchemaIRNode` directly rather than `SqlSchemaIR` because
- * `SqlSchemaIR` calls `freezeNode` in its constructor, which prevents
- * subclass field initialisation. `PostgresSchemaIR` replicates the minimal
- * `SqlSchemaIR` structure and freezes itself at the end of its own
- * constructor.
- *
- * `tables` holds `PostgresTableIR` instances which carry their own RLS
- * policies. `children()` returns the tables directly — the table instances
- * ARE the diff-tree nodes.
- *
- * Nothing RLS-specific leaks into the sql-family layer.
- */
-export class PostgresSchemaIR extends SqlSchemaIRNode implements DiffableNode {
-  readonly nodeTarget: SqlSchemaTarget = 'postgres';
-  readonly tables: Readonly<Record<string, PostgresTableIR>>;
-  declare readonly annotations?: SqlAnnotations;
-  readonly pgSchemaName: string;
-  readonly pgVersion: string;
-  readonly roles: readonly PostgresRole[];
-  readonly existingSchemas: readonly string[];
-  readonly nativeEnumTypeNames: readonly string[];
-
-  constructor(input: PostgresSchemaIRInput) {
-    super();
-    this.tables = Object.freeze(
-      Object.fromEntries(
-        Object.entries(input.tables).map(([key, t]) => [
-          key,
-          t instanceof PostgresTableIR ? t : new PostgresTableIR(t),
-        ]),
-      ),
-    );
-    this.pgSchemaName = input.pgSchemaName;
-    this.pgVersion = input.pgVersion;
-    this.roles = Object.freeze([...input.roles]);
-    this.existingSchemas = Object.freeze([...input.existingSchemas]);
-    this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);
-    // Populate the annotations.pg bag with only the subset the family layer
-    // reads (nativeEnumTypeNames for PSL inference, existingSchemas for
-    // namespace presence checks).
-    this.annotations = {
-      pg: {
-        schema: input.pgSchemaName,
-        ...(input.nativeEnumTypeNames.length > 0 && {
-          nativeEnumTypeNames: input.nativeEnumTypeNames,
-        }),
-        ...(input.existingSchemas.length > 0 && {
-          existingSchemas: input.existingSchemas,
-        }),
-      },
-    };
-    freezeNode(this);
-  }
-
-  get id(): string {
-    return this.pgSchemaName;
-  }
-
-  get rlsPolicies(): readonly PostgresRlsPolicy[] {
-    return Object.values(this.tables).flatMap((t) => t.rlsPolicies);
-  }
-
-  isEqualTo(_other: DiffableNode): boolean {
-    return true;
-  }
-
-  children(): readonly DiffableNode[] {
-    return Object.values(this.tables);
-  }
-}
-
-/**
- * Structural guard for `PostgresSchemaIR`, narrowing on the `nodeTarget`
- * discriminant rather than `instanceof`. `nodeTarget` is an enumerable own field
- * (a plain class-field initializer), so it survives the `{ ...schema, tables }`
- * spread the multi-space verify path (`projectSchemaToSpace`) produces — that
- * projected object is not a class instance but retains every enumerable own
- * property. The family-level `kind = 'sql-schema-ir'` discriminator is unusable
- * here: it is shared by every SQL schema-IR node and is non-enumerable (dropped
- * by the spread).
- */
-export function isPostgresSchemaIR(schema: SqlSchemaIR): schema is PostgresSchemaIR {
-  return schema.nodeTarget === 'postgres';
-}
-
-export function assertPostgresSchemaIR(schema: SqlSchemaIR): asserts schema is PostgresSchemaIR {
-  if (!isPostgresSchemaIR(schema)) {
-    throw new Error(
-      `planPostgresSchemaDiff: expected a PostgresSchemaIR but got nodeTarget=${String(schema.nodeTarget ?? typeof schema)}`,
-    );
-  }
-}
-
-/**
- * Returns `schema` as-is when it is a real `PostgresSchemaIR` instance, or
- * reconstructs one when `projectSchemaToSpace` has spread the class into a
- * plain object (losing prototype methods).
- */
-export function ensurePostgresSchemaIR(schema: PostgresSchemaIR): PostgresSchemaIR {
-  if (schema instanceof PostgresSchemaIR) return schema;
-  return new PostgresSchemaIR(
-    blindCast<
-      PostgresSchemaIRInput,
-      'spread objects from projectSchemaToSpace preserve all own-enumerable fields'
-    >(schema),
-  );
-}