@prisma-next/target-postgres 0.14.0-dev.8 → 0.14.0-dev.80

package/dist/diff-database-schema-DULhiCNM.mjs

@@ -0,0 +1,305 @@
+import { r as isPostgresSchema } from "./postgres-schema-DYATroNx.mjs";
+import { a as postgresDiffSubjectGranularity, n as PostgresNativeEnumSchemaNode, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-D6LvInCe.mjs";
+import { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode, t as PostgresRoleSchemaNode } from "./postgres-role-schema-node-Cm-j0ZGM.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-DpGte50u.mjs";
+import { i as resolvePostgresNodeIssueControlPolicySubject } from "./control-policy-5LE2kwfb.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { blindCast } from "@prisma-next/utils/casts";
+import { buildNativeTypeExpander, contractNamespaceToSchemaIR } from "@prisma-next/family-sql/control";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { SqlForeignKeyIR } from "@prisma-next/sql-schema-ir/types";
+import { classifyDiffSubjectGranularity } from "@prisma-next/family-sql/diff";
+import { diffSchemas } from "@prisma-next/framework-components/control";
+//#region src/core/migrations/contract-to-postgres-database-schema-node.ts
+function toPolicyNode(policy, namespaceId) {
+	return new PostgresPolicySchemaNode({
+		name: policy.name,
+		prefix: policy.prefix,
+		tableName: policy.tableName,
+		namespaceId,
+		operation: policy.operation,
+		roles: [...policy.roles],
+		...ifDefined("using", policy.using),
+		...ifDefined("withCheck", policy.withCheck),
+		permissive: policy.permissive
+	});
+}
+/**
+* Projects a Postgres contract into the expected schema-diff tree: a
+* `PostgresDatabaseSchemaNode` root holding one `PostgresNamespaceSchemaNode`
+* per Postgres namespace, each holding its `PostgresTableSchemaNode`s with
+* their `PostgresPolicySchemaNode`s, plus the database roles on the root.
+*
+* Not a duplicate of the family's `contractToSchemaIR`: that builds a flat,
+* single `{ tables }` map (and throws on cross-namespace name collisions, with
+* no RLS/role concept) for SQLite's single-schema world. This is the
+* Postgres-specific *tree* shape — multi-schema, RLS-policy-aware, role-aware.
+* It reuses the family's per-namespace table conversion (`contractNamespaceToSchemaIR`)
+* for column/FK/index building and only adds the Postgres tree/policy/role shape.
+*
+* Tables are grouped by their owning namespace (resolved DDL schema name) so
+* the tree mirrors Postgres's object hierarchy. The DDL schema name is
+* resolved once per namespace.
+*
+* A policy that references a table absent from its namespace is a malformed
+* contract — the loop throws rather than fabricating a stub table.
+*/
+function contractToPostgresDatabaseSchemaNode(contract, options) {
+	if (contract === null) return new PostgresDatabaseSchemaNode({
+		namespaces: {},
+		roles: [],
+		existingSchemas: [],
+		pgVersion: ""
+	});
+	const namespaces = {};
+	const roles = [];
+	const ownedSchemas = [];
+	for (const ns of Object.values(contract.storage.namespaces)) {
+		if (!isPostgresSchema(ns)) continue;
+		for (const role of Object.values(ns.role)) roles.push(new PostgresRoleSchemaNode({
+			name: role.name,
+			namespaceId: role.namespaceId
+		}));
+		if (ns.id === UNBOUND_NAMESPACE_ID) {
+			if (!Object.entries(ns.entries).some(([entriesKey, slot]) => entriesKey !== "role" && Object.keys(slot).length > 0)) continue;
+		}
+		const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);
+		ownedSchemas.push(ddlSchema);
+		const sqlTables = contractNamespaceToSchemaIR(contract.storage, ns.id, options).tables;
+		const policiesByTable = /* @__PURE__ */ new Map();
+		for (const policy of Object.values(ns.policy)) {
+			const list = policiesByTable.get(policy.tableName) ?? [];
+			list.push(toPolicyNode(policy, ddlSchema));
+			policiesByTable.set(policy.tableName, list);
+		}
+		const tables = {};
+		for (const tableName of Object.keys(ns.table)) {
+			const sqlTable = sqlTables[tableName];
+			if (sqlTable === void 0) continue;
+			const foreignKeys = sqlTable.foreignKeys.map((fk) => new SqlForeignKeyIR({
+				columns: fk.columns,
+				referencedTable: fk.referencedTable,
+				referencedColumns: fk.referencedColumns,
+				referencedSchema: fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,
+				...ifDefined("name", fk.name),
+				...ifDefined("onDelete", fk.onDelete),
+				...ifDefined("onUpdate", fk.onUpdate),
+				...ifDefined("annotations", fk.annotations),
+				resolvedReferencedNamespace: resolveDdlSchemaForNamespaceStorage(contract.storage, fk.referencedSchema ?? UNBOUND_NAMESPACE_ID)
+			}));
+			tables[tableName] = new PostgresTableSchemaNode({
+				name: sqlTable.name,
+				columns: sqlTable.columns,
+				foreignKeys,
+				uniques: sqlTable.uniques,
+				indexes: sqlTable.indexes,
+				...ifDefined("primaryKey", sqlTable.primaryKey),
+				...ifDefined("annotations", sqlTable.annotations),
+				...ifDefined("checks", sqlTable.checks),
+				policies: policiesByTable.get(tableName) ?? [],
+				rlsEnabled: Object.hasOwn(ns.rls, tableName)
+			});
+		}
+		for (const [tableName, tablePolicies] of policiesByTable) {
+			if (!(tableName in tables)) {
+				const policyName = tablePolicies[0]?.name ?? "(unknown)";
+				throw new Error(`contract-to-postgres-database-schema-node: policy "${policyName}" references table "${tableName}" not present in namespace "${ddlSchema}"`);
+			}
+			if (!Object.hasOwn(ns.rls, tableName)) {
+				const policyPrefix = tablePolicies[0]?.prefix ?? "(unknown)";
+				throw new Error(`contract-to-postgres-database-schema-node: policy "${policyPrefix}" targets table "${tableName}" in namespace "${ddlSchema}", which is not RLS-controlled. Mark the model with @@rls (entries.rls["${tableName}"]) or remove the policy.`);
+			}
+		}
+		namespaces[ddlSchema] = new PostgresNamespaceSchemaNode({
+			schemaName: ddlSchema,
+			tables,
+			nativeEnums: Object.values(ns.entries.native_enum ?? {}).map((entity) => new PostgresNativeEnumSchemaNode({
+				typeName: entity.typeName,
+				namespaceId: ddlSchema,
+				members: entity.members,
+				...ifDefined("control", entity.control)
+			}))
+		});
+	}
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles,
+		existingSchemas: ownedSchemas,
+		pgVersion: ""
+	});
+}
+//#endregion
+//#region src/core/migrations/diff-database-schema.ts
+/**
+* Whether a diff issue's subject node is cluster-scoped — it carries its own
+* `namespaceId` field (only role and policy diff nodes do) and that
+* coordinate is the unbound sentinel, meaning the node is not owned by any
+* schema/namespace. A role node is always cluster-scoped (roles are
+* cluster-level objects); a policy node's `namespaceId` is always its
+* table's resolved DDL schema, never the sentinel. Namespace-ownership
+* scoping (which compares `issue.path[1]` against the set of DDL schemas
+* the contract owns) makes no sense for a cluster-scoped subject — its path
+* segment at that index is the object's own name, not a schema name — so
+* such an issue bypasses that scoping entirely.
+*/
+function isClusterScopedIssue(issue) {
+	const node = issue.expected ?? issue.actual;
+	return node !== void 0 && nodeNamespaceId(node) === UNBOUND_NAMESPACE_ID;
+}
+function nodeNamespaceId(node) {
+	if (!Object.hasOwn(node, "namespaceId")) return void 0;
+	return blindCast(node).namespaceId;
+}
+function ownedSchemaNames(expected) {
+	const policyNamespaces = Object.values(expected.namespaces).flatMap((ns) => Object.values(ns.tables).flatMap((t) => t.policies.map((p) => p.namespaceId)));
+	return /* @__PURE__ */ new Set([...policyNamespaces, ...expected.existingSchemas]);
+}
+/**
+* Drops contract namespaces that declare no tables from the verdict-diff
+* expected tree and the relational owned-schema set. The legacy relational
+* walk skipped a table-less namespace (e.g. an enums-only schema) before
+* pairing, so neither its DDL schema's absence nor that schema's live
+* relational contents ever reached the verdict — the pruned tree
+* reproduces that. The prune loses no expected policies: policies attach
+* to tables, so a table-less namespace carries none (the projection
+* throws on a policy referencing an absent table). Live policies in a
+* pruned schema remain governed via the full owned set (see
+* {@link diffPostgresSchema}).
+*/
+function pruneTableLessNamespaces(expected) {
+	const namespaces = Object.fromEntries(Object.entries(expected.namespaces).filter(([, ns]) => Object.keys(ns.tables).length > 0));
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles: [...expected.roles],
+		existingSchemas: expected.existingSchemas.filter((s) => namespaces[s] !== void 0),
+		pgVersion: expected.pgVersion
+	});
+}
+/**
+* Resolves a verdict-diff issue's subject's declared control policy directly
+* from the contract, by delegating to the same node-typed resolver
+* ({@link resolvePostgresNodeIssueControlPolicySubject}) the planner uses to
+* gate DDL calls. `undefined` when the issue resolves to no contract subject.
+*
+* A role issue resolves through that same resolver to `external`
+* unconditionally (see its role branch), regardless of the contract's own
+* default policy: a role is referenced by the contract but not owned, and
+* `external`'s existing semantics — a missing declared subject still fails,
+* every extra is suppressed — are exactly the wanted asymmetric grading for
+* a cluster object the framework does not own.
+*/
+function resolveControlPolicy(issue, contract) {
+	return resolvePostgresNodeIssueControlPolicySubject(blindCast(issue), contract)?.explicitNodeControlPolicy;
+}
+/**
+* The Postgres full-tree node diff for the family verify verdict: derive
+* the expected tree (resolved leaf values, expander threaded, FK schemas
+* resolved, table-less namespaces pruned), run the generic
+* differ over the trees as derived, and scope out `not-expected` findings under namespaces the
+* contract does not own. Ownership scoping bypasses cluster-scoped subjects
+* (roles today), mirroring the legacy decomposition: relational extras check
+* the PRUNED owned set (the legacy
+* per-namespace walk never visited a table-less namespace, so its live
+* relational contents are invisible), while `structural` extras (RLS
+* policies) check the FULL owned set (the legacy policy diff governed
+* every contract schema regardless of tables — RLS governance does not
+* shrink because a namespace declares no tables). The codec `verifyType`
+* hooks run once per contract namespace with tables against that
+* namespace's paired actual node (the hooks read namespace-scoped state
+* such as `nativeEnums`).
+*/
+function diffPostgresSchema(input) {
+	const postgresContract = blindCast(input.contract);
+	PostgresDatabaseSchemaNode.assert(input.schema);
+	const actual = input.schema;
+	const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
+		annotationNamespace: "pg",
+		...ifDefined("expandNativeType", buildNativeTypeExpander(input.frameworkComponents))
+	});
+	const expected = pruneTableLessNamespaces(fullExpected);
+	const relationalOwned = ownedSchemaNames(expected);
+	const structuralOwned = ownedSchemaNames(fullExpected);
+	return {
+		issues: diffSchemas(expected, actual).filter((issue) => {
+			if (issue.reason !== "not-expected") return true;
+			if (isClusterScopedIssue(issue)) return true;
+			const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
+			const namespaceSegment = issue.path[1];
+			if (namespaceSegment === void 0) return true;
+			return (granularity === "structural" ? structuralOwned : relationalOwned).has(namespaceSegment);
+		}),
+		resolveControlPolicy: (issue) => resolveControlPolicy(issue, postgresContract),
+		namespacePairs: Object.values(expected.namespaces).map((ns) => ({ actual: actual.namespaces[ns.schemaName] }))
+	};
+}
+/**
+* Adds an empty namespace node to the actual tree for every expected namespace
+* absent from it. The relational plan diff pairs on namespace: a contract
+* namespace whose live schema does not exist yet must surface each of its
+* tables as `not-found` (→ `CREATE TABLE`), NOT as a single namespace
+* `not-found` that subtree-coalescing would collapse (leaving `CREATE SCHEMA`
+* with no tables). Padding makes the namespaces pair, so only table/column/
+* policy drift surfaces; `CREATE SCHEMA` comes separately from the synthesized
+* namespace-presence stitch (`verifyPostgresNamespacePresence`), never from the
+* tree diff — matching the retired per-namespace-paired relational walk, which
+* paired a missing schema against an empty namespace node.
+*/
+function padActualNamespaces(expected, actual) {
+	const namespaces = { ...actual.namespaces };
+	let padded = false;
+	for (const schemaName of Object.keys(expected.namespaces)) if (namespaces[schemaName] === void 0) {
+		namespaces[schemaName] = new PostgresNamespaceSchemaNode({
+			schemaName,
+			tables: {}
+		});
+		padded = true;
+	}
+	if (!padded) return actual;
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles: [...actual.roles],
+		existingSchemas: [...actual.existingSchemas],
+		pgVersion: actual.pgVersion
+	});
+}
+/**
+* The Postgres planner's diff input: the SAME tree-building
+* `diffPostgresSchema` uses (expander threaded, FK schemas resolved,
+* table-less namespaces pruned, cluster-scope-aware ownership filter) plus
+* actual namespace padding (so a missing
+* schema's tables surface as `not-found` instead of a swallowed namespace
+* `not-found`). One differ drives both verify and plan; this is the
+* plan-side derivation. The single issue list covers tables / columns /
+* constraints / indexes / defaults AND policies — the caller splits it
+* (relational → `mapNodeIssueToCall`; policy → RLS ops) and stitches in
+* `CREATE SCHEMA` separately.
+*/
+function buildPostgresPlanDiff(input) {
+	const postgresContract = blindCast(input.contract);
+	PostgresDatabaseSchemaNode.assert(input.actualSchema);
+	const actual = input.actualSchema;
+	const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
+		annotationNamespace: "pg",
+		...ifDefined("expandNativeType", buildNativeTypeExpander(input.frameworkComponents))
+	});
+	const expected = pruneTableLessNamespaces(fullExpected);
+	const paddedActual = padActualNamespaces(expected, actual);
+	const relationalOwned = ownedSchemaNames(expected);
+	const structuralOwned = ownedSchemaNames(fullExpected);
+	return {
+		expected,
+		actual: paddedActual,
+		issues: blindCast(diffSchemas(expected, paddedActual)).filter((issue) => {
+			if (issue.reason !== "not-expected") return true;
+			if (isClusterScopedIssue(issue)) return true;
+			const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
+			const namespaceSegment = issue.path[1];
+			if (namespaceSegment === void 0) return true;
+			return (granularity === "structural" ? structuralOwned : relationalOwned).has(namespaceSegment);
+		})
+	};
+}
+//#endregion
+export { diffPostgresSchema as n, contractToPostgresDatabaseSchemaNode as r, buildPostgresPlanDiff as t };
+
+//# sourceMappingURL=diff-database-schema-DULhiCNM.mjs.map

package/dist/diff-database-schema-DULhiCNM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-database-schema-DULhiCNM.mjs","names":[],"sources":["../src/core/migrations/contract-to-postgres-database-schema-node.ts","../src/core/migrations/diff-database-schema.ts"],"sourcesContent":["import type { ContractToSchemaIROptions } from '@prisma-next/family-sql/control';\nimport { contractNamespaceToSchemaIR } from '@prisma-next/family-sql/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport { SqlForeignKeyIR } from '@prisma-next/sql-schema-ir/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresRlsPolicy } from '../postgres-rls-policy';\nimport type { PostgresContract } from '../postgres-schema';\nimport { isPostgresSchema } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';\nimport { PostgresNativeEnumSchemaNode } from '../schema-ir/postgres-native-enum-schema-node';\nimport { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';\nimport { PostgresRoleSchemaNode } from '../schema-ir/postgres-role-schema-node';\nimport { PostgresTableSchemaNode } from '../schema-ir/postgres-table-schema-node';\nimport { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';\n\nfunction toPolicyNode(policy: PostgresRlsPolicy, namespaceId: string): PostgresPolicySchemaNode {\n  return new PostgresPolicySchemaNode({\n    name: policy.name,\n    prefix: policy.prefix,\n    tableName: policy.tableName,\n    namespaceId,\n    operation: policy.operation,\n    roles: [...policy.roles],\n    ...ifDefined('using', policy.using),\n    ...ifDefined('withCheck', policy.withCheck),\n    permissive: policy.permissive,\n  });\n}\n\n/**\n * Projects a Postgres contract into the expected schema-diff tree: a\n * `PostgresDatabaseSchemaNode` root holding one `PostgresNamespaceSchemaNode`\n * per Postgres namespace, each holding its `PostgresTableSchemaNode`s with\n * their `PostgresPolicySchemaNode`s, plus the database roles on the root.\n *\n * Not a duplicate of the family's `contractToSchemaIR`: that builds a flat,\n * single `{ tables }` map (and throws on cross-namespace name collisions, with\n * no RLS/role concept) for SQLite's single-schema world. This is the\n * Postgres-specific *tree* shape — multi-schema, RLS-policy-aware, role-aware.\n * It reuses the family's per-namespace table conversion (`contractNamespaceToSchemaIR`)\n * for column/FK/index building and only adds the Postgres tree/policy/role shape.\n *\n * Tables are grouped by their owning namespace (resolved DDL schema name) so\n * the tree mirrors Postgres's object hierarchy. The DDL schema name is\n * resolved once per namespace.\n *\n * A policy that references a table absent from its namespace is a malformed\n * contract — the loop throws rather than fabricating a stub table.\n */\nexport function contractToPostgresDatabaseSchemaNode(\n  contract: PostgresContract | null,\n  options: ContractToSchemaIROptions,\n): PostgresDatabaseSchemaNode {\n  if (contract === null) {\n    return new PostgresDatabaseSchemaNode({\n      namespaces: {},\n      roles: [],\n      existingSchemas: [],\n      pgVersion: '',\n    });\n  }\n\n  const namespaces: Record<string, PostgresNamespaceSchemaNode> = {};\n  const roles: PostgresRoleSchemaNode[] = [];\n  const ownedSchemas: string[] = [];\n\n  for (const ns of Object.values(contract.storage.namespaces)) {\n    if (!isPostgresSchema(ns)) continue;\n\n    // Role entries are root-level diff subjects: they hoist to the database\n    // root from every slot and never count toward whether a namespace\n    // materializes a schema node.\n    for (const role of Object.values(ns.role)) {\n      roles.push(new PostgresRoleSchemaNode({ name: role.name, namespaceId: role.namespaceId }));\n    }\n\n    // The unbound slot resolves its DDL schema to 'public', so it\n    // materializes a schema node exactly when it has non-role content — a\n    // late-binding contract keeps today's behavior (the slot carries the\n    // tables), while a roles-only unbound slot alongside named namespaces\n    // contributes only root roles and no node (which would otherwise be a\n    // spurious empty 'public' node, clobbering a real bound 'public'\n    // namespace's node keyed by the same resolved schema name).\n    if (ns.id === UNBOUND_NAMESPACE_ID) {\n      const hasNonRoleContent = Object.entries(ns.entries).some(\n        ([entriesKey, slot]) => entriesKey !== 'role' && Object.keys(slot).length > 0,\n      );\n      if (!hasNonRoleContent) continue;\n    }\n\n    const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);\n    ownedSchemas.push(ddlSchema);\n\n    // Convert only THIS namespace's tables (passing the full storage for\n    // type/value-set/enum resolution that spans namespaces), so the same table\n    // name can exist in two schemas without colliding in a bare-keyed record.\n    const sqlTables = contractNamespaceToSchemaIR(contract.storage, ns.id, options).tables;\n\n    const policiesByTable = new Map<string, PostgresPolicySchemaNode[]>();\n    for (const policy of Object.values(ns.policy)) {\n      const list = policiesByTable.get(policy.tableName) ?? [];\n      list.push(toPolicyNode(policy, ddlSchema));\n      policiesByTable.set(policy.tableName, list);\n    }\n\n    const tables: Record<string, PostgresTableSchemaNode> = {};\n    for (const tableName of Object.keys(ns.table)) {\n      const sqlTable = sqlTables[tableName];\n      if (sqlTable === undefined) continue;\n      // The family conversion stamps `referencedSchema` only for bound FK\n      // targets; an absent value means the FK targets the unbound namespace.\n      // Postgres restores its own coordinate for that slot (the unbound\n      // singleton's id) so the raw coordinate keeps qualifying REFERENCES\n      // clauses, and resolves the real live DDL schema — introspected FKs\n      // already carry the live schema, so this is what lets an expected FK\n      // pair (by diff-node id) with its introspected counterpart.\n      const foreignKeys = sqlTable.foreignKeys.map(\n        (fk) =>\n          new SqlForeignKeyIR({\n            columns: fk.columns,\n            referencedTable: fk.referencedTable,\n            referencedColumns: fk.referencedColumns,\n            referencedSchema: fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,\n            ...ifDefined('name', fk.name),\n            ...ifDefined('onDelete', fk.onDelete),\n            ...ifDefined('onUpdate', fk.onUpdate),\n            ...ifDefined('annotations', fk.annotations),\n            resolvedReferencedNamespace: resolveDdlSchemaForNamespaceStorage(\n              contract.storage,\n              fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,\n            ),\n          }),\n      );\n      tables[tableName] = new PostgresTableSchemaNode({\n        name: sqlTable.name,\n        columns: sqlTable.columns,\n        foreignKeys,\n        uniques: sqlTable.uniques,\n        indexes: sqlTable.indexes,\n        ...ifDefined('primaryKey', sqlTable.primaryKey),\n        ...ifDefined('annotations', sqlTable.annotations),\n        ...ifDefined('checks', sqlTable.checks),\n        policies: policiesByTable.get(tableName) ?? [],\n        // Marker-driven, never derived from the policy set: the `rls` entry\n        // is the single authored source of enablement.\n        rlsEnabled: Object.hasOwn(ns.rls, tableName),\n      });\n    }\n\n    for (const [tableName, tablePolicies] of policiesByTable) {\n      if (!(tableName in tables)) {\n        const policyName = tablePolicies[0]?.name ?? '(unknown)';\n        throw new Error(\n          `contract-to-postgres-database-schema-node: policy \"${policyName}\" references table \"${tableName}\" not present in namespace \"${ddlSchema}\"`,\n        );\n      }\n      if (!Object.hasOwn(ns.rls, tableName)) {\n        const policyPrefix = tablePolicies[0]?.prefix ?? '(unknown)';\n        throw new Error(\n          `contract-to-postgres-database-schema-node: policy \"${policyPrefix}\" targets table \"${tableName}\" in namespace \"${ddlSchema}\", which is not RLS-controlled. Mark the model with @@rls (entries.rls[\"${tableName}\"]) or remove the policy.`,\n        );\n      }\n    }\n\n    const nativeEnums = Object.values(ns.entries.native_enum ?? {}).map(\n      (entity) =>\n        new PostgresNativeEnumSchemaNode({\n          typeName: entity.typeName,\n          namespaceId: ddlSchema,\n          members: entity.members,\n          ...ifDefined('control', entity.control),\n        }),\n    );\n\n    namespaces[ddlSchema] = new PostgresNamespaceSchemaNode({\n      schemaName: ddlSchema,\n      tables,\n      nativeEnums,\n    });\n  }\n\n  return new PostgresDatabaseSchemaNode({\n    namespaces,\n    roles,\n    existingSchemas: ownedSchemas,\n    pgVersion: '',\n  });\n}\n","import type { Contract, ControlPolicy } from '@prisma-next/contract/types';\nimport type { SqlSchemaDiffResult } from '@prisma-next/family-sql/control';\nimport { buildNativeTypeExpander } from '@prisma-next/family-sql/control';\nimport { classifyDiffSubjectGranularity } from '@prisma-next/family-sql/diff';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type { DiffableNode, SchemaDiffIssue } from '@prisma-next/framework-components/control';\nimport { diffSchemas } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport type { PostgresContract } from '../postgres-schema';\nimport { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';\nimport { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';\nimport {\n  postgresDiffSubjectGranularity,\n  type SqlSchemaDiffNode,\n} from '../schema-ir/schema-node-kinds';\nimport { contractToPostgresDatabaseSchemaNode } from './contract-to-postgres-database-schema-node';\nimport { resolvePostgresNodeIssueControlPolicySubject } from './control-policy';\n\n/**\n * Whether a diff issue's subject node is cluster-scoped — it carries its own\n * `namespaceId` field (only role and policy diff nodes do) and that\n * coordinate is the unbound sentinel, meaning the node is not owned by any\n * schema/namespace. A role node is always cluster-scoped (roles are\n * cluster-level objects); a policy node's `namespaceId` is always its\n * table's resolved DDL schema, never the sentinel. Namespace-ownership\n * scoping (which compares `issue.path[1]` against the set of DDL schemas\n * the contract owns) makes no sense for a cluster-scoped subject — its path\n * segment at that index is the object's own name, not a schema name — so\n * such an issue bypasses that scoping entirely.\n */\nfunction isClusterScopedIssue(issue: SchemaDiffIssue): boolean {\n  const node = issue.expected ?? issue.actual;\n  return node !== undefined && nodeNamespaceId(node) === UNBOUND_NAMESPACE_ID;\n}\n\nfunction nodeNamespaceId(node: DiffableNode): string | undefined {\n  if (!Object.hasOwn(node, 'namespaceId')) return undefined;\n  return blindCast<\n    { namespaceId: string },\n    'presence of an own namespaceId field was just checked via Object.hasOwn'\n  >(node).namespaceId;\n}\n\nfunction ownedSchemaNames(expected: PostgresDatabaseSchemaNode): ReadonlySet<string> {\n  const policyNamespaces = Object.values(expected.namespaces).flatMap((ns) =>\n    Object.values(ns.tables).flatMap((t) => t.policies.map((p) => p.namespaceId)),\n  );\n  return new Set([...policyNamespaces, ...expected.existingSchemas]);\n}\n\n/**\n * Drops contract namespaces that declare no tables from the verdict-diff\n * expected tree and the relational owned-schema set. The legacy relational\n * walk skipped a table-less namespace (e.g. an enums-only schema) before\n * pairing, so neither its DDL schema's absence nor that schema's live\n * relational contents ever reached the verdict — the pruned tree\n * reproduces that. The prune loses no expected policies: policies attach\n * to tables, so a table-less namespace carries none (the projection\n * throws on a policy referencing an absent table). Live policies in a\n * pruned schema remain governed via the full owned set (see\n * {@link diffPostgresSchema}).\n */\nfunction pruneTableLessNamespaces(\n  expected: PostgresDatabaseSchemaNode,\n): PostgresDatabaseSchemaNode {\n  const namespaces = Object.fromEntries(\n    Object.entries(expected.namespaces).filter(([, ns]) => Object.keys(ns.tables).length > 0),\n  );\n  return new PostgresDatabaseSchemaNode({\n    namespaces,\n    roles: [...expected.roles],\n    existingSchemas: expected.existingSchemas.filter((s) => namespaces[s] !== undefined),\n    pgVersion: expected.pgVersion,\n  });\n}\n\n/**\n * Resolves a verdict-diff issue's subject's declared control policy directly\n * from the contract, by delegating to the same node-typed resolver\n * ({@link resolvePostgresNodeIssueControlPolicySubject}) the planner uses to\n * gate DDL calls. `undefined` when the issue resolves to no contract subject.\n *\n * A role issue resolves through that same resolver to `external`\n * unconditionally (see its role branch), regardless of the contract's own\n * default policy: a role is referenced by the contract but not owned, and\n * `external`'s existing semantics — a missing declared subject still fails,\n * every extra is suppressed — are exactly the wanted asymmetric grading for\n * a cluster object the framework does not own.\n */\nfunction resolveControlPolicy(\n  issue: SchemaDiffIssue,\n  contract: Contract<SqlStorage>,\n): ControlPolicy | undefined {\n  const nodeIssue = blindCast<\n    SchemaDiffIssue<SqlSchemaDiffNode>,\n    'every node in a Postgres schema diff tree is a SqlSchemaDiffNode'\n  >(issue);\n  return resolvePostgresNodeIssueControlPolicySubject(nodeIssue, contract)\n    ?.explicitNodeControlPolicy;\n}\n\n/**\n * The Postgres full-tree node diff for the family verify verdict: derive\n * the expected tree (resolved leaf values, expander threaded, FK schemas\n * resolved, table-less namespaces pruned), run the generic\n * differ over the trees as derived, and scope out `not-expected` findings under namespaces the\n * contract does not own. Ownership scoping bypasses cluster-scoped subjects\n * (roles today), mirroring the legacy decomposition: relational extras check\n * the PRUNED owned set (the legacy\n * per-namespace walk never visited a table-less namespace, so its live\n * relational contents are invisible), while `structural` extras (RLS\n * policies) check the FULL owned set (the legacy policy diff governed\n * every contract schema regardless of tables — RLS governance does not\n * shrink because a namespace declares no tables). The codec `verifyType`\n * hooks run once per contract namespace with tables against that\n * namespace's paired actual node (the hooks read namespace-scoped state\n * such as `nativeEnums`).\n */\nexport function diffPostgresSchema(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly schema: SqlSchemaIRNode;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n}): SqlSchemaDiffResult {\n  const postgresContract = blindCast<\n    PostgresContract,\n    'diffPostgresSchema is only called with a postgres contract'\n  >(input.contract);\n  PostgresDatabaseSchemaNode.assert(input.schema);\n  const actual = input.schema;\n  const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);\n  const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {\n    annotationNamespace: 'pg',\n    ...ifDefined('expandNativeType', expandNativeType),\n  });\n  const expected = pruneTableLessNamespaces(fullExpected);\n  const relationalOwned = ownedSchemaNames(expected);\n  const structuralOwned = ownedSchemaNames(fullExpected);\n  const issues = diffSchemas(expected, actual).filter((issue) => {\n    if (issue.reason !== 'not-expected') return true;\n    if (isClusterScopedIssue(issue)) return true;\n    const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);\n    const namespaceSegment = issue.path[1];\n    if (namespaceSegment === undefined) return true;\n    const owned = granularity === 'structural' ? structuralOwned : relationalOwned;\n    return owned.has(namespaceSegment);\n  });\n  const namespacePairs = Object.values(expected.namespaces).map((ns) => ({\n    actual: actual.namespaces[ns.schemaName],\n  }));\n  return {\n    issues,\n    resolveControlPolicy: (issue) => resolveControlPolicy(issue, postgresContract),\n    namespacePairs,\n  };\n}\n\n/**\n * Adds an empty namespace node to the actual tree for every expected namespace\n * absent from it. The relational plan diff pairs on namespace: a contract\n * namespace whose live schema does not exist yet must surface each of its\n * tables as `not-found` (→ `CREATE TABLE`), NOT as a single namespace\n * `not-found` that subtree-coalescing would collapse (leaving `CREATE SCHEMA`\n * with no tables). Padding makes the namespaces pair, so only table/column/\n * policy drift surfaces; `CREATE SCHEMA` comes separately from the synthesized\n * namespace-presence stitch (`verifyPostgresNamespacePresence`), never from the\n * tree diff — matching the retired per-namespace-paired relational walk, which\n * paired a missing schema against an empty namespace node.\n */\nfunction padActualNamespaces(\n  expected: PostgresDatabaseSchemaNode,\n  actual: PostgresDatabaseSchemaNode,\n): PostgresDatabaseSchemaNode {\n  const namespaces: Record<string, PostgresNamespaceSchemaNode> = { ...actual.namespaces };\n  let padded = false;\n  for (const schemaName of Object.keys(expected.namespaces)) {\n    if (namespaces[schemaName] === undefined) {\n      namespaces[schemaName] = new PostgresNamespaceSchemaNode({\n        schemaName,\n        tables: {},\n      });\n      padded = true;\n    }\n  }\n  if (!padded) return actual;\n  return new PostgresDatabaseSchemaNode({\n    namespaces,\n    roles: [...actual.roles],\n    existingSchemas: [...actual.existingSchemas],\n    pgVersion: actual.pgVersion,\n  });\n}\n\nexport interface PostgresPlanDiff {\n  /** The desired (\"end\") tree — resolved leaf values (incl. `codecRef`) on every column, table-less namespaces pruned. */\n  readonly expected: PostgresDatabaseSchemaNode;\n  /** The live (\"start\") tree, padded with empty namespaces so a missing schema's tables pair. */\n  readonly actual: PostgresDatabaseSchemaNode;\n  /** The one node diff over the two trees: relational + policy drift, cluster-scope-aware ownership filtered. */\n  readonly issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[];\n}\n\n/**\n * The Postgres planner's diff input: the SAME tree-building\n * `diffPostgresSchema` uses (expander threaded, FK schemas resolved,\n * table-less namespaces pruned, cluster-scope-aware ownership filter) plus\n * actual namespace padding (so a missing\n * schema's tables surface as `not-found` instead of a swallowed namespace\n * `not-found`). One differ drives both verify and plan; this is the\n * plan-side derivation. The single issue list covers tables / columns /\n * constraints / indexes / defaults AND policies — the caller splits it\n * (relational → `mapNodeIssueToCall`; policy → RLS ops) and stitches in\n * `CREATE SCHEMA` separately.\n */\nexport function buildPostgresPlanDiff(input: {\n  readonly contract: Contract<SqlStorage>;\n  readonly actualSchema: SqlSchemaIRNode;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n}): PostgresPlanDiff {\n  const postgresContract = blindCast<\n    PostgresContract,\n    'buildPostgresPlanDiff is only called with a postgres contract'\n  >(input.contract);\n  PostgresDatabaseSchemaNode.assert(input.actualSchema);\n  const actual = input.actualSchema;\n  const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);\n  const projectionOptions = {\n    annotationNamespace: 'pg',\n    ...ifDefined('expandNativeType', expandNativeType),\n  };\n  const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, projectionOptions);\n  const expected = pruneTableLessNamespaces(fullExpected);\n  const paddedActual = padActualNamespaces(expected, actual);\n  const relationalOwned = ownedSchemaNames(expected);\n  const structuralOwned = ownedSchemaNames(fullExpected);\n  const issues = blindCast<\n    readonly SchemaDiffIssue<SqlSchemaDiffNode>[],\n    'both trees are PostgresDatabaseSchemaNodes, so every diff-issue node is a SqlSchemaDiffNode'\n  >(diffSchemas(expected, paddedActual)).filter((issue) => {\n    if (issue.reason !== 'not-expected') return true;\n    if (isClusterScopedIssue(issue)) return true;\n    const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);\n    const namespaceSegment = issue.path[1];\n    if (namespaceSegment === undefined) return true;\n    const owned = granularity === 'structural' ? structuralOwned : relationalOwned;\n    return owned.has(namespaceSegment);\n  });\n  return { expected, actual: paddedActual, issues };\n}\n"],"mappings":"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"}

package/dist/diff-database-schema.d.mts

@@ -0,0 +1,46 @@
+import { t as PostgresDatabaseSchemaNode } from "./postgres-database-schema-node-CJv5bfbs.mjs";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { SqlSchemaIRNode } from "@prisma-next/sql-schema-ir/types";
+import { DiffableNode, SchemaDiffIssue } from "@prisma-next/framework-components/control";
+import { Contract } from "@prisma-next/contract/types";
+import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+
+//#region src/core/schema-ir/schema-node-kinds.d.ts
+/**
+ * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements
+ * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`
+ * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)
+ * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node
+ * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).
+ */
+type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;
+//#endregion
+//#region src/core/migrations/diff-database-schema.d.ts
+interface PostgresPlanDiff {
+  /** The desired ("end") tree — resolved leaf values (incl. `codecRef`) on every column, table-less namespaces pruned. */
+  readonly expected: PostgresDatabaseSchemaNode;
+  /** The live ("start") tree, padded with empty namespaces so a missing schema's tables pair. */
+  readonly actual: PostgresDatabaseSchemaNode;
+  /** The one node diff over the two trees: relational + policy drift, cluster-scope-aware ownership filtered. */
+  readonly issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[];
+}
+/**
+ * The Postgres planner's diff input: the SAME tree-building
+ * `diffPostgresSchema` uses (expander threaded, FK schemas resolved,
+ * table-less namespaces pruned, cluster-scope-aware ownership filter) plus
+ * actual namespace padding (so a missing
+ * schema's tables surface as `not-found` instead of a swallowed namespace
+ * `not-found`). One differ drives both verify and plan; this is the
+ * plan-side derivation. The single issue list covers tables / columns /
+ * constraints / indexes / defaults AND policies — the caller splits it
+ * (relational → `mapNodeIssueToCall`; policy → RLS ops) and stitches in
+ * `CREATE SCHEMA` separately.
+ */
+declare function buildPostgresPlanDiff(input: {
+  readonly contract: Contract<SqlStorage>;
+  readonly actualSchema: SqlSchemaIRNode;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}): PostgresPlanDiff;
+//#endregion
+export { buildPostgresPlanDiff };
+//# sourceMappingURL=diff-database-schema.d.mts.map

package/dist/diff-database-schema.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-database-schema.d.mts","names":[],"sources":["../src/core/schema-ir/schema-node-kinds.ts","../src/core/migrations/diff-database-schema.ts"],"mappings":";;;;;;;;;;;;;;;KAiBY,iBAAA,GAAoB,eAAA,GAAkB,YAAY;;;UCmL7C,gBAAA;EAMW;EAAA,SAJjB,QAAA,EAAU,0BAAA;EAIwC;EAAA,SAFlD,MAAA,EAAQ,0BAAA;EAiBH;EAAA,SAfL,MAAA,WAAiB,eAAA,CAAgB,iBAAA;AAAA;;;;;;;;;;;;;iBAe5B,qBAAA,CAAsB,KAAA;EAAA,SAC3B,QAAA,EAAU,QAAA,CAAS,UAAA;EAAA,SACnB,YAAA,EAAc,eAAA;EAAA,SACd,mBAAA,EAAqB,aAAA,CAAc,8BAAA;AAAA,IAC1C,gBAAA"}

package/dist/diff-database-schema.mjs

@@ -0,0 +1,2 @@
+import { t as buildPostgresPlanDiff } from "./diff-database-schema-DULhiCNM.mjs";
+export { buildPostgresPlanDiff };

package/dist/errors-DO-w0EUS.mjs

@@ -0,0 +1,35 @@
+import { CliStructuredError } from "@prisma-next/errors/control";
+//#region src/core/errors.ts
+/**
+* A `PostgresMigration` operation that needs the materialized control adapter
+* — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —
+* was invoked, but the migration was constructed without a `ControlStack`.
+* Concrete authoring usage always goes through the migration CLI entrypoint,
+* which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
+* error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
+* with the no-arg form (legal for `operations` / `describe` introspection only).
+*
+* The `operation` argument is required so every throw site names the operation
+* that actually failed; a new operation cannot inherit a misattributed message.
+*
+* Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
+* (data-transform query plan against wrong contract) because the missing
+* input is the stack itself, not the per-operation contract.
+*
+* Lives in `@prisma-next/target-postgres/errors` rather than the shared
+* framework migration errors module because the failure is target-specific:
+* the contract it talks about (`PostgresMigration`, the Postgres control
+* adapter, the Postgres-target stack) only exists in this package.
+*/
+function errorPostgresMigrationStackMissing(operation) {
+	return new CliStructuredError("2007", `PostgresMigration.${operation} requires a control adapter`, {
+		domain: "MIG",
+		why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,
+		fix: "Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.",
+		meta: { operation }
+	});
+}
+//#endregion
+export { errorPostgresMigrationStackMissing as t };
+
+//# sourceMappingURL=errors-DO-w0EUS.mjs.map

package/dist/errors-DO-w0EUS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-DO-w0EUS.mjs","names":[],"sources":["../src/core/errors.ts"],"sourcesContent":["import { CliStructuredError } from '@prisma-next/errors/control';\n\n/**\n * A `PostgresMigration` operation that needs the materialized control adapter\n * — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —\n * was invoked, but the migration was constructed without a `ControlStack`.\n * Concrete authoring usage always goes through the migration CLI entrypoint,\n * which assembles a stack from the loaded `prisma-next.config.ts`; reaching this\n * error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`\n * with the no-arg form (legal for `operations` / `describe` introspection only).\n *\n * The `operation` argument is required so every throw site names the operation\n * that actually failed; a new operation cannot inherit a misattributed message.\n *\n * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`\n * (data-transform query plan against wrong contract) because the missing\n * input is the stack itself, not the per-operation contract.\n *\n * Lives in `@prisma-next/target-postgres/errors` rather than the shared\n * framework migration errors module because the failure is target-specific:\n * the contract it talks about (`PostgresMigration`, the Postgres control\n * adapter, the Postgres-target stack) only exists in this package.\n */\nexport function errorPostgresMigrationStackMissing(operation: string): CliStructuredError {\n  return new CliStructuredError(\n    '2007',\n    `PostgresMigration.${operation} requires a control adapter`,\n    {\n      domain: 'MIG',\n      why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,\n      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',\n      meta: { operation },\n    },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,mCAAmC,WAAuC;CACxF,OAAO,IAAI,mBACT,QACA,qBAAqB,UAAU,8BAC/B;EACE,QAAQ;EACR,KAAK,qBAAqB,UAAU;EACpC,KAAK;EACL,MAAM,EAAE,UAAU;CACpB,CACF;AACF"}

package/dist/errors.d.mts

@@ -2,14 +2,16 @@ import { CliStructuredError } from "@prisma-next/errors/control";
 
 //#region src/core/errors.d.ts
 /**
- * A `PostgresMigration` instance method that needs the materialized control
- * adapter (currently only `this.dataTransform(...)`) was invoked, but the
- * migration was constructed without a `ControlStack`. Concrete authoring
- * usage always goes through the migration CLI entrypoint, which assembles
- * a stack from the loaded `prisma-next.config.ts`; reaching this error
- * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
- * with the no-arg form (legal for `operations` / `describe` introspection
- * only).
+ * A `PostgresMigration` operation that needs the materialized control adapter
+ * — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —
+ * was invoked, but the migration was constructed without a `ControlStack`.
+ * Concrete authoring usage always goes through the migration CLI entrypoint,
+ * which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
+ * error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
+ * with the no-arg form (legal for `operations` / `describe` introspection only).
+ *
+ * The `operation` argument is required so every throw site names the operation
+ * that actually failed; a new operation cannot inherit a misattributed message.
  *
  * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
  * (data-transform query plan against wrong contract) because the missing
@@ -20,7 +22,7 @@ import { CliStructuredError } from "@prisma-next/errors/control";
  * the contract it talks about (`PostgresMigration`, the Postgres control
  * adapter, the Postgres-target stack) only exists in this package.
  */
-declare function errorPostgresMigrationStackMissing(): CliStructuredError;
+declare function errorPostgresMigrationStackMissing(operation: string): CliStructuredError;
 //#endregion
 export { errorPostgresMigrationStackMissing };
 //# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;AAqBA;;;;AAAwE;;;;;;;;;;;;;iBAAxD,kCAAA,IAAsC,kBAAkB"}
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":";;;;;AAuBA;;;;AAAyF;;;;;;;;;;;;;;;iBAAzE,kCAAA,CAAmC,SAAA,WAAoB,kBAAkB"}

package/dist/errors.mjs

@@ -1,2 +1,2 @@
-import { t as errorPostgresMigrationStackMissing } from "./errors-CUk87ByX.mjs";
+import { t as errorPostgresMigrationStackMissing } from "./errors-DO-w0EUS.mjs";
 export { errorPostgresMigrationStackMissing };

package/dist/issue-planner.d.mts

@@ -1,11 +1,11 @@
-import { b as PostgresOpFactoryCall } from "./op-factory-call-DmQEc3XV.mjs";
+import { w as PostgresOpFactoryCall } from "./op-factory-call-Bn9zDx4_.mjs";
+import { SqlStorage, StorageTable, StorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { CodecControlHooks, MigrationOperationPolicy, SqlPlannerConflict } from "@prisma-next/family-sql/control";
+import { SqlColumnIR, SqlSchemaIR, SqlSchemaIRNode } from "@prisma-next/sql-schema-ir/types";
+import { DiffableNode, SchemaDiffIssue } from "@prisma-next/framework-components/control";
 import { Result } from "@prisma-next/utils/result";
-import { SqlStorage, StorageTable, StorageTypeInstance } from "@prisma-next/sql-contract/types";
-import { SchemaIssue } from "@prisma-next/framework-components/control";
 import { Contract } from "@prisma-next/contract/types";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
-import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 
 //#region src/core/migrations/planner-strategies.d.ts
 /**
@@ -27,9 +27,16 @@ interface StrategyContext {
   readonly policy: MigrationOperationPolicy;
   readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
 }
-type CallMigrationStrategy = (issues: readonly SchemaIssue[], context: StrategyContext) => {
+/**
+ * Consumes node-typed diff issues (`SchemaDiffIssue`, from the one differ —
+ * `buildPostgresPlanDiff`), reading the issue's node pair for structural
+ * decisions and resolving column DDL from the node's `codecRef`. The
+ * retained subsystems (codec type-operations, the NOT-NULL temp-default
+ * backfill) keep reading the contract via `StrategyContext`.
+ */
+type CallMigrationStrategy = (issues: readonly SchemaDiffIssue[], context: StrategyContext) => {
   kind: 'match';
-  issues: readonly SchemaIssue[];
+  issues: readonly SchemaDiffIssue[];
   calls: readonly PostgresOpFactoryCall[];
   /**
    * `true` for strategies that emit cohesive sequential recipes whose
@@ -44,8 +51,21 @@ type CallMigrationStrategy = (issues: readonly SchemaIssue[], context: StrategyC
 };
 //#endregion
 //#region src/core/migrations/issue-planner.d.ts
+interface IssuePlannerValue {
+  readonly calls: readonly PostgresOpFactoryCall[];
+}
+/**
+ * The generic differ is total: a missing/extra table (or column) emits an
+ * issue for itself AND for every node in its subtree. `CreateTable`/`DropTable`
+ * and `AddColumn`/`DropColumn` already account for the whole subtree, so the
+ * nested issues are redundant — coalescing drops any issue whose path is a
+ * strict descendant of a `not-found`/`not-expected` issue's path. Run over the
+ * relational subset ONLY (policy issues and synthesized namespace issues are
+ * handled on their own paths, never coalesced against tables).
+ */
+declare function coalesceSubtreeIssues<TNode extends DiffableNode = DiffableNode>(issues: readonly SchemaDiffIssue<TNode>[]): readonly SchemaDiffIssue<TNode>[];
 interface IssuePlannerOptions {
-  readonly issues: readonly SchemaIssue[];
+  readonly issues: readonly SchemaDiffIssue[];
   readonly toContract: Contract<SqlStorage>;
   readonly fromContract: Contract<SqlStorage> | null;
   readonly schemaName: string;
@@ -72,10 +92,14 @@ interface IssuePlannerOptions {
   readonly frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
   readonly strategies?: readonly CallMigrationStrategy[];
 }
-interface IssuePlannerValue {
-  readonly calls: readonly PostgresOpFactoryCall[];
-}
+/**
+ * Runs the ordered strategy list over the node-typed diff issues, maps
+ * leftover issues via {@link mapNodeIssueToCall}, applies operation-class
+ * policy gating, and buckets calls into the fixed DDL emission order (dep →
+ * drop → table → column → recipe → alter → primaryKey → unique → index →
+ * foreignKey).
+ */
 declare function planIssues(options: IssuePlannerOptions): Result<IssuePlannerValue, readonly SqlPlannerConflict[]>;
 //#endregion
-export { planIssues };
+export { coalesceSubtreeIssues, planIssues };
 //# sourceMappingURL=issue-planner.d.mts.map

package/dist/issue-planner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"issue-planner.d.mts","names":[],"sources":["../src/core/migrations/planner-strategies.ts","../src/core/migrations/issue-planner.ts"],"mappings":";;;;;;;;;;;;;;;;;;;UA8HiB,eAAA;EAAA,SACN,UAAA,EAAY,QAAA,CAAS,UAAA;EAAA,SACrB,YAAA,EAAc,QAAA,CAAS,UAAA;EAAA,SACvB,UAAA;EAAA,SACA,UAAA,EAAY,WAAA,SAAoB,iBAAA;EAAA,SAChC,YAAA,EAAc,QAAA,CAAS,MAAA,SAAe,mBAAA;EAAA,SACtC,MAAA,EAAQ,WAAA;EAAA,SACR,MAAA,EAAQ,wBAAA;EAAA,SACR,mBAAA,EAAqB,aAAA,CAAc,8BAAA;AAAA;AAAA,KAOlC,qBAAA,IACV,MAAA,WAAiB,WAAA,IACjB,OAAA,EAAS,eAAA;EAGL,IAAA;EACA,MAAA,WAAiB,WAAA;EACjB,KAAA,WAAgB,qBAAA;ECEG;;;;;;;EDMnB,MAAA;AAAA;EAEA,IAAA;AAAA;;;UCXW,mBAAA;EAAA,SACN,MAAA,WAAiB,WAAA;EAAA,SACjB,UAAA,EAAY,QAAA,CAAS,UAAA;EAAA,SACrB,YAAA,EAAc,QAAA,CAAS,UAAA;EAAA,SACvB,UAAA;EAAA,SACA,UAAA,EAAY,WAAA,SAAoB,iBAAA;EAAA,SAChC,YAAA,EAAc,QAAA,CAAS,MAAA,SAAe,mBAAA;EDnBJ;;;;;;;EAAA,SC2BlC,MAAA,GAAS,WAAA;EDhCT;;;;;EAAA,SCsCA,MAAA,GAAS,wBAAA;EDpCc;;;;EAAA,SCyCvB,mBAAA,GAAsB,aAAA,CAAc,8BAAA;EAAA,SACpC,UAAA,YAAsB,qBAAA;AAAA;AAAA,UAGhB,iBAAA;EAAA,SACN,KAAA,WAAgB,qBAAqB;AAAA;AAAA,iBA2pBhC,UAAA,CACd,OAAA,EAAS,mBAAA,GACR,MAAA,CAAO,iBAAA,WAA4B,kBAAA"}
+{"version":3,"file":"issue-planner.d.mts","names":[],"sources":["../src/core/migrations/planner-strategies.ts","../src/core/migrations/issue-planner.ts"],"mappings":";;;;;;;;;;;;;;;;;;;UAwIiB,eAAA;EAAA,SACN,UAAA,EAAY,QAAA,CAAS,UAAA;EAAA,SACrB,YAAA,EAAc,QAAA,CAAS,UAAA;EAAA,SACvB,UAAA;EAAA,SACA,UAAA,EAAY,WAAA,SAAoB,iBAAA;EAAA,SAChC,YAAA,EAAc,QAAA,CAAS,MAAA,SAAe,mBAAA;EAAA,SACtC,MAAA,EAAQ,WAAA;EAAA,SACR,MAAA,EAAQ,wBAAA;EAAA,SACR,mBAAA,EAAqB,aAAA,CAAc,8BAAA;AAAA;;AChB9C;;;;AACgD;AAkThD;KDrRY,qBAAA,IACV,MAAA,WAAiB,eAAA,IACjB,OAAA,EAAS,eAAA;EAGL,IAAA;EACA,MAAA,WAAiB,eAAA;EACjB,KAAA,WAAgB,qBAAA;EC+Qa;;;;;;;EDvQ7B,MAAA;AAAA;EAEA,IAAA;AAAA;;;UC/CW,iBAAA;EAAA,SACN,KAAA,WAAgB,qBAAqB;AAAA;;;;;;;;;;iBAkThC,qBAAA,eAAoC,YAAA,GAAe,YAAA,EACjE,MAAA,WAAiB,eAAA,CAAgB,KAAA,eACvB,eAAA,CAAgB,KAAA;AAAA,UAgiBX,mBAAA;EAAA,SACN,MAAA,WAAiB,eAAA;EAAA,SACjB,UAAA,EAAY,QAAA,CAAS,UAAA;EAAA,SACrB,YAAA,EAAc,QAAA,CAAS,UAAA;EAAA,SACvB,UAAA;EAAA,SACA,UAAA,EAAY,WAAA,SAAoB,iBAAA;EAAA,SAChC,YAAA,EAAc,QAAA,CAAS,MAAA,SAAe,mBAAA;EAviBd;;;;;;;EAAA,SA+iBxB,MAAA,GAAS,WAAA;EAhjB+C;;;;;EAAA,SAsjBxD,MAAA,GAAS,wBAAA;EApjBa;AAAA;AAgiBjC;;EAhiBiC,SAyjBtB,mBAAA,GAAsB,aAAA,CAAc,8BAAA;EAAA,SACpC,UAAA,YAAsB,qBAAA;AAAA;;;;;;;;iBAUjB,UAAA,CACd,OAAA,EAAS,mBAAA,GACR,MAAA,CAAO,iBAAA,WAA4B,kBAAA"}

package/dist/issue-planner.mjs

@@ -1,2 +1,2 @@
-import { t as planIssues } from "./issue-planner-DL6g3CmE.mjs";
-export { planIssues };
+import { l as planIssues, o as coalesceSubtreeIssues } from "./control-policy-5LE2kwfb.mjs";
+export { coalesceSubtreeIssues, planIssues };

package/dist/migration.d.mts

@@ -1,7 +1,7 @@
-import { n as DataTransformOptions, r as dataTransform, t as DataTransformClosure } from "./data-transform-DDgWdB5o.mjs";
-import { T as Op } from "./op-factory-call-DmQEc3XV.mjs";
-import { t as PostgresMigration } from "./postgres-migration-Y4YBJqkS.mjs";
-import { col, fn, foreignKey, lit, primaryKey, unique } from "@prisma-next/sql-relational-core/contract-free";
+import { n as DataTransformOptions, r as dataTransform, t as DataTransformClosure } from "./data-transform-DPzwBMhW.mjs";
+import { k as Op } from "./op-factory-call-Bn9zDx4_.mjs";
+import { t as PostgresMigration } from "./postgres-migration-DbckK1su.mjs";
+import { checkExpression, col, fn, foreignKey, lit, primaryKey, unique } from "@prisma-next/sql-relational-core/contract-free";
 import { placeholder } from "@prisma-next/errors/migration";
 import { MigrationCLI } from "@prisma-next/cli/migration-cli";
 import { ExecuteRequestLowerer } from "@prisma-next/family-sql/control-adapter";
@@ -22,5 +22,5 @@ declare function createExtension(extensionName: string): Op;
  */
 declare function rawSql(op: Op): Op;
 //#endregion
-export { type DataTransformClosure, type DataTransformOptions, PostgresMigration as Migration, MigrationCLI, col, createExtension, dataTransform, fn, foreignKey, lit, placeholder, primaryKey, rawSql, unique };
+export { type DataTransformClosure, type DataTransformOptions, PostgresMigration as Migration, MigrationCLI, checkExpression, col, createExtension, dataTransform, fn, foreignKey, lit, placeholder, primaryKey, rawSql, unique };
 //# sourceMappingURL=migration.d.mts.map

package/dist/migration.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration.d.mts","names":[],"sources":["../src/core/migrations/operations/dependencies.ts","../src/core/migrations/operations/raw.ts"],"mappings":";;;;;;;;;iBAKgB,eAAA,CAAgB,aAAA,WAAwB,EAAE;;;;;;;;;;;AAA1D;;iBCOgB,MAAA,CAAO,EAAA,EAAI,EAAA,GAAK,EAAE"}
+{"version":3,"file":"migration.d.mts","names":[],"sources":["../src/core/migrations/operations/dependencies.ts","../src/core/migrations/operations/raw.ts"],"mappings":";;;;;;;;;iBAMgB,eAAA,CAAgB,aAAA,WAAwB,EAAE;;;;;;;;;;;AAA1D;;iBCMgB,MAAA,CAAO,EAAA,EAAI,EAAA,GAAK,EAAE"}