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

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

@@ -0,0 +1,191 @@
+import type { Contract } from '@prisma-next/contract/types';
+import { verifySqlSchemaTree } from '@prisma-next/family-sql/diff';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  SchemaDiffIssue,
+  VerifyDatabaseSchemaResult,
+} from '@prisma-next/framework-components/control';
+import { diffSchemas, SchemaDiff } from '@prisma-next/framework-components/control';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { parsePostgresDefault } from '../default-normalizer';
+import { normalizeSchemaNativeType } from '../native-type-normalizer';
+import type { PostgresContract } from '../postgres-schema';
+import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
+import { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';
+import type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';
+import { contractToPostgresDatabaseSchemaNode } from './contract-to-postgres-database-schema-node';
+
+interface PostgresDiffDatabaseSchemaInput {
+  readonly contract: Contract<SqlStorage>;
+  readonly actualSchema: SqlSchemaIRNode;
+  readonly strict: boolean;
+  readonly typeMetadataRegistry: ReadonlyMap<string, { readonly nativeType?: string }>;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}
+
+/**
+ * The single combined database-schema comparison — the one computation the
+ * migration planner and the family schema verify both consume. Composes,
+ * once each:
+ *
+ * - the per-namespace-paired relational diff (`verifySqlSchemaTree`) → table /
+ *   column / constraint findings as framework `SchemaIssue`s (with the
+ *   verification-tree `root` and pass/warn/fail counts);
+ * - the policy diff (`diffPostgresSchema` over the two trees) → RLS policy
+ *   presence as `SchemaDiffIssue`s, ownership-filtered to the contract's owned
+ *   schemas.
+ *
+ * `diffPostgresDatabaseSchema` and `verifyPostgresDatabaseSchema` both read
+ * this single result, so the relational walk runs once per caller — never
+ * once for the diff and again for the verify tree.
+ */
+function computePostgresSchemaComparison(input: PostgresDiffDatabaseSchemaInput): {
+  readonly relational: VerifyDatabaseSchemaResult;
+  readonly schemaDiffIssues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[];
+} {
+  const postgresContract = blindCast<
+    PostgresContract,
+    'diffPostgresDatabaseSchema is only called with a postgres contract'
+  >(input.contract);
+
+  // Relational diff: per-namespace-paired so a multi-schema database checks each
+  // contract namespace against its own actual node.
+  const relational = verifySqlSchemaTree({
+    contract: input.contract,
+    actualSchema: input.actualSchema,
+    buildExpectedSchema: (scopedContract) =>
+      contractToPostgresDatabaseSchemaNode(
+        blindCast<
+          PostgresContract | null,
+          'the relational pairing projects a scoped postgres contract'
+        >(scopedContract),
+        { annotationNamespace: 'pg' },
+      ),
+    strict: input.strict,
+    typeMetadataRegistry: input.typeMetadataRegistry,
+    frameworkComponents: input.frameworkComponents,
+    normalizeDefault: parsePostgresDefault,
+    normalizeNativeType: normalizeSchemaNativeType,
+  });
+
+  // Policy diff: the generic node differ over the expected/actual policy trees,
+  // ownership-filtered to the schemas the contract owns (so unowned-namespace
+  // policies are not reported as extras). The actual schema is always the
+  // Postgres database root in production — assert it, matching the prior
+  // `collectSchemaDiffIssues` / `planPostgresSchemaDiff` behaviour.
+  PostgresDatabaseSchemaNode.assert(input.actualSchema);
+  const expected = contractToPostgresDatabaseSchemaNode(postgresContract, {
+    annotationNamespace: 'pg',
+  });
+  const schemaDiffIssues = filterIssuesByOwnership(
+    diffPostgresSchema(expected, input.actualSchema),
+    ownedSchemaNames(expected),
+  );
+
+  return { relational, schemaDiffIssues };
+}
+
+/**
+ * The `SchemaDiffer` for Postgres: the target's black-box comparison,
+ * projected to the two issue lists. Namespace presence (`missing_schema` →
+ * `CREATE SCHEMA`) is intentionally NOT composed here: it is a planner-only
+ * op-generation concern (verify rejects on the relational `missing_table` a
+ * missing schema already produces), so the planner stitches it in around this
+ * diff. Control-policy suppression of the policy issues is likewise a
+ * per-consumer post-step (verify filters the issues; the planner filters the
+ * calls).
+ */
+export function diffPostgresDatabaseSchema(
+  input: PostgresDiffDatabaseSchemaInput,
+): SchemaDiff<SqlSchemaDiffNode> {
+  const { relational, schemaDiffIssues } = computePostgresSchemaComparison(input);
+  return new SchemaDiff(relational.schema.issues, schemaDiffIssues);
+}
+
+/**
+ * The same combined comparison as {@link diffPostgresDatabaseSchema}, wrapped
+ * in the verify envelope (`ok`/`summary`/`code`/`target`/`timings`) plus the
+ * pass/warn/fail tree the CLI renders — i.e. exactly the existing verify-result
+ * schema shape, so nothing downstream changes.
+ */
+export function verifyPostgresDatabaseSchema(
+  input: PostgresDiffDatabaseSchemaInput,
+): VerifyDatabaseSchemaResult {
+  const { relational, schemaDiffIssues } = computePostgresSchemaComparison(input);
+  return {
+    ...relational,
+    schema: { ...relational.schema, schemaDiffIssues },
+  };
+}
+
+function ownedSchemaNames(expected: PostgresDatabaseSchemaNode): ReadonlySet<string> {
+  const policyNamespaces = Object.values(expected.namespaces).flatMap((ns) =>
+    Object.values(ns.tables).flatMap((t) => t.policies.map((p) => p.namespaceId)),
+  );
+  return new Set([...policyNamespaces, ...expected.existingSchemas]);
+}
+
+// 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: PostgresPolicySchemaNode): string {
+  return `policy "${policy.name}" on "${policy.namespaceId}"."${policy.tableName}"`;
+}
+
+/**
+ * The policy node-diff — the structural half of the combined comparison above.
+ * Computes RLS-policy drift between two derived schema trees:
+ *
+ * 1. Runs the framework total diff over the two `PostgresDatabaseSchemaNode`
+ *    roots (database → namespace → table → policy).
+ * 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.
+ *
+ * Both trees are `PostgresDatabaseSchemaNode`s, so every issue node is a
+ * `SqlSchemaDiffNode` — narrow the framework's `SchemaDiffIssue<DiffableNode>`
+ * output once here (the single boundary cast), so every downstream consumer
+ * (the ownership filter, the planner) reads the concrete node with no cast.
+ *
+ * Ownership filtering (dropping `extra` issues in namespaces a contract doesn't
+ * own) is the caller's responsibility — use `filterIssuesByOwnership`.
+ */
+export function diffPostgresSchema(
+  expected: PostgresDatabaseSchemaNode,
+  actual: PostgresDatabaseSchemaNode,
+): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {
+  const issues = blindCast<
+    readonly SchemaDiffIssue<SqlSchemaDiffNode>[],
+    'both trees are PostgresDatabaseSchemaNodes, so every diff-issue node is a SqlSchemaDiffNode'
+  >(diffSchemas(expected, actual));
+
+  return issues
+    .filter((i) => {
+      const node = i.expected ?? i.actual;
+      return node !== undefined && PostgresPolicySchemaNode.is(node);
+    })
+    .map((i) => {
+      const node = i.expected ?? i.actual;
+      if (node === undefined || !PostgresPolicySchemaNode.is(node)) return i;
+      return { ...i, message: `${i.outcome}: ${renderPostgresPolicyReference(node)}` };
+    });
+}
+
+/**
+ * Filters `extra` policy issues to those in owned namespaces. Call after
+ * `diffPostgresSchema` with the union of namespace ids from the expected tree's
+ * policies and its `existingSchemas`.
+ */
+export function filterIssuesByOwnership(
+  issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],
+  ownedSchemaNameSet: ReadonlySet<string>,
+): readonly SchemaDiffIssue<SqlSchemaDiffNode>[] {
+  return issues.filter((i) => {
+    if (i.outcome !== 'extra') return true;
+    if (i.actual === undefined) return false;
+    return PostgresPolicySchemaNode.is(i.actual) && ownedSchemaNameSet.has(i.actual.namespaceId);
+  });
+}

package/src/core/migrations/issue-planner.ts

@@ -15,7 +15,7 @@ import type {
   SqlPlannerConflict,
   SqlPlannerConflictLocation,
 } from '@prisma-next/family-sql/control';
-import { arraysEqual } from '@prisma-next/family-sql/schema-verify';
+import { arraysEqual } from '@prisma-next/family-sql/diff';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 import type {

package/src/core/migrations/op-factory-call.ts

@@ -40,7 +40,7 @@ import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { columnExistsAst, tableExistsAst } from '../../contract-free/checks';
 import * as contractFreeDdl from '../../contract-free/ddl';
-import type { PostgresRlsPolicy } from '../schema-ir/postgres-rls-policy';
+import type { PostgresRlsPolicy } from '../postgres-rls-policy';
 import { escapeLiteral, quoteIdentifier } from '../sql-utils';
 import type { PostgresColumnDefault } from '../types';
 import { boundSchema } from './bound-schema';

package/src/core/migrations/operations/rls.ts

@@ -2,7 +2,7 @@ import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adap
 import { ifDefined } from '@prisma-next/utils/defined';
 import { rlsEnabledAst, rlsPolicyExistsAst } from '../../../contract-free/checks';
 import { createPolicy, dropPolicy } from '../../../contract-free/ddl';
-import type { PostgresRlsPolicy } from '../../schema-ir/postgres-rls-policy';
+import type { PostgresRlsPolicy } from '../../postgres-rls-policy';
 import { qualifyTableName } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
 

package/src/core/migrations/planner.ts

@@ -13,30 +13,29 @@ import {
   plannerFailure,
 } from '@prisma-next/family-sql/control';
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
-import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   MigrationPlanner,
   MigrationPlanWithAuthoringSurface,
   MigrationScaffoldContext,
+  SchemaDiffIssue,
   SchemaIssue,
 } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
-import { parsePostgresDefault } from '../default-normalizer';
-import { normalizeSchemaNativeType } from '../native-type-normalizer';
-import type { PostgresContract } from '../postgres-schema';
-import { assertPostgresRlsPolicy } from '../schema-ir/postgres-rls-policy';
-import { assertPostgresSchemaIR, ensurePostgresSchemaIR } from '../schema-ir/postgres-schema-ir';
-import { resolveDdlSchemaForNamespaceStorage } from '../schema-ir/postgres-schema-ir-annotations';
-import { contractToPostgresSchemaIR } from './contract-to-postgres-schema-ir';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { PostgresRlsPolicy } from '../postgres-rls-policy';
+import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
+import { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';
+import type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';
 import {
   formatPostgresControlPolicySubjectLabel,
   resolvePostgresCallControlPolicySubject,
   resolvePostgresIssueControlPolicySubject,
   resolvePostgresIssueCreationFactoryName,
 } from './control-policy';
-import { diffPostgresSchema, filterIssuesByOwnership } from './diff-postgres-schema';
+import { diffPostgresDatabaseSchema } from './diff-database-schema';
 import { planIssues } from './issue-planner';
 import type { PostgresOpFactoryCall } from './op-factory-call';
 import {
@@ -46,6 +45,7 @@ import {
 } from './op-factory-call';
 import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
 import { postgresPlannerStrategies } from './planner-strategies';
+import { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';
 import { verifyPostgresNamespacePresence } from './verify-postgres-namespaces';
 
 type PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {
@@ -58,10 +58,6 @@ type PlannerOptionsWithComponents = SqlMigrationPlannerPlanOptions & {
   readonly frameworkComponents: PlannerFrameworkComponents;
 };
 
-type VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0] & {
-  readonly frameworkComponents: PlannerFrameworkComponents;
-};
-
 export function createPostgresMigrationPlanner(
   lowerer: ExecuteRequestLowerer,
 ): PostgresMigrationPlanner {
@@ -162,9 +158,33 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       return policyResult;
     }
 
-    const schemaIssues = this.collectSchemaIssues(options);
+    // One combined database-schema diff drives the whole plan: the relational
+    // findings (+ namespace presence) become structural DDL via `planIssues`,
+    // the policy findings become RLS ops via `planPostgresSchemaDiff`. Verify
+    // runs the same underlying comparison (via `verifyDatabaseSchema`) and
+    // rejects on non-empty. The caller-supplied `keepDiffIssue` predicate is
+    // applied blindly — any scoping (e.g. multi-space ownership) is the
+    // orchestration's, never worked out here.
+    PostgresDatabaseSchemaNode.assert(options.schema);
+    const rawDiff = diffPostgresDatabaseSchema({
+      contract: options.contract,
+      actualSchema: options.schema,
+      strict:
+        options.policy.allowedOperationClasses.includes('widening') ||
+        options.policy.allowedOperationClasses.includes('destructive'),
+      typeMetadataRegistry: new Map(),
+      frameworkComponents: options.frameworkComponents,
+    });
+    const databaseDiff = options.keepDiffIssue ? rawDiff.filter(options.keepDiffIssue) : rawDiff;
+    const schemaIssues = this.collectSchemaIssues(options, databaseDiff.issues);
     const codecHooks = extractCodecControlHooks(options.frameworkComponents);
     const storageTypes = options.contract.storage.types ?? {};
+    // The strategy layer reads the live schema by bare table name for existence
+    // checks (shared-temp-default safety, FK/unique probes), so it takes one
+    // per-schema namespace node — never the whole tree root, and never a flat
+    // merge of every namespace (which would collide same-named tables across
+    // schemas). Probing more than one namespace at once is future work.
+    const relationalSchema = relationalNamespaceNode(options.schema, schemaName);
 
     // Input-side control-policy partition. `external` / `observed` subjects
     // — and non-creation issues for `tolerated` subjects — are dropped from
@@ -195,7 +215,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       schemaName,
       codecHooks,
       storageTypes,
-      schema: options.schema,
+      ...ifDefined('schema', relationalSchema),
       policy: options.policy,
       frameworkComponents: options.frameworkComponents,
       strategies: postgresPlannerStrategies,
@@ -205,7 +225,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       return plannerFailure(result.failure);
     }
 
-    const schemaDiffCalls = this.planPostgresSchemaDiff(options);
+    const schemaDiffCalls = this.planPostgresSchemaDiff(options, databaseDiff.schemaDiffIssues);
     const schemaDiffPartition = partitionCallsByControlPolicy({
       calls: schemaDiffCalls,
       contract: options.contract,
@@ -263,24 +283,16 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     });
   }
 
+  /**
+   * Maps the RLS policy presence findings of the shared
+   * `diffPostgresDatabaseSchema` (already ownership-filtered) into
+   * `ENABLE RLS` / `CREATE POLICY` / `DROP POLICY` ops. It no longer re-diffs —
+   * it consumes the `schemaDiffIssues` of the one combined diff.
+   */
   private planPostgresSchemaDiff(
     options: PlannerOptionsWithComponents,
+    filteredDiffIssues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],
   ): readonly PostgresOpFactoryCall[] {
-    assertPostgresSchemaIR(options.schema);
-    const expected = contractToPostgresSchemaIR(
-      blindCast<PostgresContract, 'planPostgresSchemaDiff is only called with a postgres contract'>(
-        options.contract,
-      ),
-      { annotationNamespace: 'pg' },
-    );
-    const actual = ensurePostgresSchemaIR(options.schema);
-    const rawIssues = diffPostgresSchema(expected, actual);
-    const ownedSchemaNames = new Set([
-      ...expected.rlsPolicies.map((p) => p.namespaceId),
-      ...expected.existingSchemas,
-    ]);
-    const filteredDiffIssues = filterIssuesByOwnership(rawIssues, ownedSchemaNames);
-
     const allowsDestructive = options.policy.allowedOperationClasses.includes('destructive');
     const calls: PostgresOpFactoryCall[] = [];
     const seenEnableTables = new Set<string>();
@@ -290,32 +302,34 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       // encodes the body hash, so two policies sharing a local key (same name)
       // are always equal and isEqualTo never returns false.
       if (issue.outcome === 'missing') {
-        assertPostgresRlsPolicy(issue.expected);
-        // issue.expected.namespaceId is the DDL schema name (resolved during projection);
+        const expected = issue.expected;
+        PostgresPolicySchemaNode.assert(expected);
+        // expected.namespaceId is the DDL schema name (resolved during projection);
         // this re-resolution is a no-op as long as PostgresSchema.ddlSchemaName() returns this.id.
         const schemaForTable = resolveDdlSchemaForNamespaceStorage(
           options.contract.storage,
-          issue.expected.namespaceId,
-          options.schema,
+          expected.namespaceId,
         );
-        const tableKey = `${schemaForTable}.${issue.expected.tableName}`;
+        const tableKey = `${schemaForTable}.${expected.tableName}`;
         if (!seenEnableTables.has(tableKey)) {
           seenEnableTables.add(tableKey);
-          calls.push(new EnableRowLevelSecurityCall(schemaForTable, issue.expected.tableName));
+          calls.push(new EnableRowLevelSecurityCall(schemaForTable, expected.tableName));
         }
         calls.push(
-          new CreatePostgresRlsPolicyCall(schemaForTable, issue.expected.tableName, issue.expected),
+          new CreatePostgresRlsPolicyCall(
+            schemaForTable,
+            expected.tableName,
+            policyNodeToContractPolicy(expected),
+          ),
         );
       } else if (issue.outcome === 'extra' && allowsDestructive) {
-        assertPostgresRlsPolicy(issue.actual);
+        const actual = issue.actual;
+        PostgresPolicySchemaNode.assert(actual);
         const schemaForTable = resolveDdlSchemaForNamespaceStorage(
           options.contract.storage,
-          issue.actual.namespaceId,
-          options.schema,
-        );
-        calls.push(
-          new DropPostgresRlsPolicyCall(schemaForTable, issue.actual.tableName, issue.actual.name),
+          actual.namespaceId,
         );
+        calls.push(new DropPostgresRlsPolicyCall(schemaForTable, actual.tableName, actual.name));
       }
     }
 
@@ -335,35 +349,70 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     return null;
   }
 
-  private collectSchemaIssues(options: PlannerOptionsWithComponents): readonly SchemaIssue[] {
-    // `db init` uses additive-only policy and intentionally ignores extra
-    // schema objects. Any reconciliation-capable policy (widening or
-    // destructive) must inspect extras to reconcile strict equality.
-    const allowed = options.policy.allowedOperationClasses;
-    const strict = allowed.includes('widening') || allowed.includes('destructive');
-    const verifyOptions: VerifySqlSchemaOptionsWithComponents = {
-      contract: options.contract,
-      schema: options.schema,
-      strict,
-      typeMetadataRegistry: new Map(),
-      frameworkComponents: options.frameworkComponents,
-      normalizeDefault: parsePostgresDefault,
-      normalizeNativeType: normalizeSchemaNativeType,
-    };
-    const verifyResult = verifySqlSchema(verifyOptions);
-    // Schema presence is a Postgres-specific concern (no equivalent in
-    // SQLite / Mongo), so the issue emission lives in the target layer
-    // rather than in the family verifier. Stitch it in here so a single
-    // `SchemaIssue[]` flows through `planIssues` and the planner emits
-    // CREATE SCHEMA in the dep bucket before any CreateTableCall.
-    // Schema drift is handled separately via diffPostgresSchema → planPostgresSchemaDiff.
+  /**
+   * The structural issue list `planIssues` consumes: the relational findings
+   * from the shared `diffPostgresDatabaseSchema` plus namespace presence.
+   *
+   * Schema presence (`missing_schema` → `CREATE SCHEMA`) is a planner-only
+   * op-generation concern, so it is stitched in here rather than inside the
+   * shared diff — verify never needs it (a missing schema already surfaces as
+   * `missing_table` in the relational findings). It reads `existingSchemas` off
+   * the database root, so it takes the whole tree. Policy drift is handled
+   * separately via `planPostgresSchemaDiff` from the same shared diff's
+   * `schemaDiffIssues`.
+   */
+  private collectSchemaIssues(
+    options: PlannerOptionsWithComponents,
+    relationalIssues: readonly SchemaIssue[],
+  ): readonly SchemaIssue[] {
     const namespaceIssues = verifyPostgresNamespacePresence({
       contract: options.contract,
       schema: options.schema,
     });
     if (namespaceIssues.length === 0) {
-      return verifyResult.schema.issues;
+      return relationalIssues;
     }
-    return [...namespaceIssues, ...verifyResult.schema.issues];
+    return [...namespaceIssues, ...relationalIssues];
   }
 }
+
+/**
+ * Returns the one namespace node whose tables the relational strategy layer
+ * probes for live-table existence — the node matching the planner's resolved
+ * schema name, or the first namespace when none matches. `undefined` when the
+ * tree has no namespaces, so the strategy context uses its empty-schema default.
+ *
+ * The relational strategies key tables by bare name, so they can only probe one
+ * namespace at a time; probing across every namespace at once is future work.
+ */
+function relationalNamespaceNode(
+  schema: PostgresDatabaseSchemaNode,
+  schemaName: string,
+): SqlSchemaIR | undefined {
+  const namespaceNodes = Object.values(schema.namespaces);
+  const byName = namespaceNodes.find((node) => node.schemaName === schemaName);
+  return byName ?? namespaceNodes[0];
+}
+
+/**
+ * Rebuilds the `PostgresRlsPolicy` contract entity `CreatePostgresRlsPolicyCall`
+ * carries (its `renderTypeScript`/`createRlsPolicy` paths serialize the whole
+ * entity, `namespaceId` included). This reconstructs rather than looking the
+ * original up in the contract on purpose: the diff node's `namespaceId` is the
+ * *resolved DDL schema* (set when the expected tree was built), which is the
+ * value the emitted op must carry; the contract-stored entity holds the raw,
+ * pre-resolution coordinate, so a lookup would change the migration output.
+ */
+function policyNodeToContractPolicy(node: PostgresPolicySchemaNode): PostgresRlsPolicy {
+  return new PostgresRlsPolicy({
+    name: node.name,
+    prefix: node.prefix,
+    tableName: node.tableName,
+    namespaceId: node.namespaceId,
+    operation: node.operation,
+    roles: [...node.roles],
+    ...ifDefined('using', node.using),
+    ...ifDefined('withCheck', node.withCheck),
+    permissive: node.permissive,
+  });
+}

package/src/core/{schema-ir/postgres-schema-ir-annotations.ts → migrations/resolve-ddl-schema.ts}

@@ -1,18 +1,20 @@
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
-import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import { isPostgresSchema } from '../postgres-schema';
-import { isPostgresSchemaIR } from './postgres-schema-ir';
 
+/**
+ * Given the contract's storage and a namespace id, returns the live Postgres
+ * DDL schema name that namespace maps to. A named Postgres namespace dispatches
+ * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to `public`
+ * (the search-path default for offline planning); a bare object payload (used
+ * by some tests) falls back to the namespace id itself.
+ */
 export function resolveDdlSchemaForNamespaceStorage(
   storage: SqlStorage,
   namespaceId: string,
-  schemaIr?: SqlSchemaIR,
 ): string {
   if (namespaceId === UNBOUND_NAMESPACE_ID) {
-    return (
-      (schemaIr && isPostgresSchemaIR(schemaIr) ? schemaIr.pgSchemaName : undefined) ?? 'public'
-    );
+    return 'public';
   }
   const namespace = storage.namespaces[namespaceId];
   if (namespace && isPostgresSchema(namespace)) {

package/src/core/migrations/runner.ts

@@ -12,7 +12,6 @@ import type {
   SqlMigrationRunnerSuccessValue,
 } from '@prisma-next/family-sql/control';
 import { runnerFailure, runnerSuccess } from '@prisma-next/family-sql/control';
-import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { MigrationRunnerResult } from '@prisma-next/framework-components/control';
 import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
@@ -23,8 +22,6 @@ import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
-import { parsePostgresDefault } from '../default-normalizer';
-import { normalizeSchemaNativeType } from '../native-type-normalizer';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 interface ApplyPlanSuccessValue {
@@ -124,30 +121,30 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
       applyValue = applyResult.value;
     }
 
-    // Schema verification on app-space only — extension spaces don't
-    // own user-facing tables in the live schema, and `verifySqlSchema`
-    // matches the destination contract against the database, which
-    // would flag every app-space table as "extra" when called against
-    // an extension contract.
+    // Verify the schema on app-space only: extension spaces don't own
+    // user-facing tables, so verifying the destination contract against the
+    // database would flag every app-space table as "extra". Delegates to the
+    // family `verifySchema` — the same comparison the CLI verify runs.
     if (space === APP_SPACE_ID) {
-      const schemaIR = await this.family.introspect({
+      const schemaNode = await this.family.introspect({
         driver,
         contract: options.destinationContract,
       });
-      const schemaVerifyResult = verifySqlSchema({
+      const schemaVerifyResult = this.family.verifySchema({
         contract: options.destinationContract,
-        schema: schemaIR,
+        schema: schemaNode,
         strict: options.strictVerification ?? true,
-        context: options.context ?? {},
-        typeMetadataRegistry: this.family.typeMetadataRegistry,
         frameworkComponents: options.frameworkComponents,
-        normalizeDefault: parsePostgresDefault,
-        normalizeNativeType: normalizeSchemaNativeType,
       });
       if (!schemaVerifyResult.ok) {
         return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {
           why: 'The resulting database schema does not satisfy the destination contract.',
-          meta: { issues: schemaVerifyResult.schema.issues },
+          meta: {
+            issues: [
+              ...schemaVerifyResult.schema.issues,
+              ...schemaVerifyResult.schema.schemaDiffIssues,
+            ],
+          },
         });
       }
     }