@prisma-next/target-postgres 0.14.0-dev.21 → 0.14.0-dev.23

package/src/core/migrations/planner.ts

@@ -25,16 +25,18 @@ import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { blindCast } from '@prisma-next/utils/casts';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
-import { assertPostgresRlsPolicy } from '../postgres-rls-policy';
-import { isPostgresSchema } from '../postgres-schema';
-import { isPostgresSchemaIR } from '../postgres-schema-ir';
-import { resolveDdlSchemaForNamespaceStorage } from '../postgres-schema-ir-annotations';
+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 {
   formatPostgresControlPolicySubjectLabel,
   resolvePostgresCallControlPolicySubject,
   resolvePostgresIssueControlPolicySubject,
   resolvePostgresIssueCreationFactoryName,
 } from './control-policy';
+import { diffPostgresSchema, filterIssuesByOwnership } from './diff-postgres-schema';
 import { planIssues } from './issue-planner';
 import type { PostgresOpFactoryCall } from './op-factory-call';
 import {
@@ -45,7 +47,6 @@ import {
 import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
 import { postgresPlannerStrategies } from './planner-strategies';
 import { verifyPostgresNamespacePresence } from './verify-postgres-namespaces';
-import { diffPostgresRlsPolicies } from './verify-postgres-rls-policies';
 
 type PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {
   readonly frameworkComponents: infer T;
@@ -204,36 +205,9 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       return plannerFailure(result.failure);
     }
 
-    // Translate RLS diff issues to DDL calls and run through control-policy
-    // partition. This runs AFTER the structural planIssues pass so the RLS
-    // calls can refer to tables that may have been created in this plan.
-    //
-    // Fail loud when the contract declares RLS policies but the schema is
-    // contract-derived (migration plan path). Without a live-introspected
-    // PostgresSchemaIR there is no baseline to reconcile against, so
-    // silently emitting no RLS DDL would be wrong. The user must run
-    // `db update` / `db init` against a live database to emit RLS.
-    if (!isPostgresSchemaIR(options.schema)) {
-      const policyNames: string[] = [];
-      for (const ns of Object.values(options.contract.storage.namespaces)) {
-        if (isPostgresSchema(ns)) {
-          for (const [policyName, policy] of Object.entries(ns.policy)) {
-            policyNames.push(`${policy.tableName}.${policyName}`);
-          }
-        }
-      }
-      if (policyNames.length > 0) {
-        return plannerFailure([
-          {
-            kind: 'unsupportedOperation',
-            summary: `migration plan does not yet emit RLS policies (the offline contract→schema derivation cannot carry them). Author RLS via 'db update' / 'db init' against a live database. Tracked for a follow-up slice (extension migration participation seam). Affected policies: ${policyNames.join(', ')}`,
-          },
-        ]);
-      }
-    }
-    const rlsCalls = this.planRlsDiff(options);
-    const rlsPartition = partitionCallsByControlPolicy({
-      calls: rlsCalls,
+    const schemaDiffCalls = this.planPostgresSchemaDiff(options);
+    const schemaDiffPartition = partitionCallsByControlPolicy({
+      calls: schemaDiffCalls,
       contract: options.contract,
       resolveControlPolicySubject: (call) =>
         resolvePostgresCallControlPolicySubject(call, options.contract),
@@ -267,10 +241,10 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       formatSubjectLabel: (factoryName, subject) =>
         formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),
     });
-    const calls = [...result.value.calls, ...rlsPartition.kept, ...fieldEventPartition.kept];
+    const calls = [...result.value.calls, ...schemaDiffPartition.kept, ...fieldEventPartition.kept];
     const warnings: SqlPlannerConflict[] = [
       ...issuePartition.warnings,
-      ...rlsPartition.warnings,
+      ...schemaDiffPartition.warnings,
       ...fieldEventPartition.warnings,
     ];
 
@@ -289,35 +263,41 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     });
   }
 
-  private planRlsDiff(options: PlannerOptionsWithComponents): readonly PostgresOpFactoryCall[] {
-    if (!isPostgresSchemaIR(options.schema)) {
-      // Non-PostgresSchemaIR (migration plan path) reaches here only when the
-      // contract declares NO policies — `planSql` already returned a failure
-      // for the has-policies case. This [] is the genuine no-RLS case.
-      return [];
-    }
-    const diffIssues = diffPostgresRlsPolicies({
-      contract: options.contract,
-      schema: options.schema,
-    });
+  private planPostgresSchemaDiff(
+    options: PlannerOptionsWithComponents,
+  ): 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>();
 
-    for (const issue of diffIssues) {
-      const { namespaceId, entityName: policyName } = issue.coordinate;
-      const schemaForTable = resolveDdlSchemaForNamespaceStorage(
-        options.contract.storage,
-        namespaceId,
-        options.schema,
-      );
-
+    for (const issue of filteredDiffIssues) {
       // 'mismatch' is unreachable for content-addressed policies: the wire name
-      // encodes the body hash, so two policies sharing a coordinate (same name)
+      // 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);
+        // 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,
+        );
         const tableKey = `${schemaForTable}.${issue.expected.tableName}`;
         if (!seenEnableTables.has(tableKey)) {
           seenEnableTables.add(tableKey);
@@ -328,8 +308,13 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         );
       } else if (issue.outcome === 'extra' && allowsDestructive) {
         assertPostgresRlsPolicy(issue.actual);
+        const schemaForTable = resolveDdlSchemaForNamespaceStorage(
+          options.contract.storage,
+          issue.actual.namespaceId,
+          options.schema,
+        );
         calls.push(
-          new DropPostgresRlsPolicyCall(schemaForTable, issue.actual.tableName, policyName),
+          new DropPostgresRlsPolicyCall(schemaForTable, issue.actual.tableName, issue.actual.name),
         );
       }
     }
@@ -371,7 +356,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     // 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.
-    // RLS policy drift is handled separately via diffPostgresRlsPolicies → planRlsDiff.
+    // Schema drift is handled separately via diffPostgresSchema → planPostgresSchemaDiff.
     const namespaceIssues = verifyPostgresNamespacePresence({
       contract: options.contract,
       schema: options.schema,

package/src/core/migrations/verify-postgres-namespaces.ts

@@ -4,7 +4,7 @@ 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';
+import { isPostgresSchemaIR } from '../schema-ir/postgres-schema-ir';
 
 /**
  * Resolves the live-database schema name for a given namespace

package/src/core/postgres-schema.ts

@@ -1,3 +1,4 @@
+import type { Contract } from '@prisma-next/contract/types';
 import {
   freezeNode,
   hydrateNamespaceEntities,
@@ -12,16 +13,19 @@ import {
   type StorageTable,
   type StorageValueSet,
 } from '@prisma-next/sql-contract/types';
+
 import { type CfExpr, cfExpr } from '@prisma-next/sql-relational-core/contract-free';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PostgresTableSource } from './ast/table-source';
 import { PG_TEXT_CODEC_ID } from './codec-ids';
 import { policyEntityKind, roleEntityKind } from './entity-kinds';
-import type { PostgresRlsPolicy } from './postgres-rls-policy';
-import type { PostgresRole } from './postgres-role';
+import type { PostgresRlsPolicy } from './schema-ir/postgres-rls-policy';
+import type { PostgresRole } from './schema-ir/postgres-role';
 import { escapeLiteral } from './sql-utils';
 
+export type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgres' };
+
 export type PostgresNamespaceEntries = SqlNamespaceEntries & {
   readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;
   readonly role?: Readonly<Record<string, PostgresRole>>;

package/src/core/{postgres-rls-policy.ts → schema-ir/postgres-rls-policy.ts}

@@ -1,5 +1,4 @@
 import type { DiffableNode } from '@prisma-next/framework-components/control';
-import type { EntityCoordinate } from '@prisma-next/framework-components/ir';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from '@prisma-next/sql-contract/types';
 
@@ -60,13 +59,12 @@ export class PostgresRlsPolicy extends SqlNode implements DiffableNode {
     freezeNode(this);
   }
 
-  identity(): EntityCoordinate {
-    return {
-      plane: 'storage',
-      namespaceId: this.namespaceId,
-      entityKind: 'policy',
-      entityName: this.name,
-    };
+  get id(): string {
+    return this.name;
+  }
+
+  children(): readonly DiffableNode[] {
+    return [];
   }
 
   /**
@@ -80,7 +78,7 @@ export class PostgresRlsPolicy extends SqlNode implements DiffableNode {
   isEqualTo(other: DiffableNode): boolean {
     if (!isPostgresRlsPolicy(other)) {
       throw new Error(
-        `PostgresRlsPolicy.isEqualTo: expected a PostgresRlsPolicy, got ${other.identity().entityKind}`,
+        `PostgresRlsPolicy.isEqualTo: expected a PostgresRlsPolicy, got ${other.constructor?.name ?? typeof other}`,
       );
     }
     return this.name === other.name;
@@ -97,7 +95,7 @@ export function assertPostgresRlsPolicy(
   if (!isPostgresRlsPolicy(node)) {
     const kind = node !== undefined && 'kind' in node ? String(node.kind) : typeof node;
     throw new Error(
-      `planRlsDiff: expected a PostgresRlsPolicy on the policy-diff path but got ${kind}`,
+      `planPostgresSchemaDiff: expected a PostgresRlsPolicy on the policy-diff path but got ${kind}`,
     );
   }
 }

package/src/core/{postgres-role.ts → schema-ir/postgres-role.ts}

@@ -1,5 +1,4 @@
 import type { DiffableNode } from '@prisma-next/framework-components/control';
-import type { EntityCoordinate } from '@prisma-next/framework-components/ir';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from '@prisma-next/sql-contract/types';
 
@@ -33,19 +32,19 @@ export class PostgresRole extends SqlNode implements DiffableNode {
     freezeNode(this);
   }
 
-  identity(): EntityCoordinate {
-    return {
-      plane: 'storage',
-      namespaceId: this.namespaceId,
-      entityKind: 'role',
-      entityName: this.name,
-    };
+  /** Roles are cluster-unique; the name alone is sufficient as the id. */
+  get id(): string {
+    return this.name;
+  }
+
+  children(): readonly DiffableNode[] {
+    return [];
   }
 
   isEqualTo(other: DiffableNode): boolean {
     if (!(other instanceof PostgresRole)) {
       throw new Error(
-        `PostgresRole.isEqualTo: expected a PostgresRole, got ${other.identity().entityKind}`,
+        `PostgresRole.isEqualTo: expected a PostgresRole, got ${other.constructor?.name ?? typeof other}`,
       );
     }
     return this.name === other.name;

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

@@ -1,7 +1,7 @@
 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 { isPostgresSchema } from '../postgres-schema';
 import { isPostgresSchemaIR } from './postgres-schema-ir';
 
 export function resolveDdlSchemaForNamespaceStorage(

package/src/core/{postgres-schema-ir.ts → schema-ir/postgres-schema-ir.ts}

@@ -1,20 +1,24 @@
+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,
-  SqlTableIR,
   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, SqlTableIR | SqlTableIRInput>;
+  readonly tables: Record<
+    string,
+    PostgresTableIR | (SqlTableIRInput & { rlsPolicies?: readonly PostgresRlsPolicy[] })
+  >;
   readonly pgSchemaName: string;
   readonly pgVersion: string;
-  readonly rlsPolicies: readonly PostgresRlsPolicy[];
   readonly roles: readonly PostgresRole[];
   readonly existingSchemas: readonly string[];
   readonly nativeEnumTypeNames: readonly string[];
@@ -31,22 +35,18 @@ export interface PostgresSchemaIRInput {
  * `SqlSchemaIR` structure and freezes itself at the end of its own
  * constructor.
  *
- * RLS-specific fields (`rlsPolicies`, `roles`) are typed top-level fields on
- * this class — no `Reflect.get`, no untyped annotation bag access. The
- * `annotations.pg` bag is populated with only the subset the family layer
- * reads (`nativeEnumTypeNames`, `existingSchemas`, `schema`) so family-layer
- * PSL inference and namespace verification continue to work without knowing
- * about RLS.
+ * `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 {
+export class PostgresSchemaIR extends SqlSchemaIRNode implements DiffableNode {
   readonly nodeTarget: SqlSchemaTarget = 'postgres';
-  readonly tables: Readonly<Record<string, SqlTableIR>>;
+  readonly tables: Readonly<Record<string, PostgresTableIR>>;
   declare readonly annotations?: SqlAnnotations;
   readonly pgSchemaName: string;
   readonly pgVersion: string;
-  readonly rlsPolicies: readonly PostgresRlsPolicy[];
   readonly roles: readonly PostgresRole[];
   readonly existingSchemas: readonly string[];
   readonly nativeEnumTypeNames: readonly string[];
@@ -57,20 +57,18 @@ export class PostgresSchemaIR extends SqlSchemaIRNode {
       Object.fromEntries(
         Object.entries(input.tables).map(([key, t]) => [
           key,
-          t instanceof SqlTableIR ? t : new SqlTableIR(t),
+          t instanceof PostgresTableIR ? t : new PostgresTableIR(t),
         ]),
       ),
     );
     this.pgSchemaName = input.pgSchemaName;
     this.pgVersion = input.pgVersion;
-    this.rlsPolicies = Object.freeze([...input.rlsPolicies]);
     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). rlsPolicies and roles are NOT placed here
-    // — they are consumed directly via typed fields on this class.
+    // namespace presence checks).
     this.annotations = {
       pg: {
         schema: input.pgSchemaName,
@@ -84,6 +82,22 @@ export class PostgresSchemaIR extends SqlSchemaIRNode {
     };
     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);
+  }
 }
 
 /**
@@ -99,3 +113,26 @@ export class PostgresSchemaIR extends SqlSchemaIRNode {
 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),
+  );
+}

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

@@ -0,0 +1,96 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import {
+  PrimaryKey,
+  type SqlAnnotations,
+  SqlCheckConstraintIR,
+  SqlColumnIR,
+  SqlForeignKeyIR,
+  SqlIndexIR,
+  SqlSchemaIRNode,
+  type SqlTableIRInput,
+  SqlUniqueIR,
+} from '@prisma-next/sql-schema-ir/types';
+import type { PostgresRlsPolicy } from './postgres-rls-policy';
+
+export interface PostgresTableIRInput extends SqlTableIRInput {
+  readonly rlsPolicies?: readonly PostgresRlsPolicy[];
+}
+
+/**
+ * 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.
+ */
+export class PostgresTableIR extends SqlSchemaIRNode implements DiffableNode {
+  readonly name: string;
+  readonly columns: Readonly<Record<string, SqlColumnIR>>;
+  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;
+  readonly uniques: ReadonlyArray<SqlUniqueIR>;
+  readonly indexes: ReadonlyArray<SqlIndexIR>;
+  declare readonly primaryKey?: PrimaryKey;
+  declare readonly annotations?: SqlAnnotations;
+  declare readonly checks?: ReadonlyArray<SqlCheckConstraintIR>;
+  readonly rlsPolicies: readonly PostgresRlsPolicy[];
+
+  constructor(input: PostgresTableIRInput) {
+    super();
+    this.name = input.name;
+    this.columns = Object.freeze(
+      Object.fromEntries(
+        Object.entries(input.columns).map(([key, col]) => [
+          key,
+          col instanceof SqlColumnIR ? col : new SqlColumnIR(col),
+        ]),
+      ),
+    );
+    this.foreignKeys = Object.freeze(
+      input.foreignKeys.map((fk) => (fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk))),
+    );
+    this.uniques = Object.freeze(
+      input.uniques.map((u) => (u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u))),
+    );
+    this.indexes = Object.freeze(
+      input.indexes.map((i) => (i instanceof SqlIndexIR ? i : new SqlIndexIR(i))),
+    );
+    if (input.primaryKey !== undefined) {
+      this.primaryKey =
+        input.primaryKey instanceof PrimaryKey
+          ? input.primaryKey
+          : new PrimaryKey(input.primaryKey);
+    }
+    if (input.annotations !== undefined) this.annotations = input.annotations;
+    if (input.checks !== undefined && 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(): string {
+    return this.name;
+  }
+
+  isEqualTo(_other: DiffableNode): boolean {
+    return true;
+  }
+
+  children(): readonly DiffableNode[] {
+    return this.rlsPolicies;
+  }
+}
+
+export function isPostgresTableIR(node: DiffableNode): node is PostgresTableIR {
+  return node instanceof PostgresTableIR;
+}

package/src/exports/control.ts

@@ -1,20 +1,23 @@
-import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
+import type { ColumnDefault } from '@prisma-next/contract/types';
 import type { SqlControlTargetDescriptor } from '@prisma-next/family-sql/control';
-import { contractToSchemaIR, extractCodecControlHooks } from '@prisma-next/family-sql/control';
+import { extractCodecControlHooks } from '@prisma-next/family-sql/control';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   ControlTargetInstance,
   MigrationRunner,
 } from '@prisma-next/framework-components/control';
-import type { SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
+import type { StorageColumn } from '@prisma-next/sql-contract/types';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
+import { contractToPostgresSchemaIR } from '../core/migrations/contract-to-postgres-schema-ir';
 import { createPostgresMigrationPlanner } from '../core/migrations/planner';
 import { renderDefaultLiteral } from '../core/migrations/planner-ddl-builders';
 import type { PostgresPlanTargetDetails } from '../core/migrations/planner-target-details';
 import { createPostgresMigrationRunner } from '../core/migrations/runner';
 import { PostgresContractSerializer } from '../core/postgres-contract-serializer';
+import type { PostgresContract } from '../core/postgres-schema';
 import { PostgresSchemaVerifier } from '../core/postgres-schema-verifier';
 
 function buildNativeTypeExpander(
@@ -58,15 +61,11 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
       },
       contractToSchema(contract, frameworkComponents) {
         const expander = buildNativeTypeExpander(frameworkComponents);
-        // Blind cast: the framework SPI signature
-        // (`control-migration-types.ts § contractToSchema`) types
-        // `contract` as the generic `Contract | null`. Inside the
-        // postgres target descriptor we know any contract reaching
-        // this method is SQL-family — the family contract resolver
-        // would have refused to construct a postgres target binding
-        // otherwise — so we narrow the generic to
-        // `Contract<SqlStorage>` for the lowering call.
-        return contractToSchemaIR(contract as unknown as Contract<SqlStorage> | null, {
+        const postgresContract = blindCast<
+          PostgresContract | null,
+          'the family resolver only binds this hook for a Postgres-target contract'
+        >(contract);
+        return contractToPostgresSchemaIR(postgresContract, {
           annotationNamespace: 'pg',
           ...ifDefined('expandNativeType', expander),
           renderDefault: postgresRenderDefault,

package/src/exports/planner.ts

@@ -1,2 +1,6 @@
+export { contractToPostgresSchemaIR } from '../core/migrations/contract-to-postgres-schema-ir';
+export {
+  diffPostgresSchema,
+  filterIssuesByOwnership,
+} from '../core/migrations/diff-postgres-schema';
 export { createPostgresMigrationPlanner } from '../core/migrations/planner';
-export { diffPostgresRlsPolicies } from '../core/migrations/verify-postgres-rls-policies';

package/src/exports/schema-ir-annotations.ts

@@ -1 +1 @@
-export { resolveDdlSchemaForNamespaceStorage } from '../core/postgres-schema-ir-annotations';
+export { resolveDdlSchemaForNamespaceStorage } from '../core/schema-ir/postgres-schema-ir-annotations';

package/src/exports/types.ts

@@ -1,18 +1,26 @@
-export {
-  PostgresRlsPolicy,
-  type PostgresRlsPolicyInput,
-  type RlsPolicyOperation,
-} from '../core/postgres-rls-policy';
-export { PostgresRole, type PostgresRoleInput } from '../core/postgres-role';
 export {
   isPostgresSchema,
+  type PostgresContract,
   PostgresSchema,
   PostgresUnboundSchema,
   postgresCreateNamespace,
 } from '../core/postgres-schema';
 export {
+  PostgresRlsPolicy,
+  type PostgresRlsPolicyInput,
+  type RlsPolicyOperation,
+} from '../core/schema-ir/postgres-rls-policy';
+export { PostgresRole, type PostgresRoleInput } from '../core/schema-ir/postgres-role';
+export {
+  assertPostgresSchemaIR,
+  ensurePostgresSchemaIR,
   isPostgresSchemaIR,
   PostgresSchemaIR,
   type PostgresSchemaIRInput,
-} from '../core/postgres-schema-ir';
+} from '../core/schema-ir/postgres-schema-ir';
+export {
+  isPostgresTableIR,
+  PostgresTableIR,
+  type PostgresTableIRInput,
+} from '../core/schema-ir/postgres-table-ir';
 export type { PostgresColumnDefault } from '../core/types';

package/dist/descriptor-meta-runtime-DiVla56r.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-runtime-DiVla56r.mjs","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta-runtime.ts"],"sourcesContent":["import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';\nimport type {\n  AuthoringEntityContext,\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringPslBlockDescriptorNamespace,\n  AuthoringTypeNamespace,\n  PslExtensionBlock,\n} from '@prisma-next/framework-components/authoring';\nimport { PostgresRlsPolicy } from './postgres-rls-policy';\nimport { PostgresRole, type PostgresRoleInput } from './postgres-role';\nimport { PostgresRlsPolicySchema, PostgresRoleSchema } from './postgres-validators';\nimport { computeContentHash, normalizePredicate } from './rls/canonicalize';\n\nexport const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;\n\nexport interface RlsPolicyExtensionBlock extends PslExtensionBlock {\n  readonly namespaceId: string;\n}\n\nfunction readRefParam(block: PslExtensionBlock, key: string): string | undefined {\n  const param = block.parameters[key];\n  return param?.kind === 'ref' ? param.identifier : undefined;\n}\n\nfunction readValueParam(block: PslExtensionBlock, key: string): string | undefined {\n  const param = block.parameters[key];\n  return param?.kind === 'value' ? param.raw : undefined;\n}\n\nfunction readListRefParams(block: PslExtensionBlock, key: string): string[] {\n  const param = block.parameters[key];\n  if (param?.kind !== 'list') return [];\n  return param.items.flatMap((item) => (item.kind === 'ref' ? [item.identifier] : []));\n}\n\nfunction unwrapQuotedString(raw: string): string {\n  if (raw.startsWith('\"') && raw.endsWith('\"') && raw.length >= 2) {\n    return raw.slice(1, -1).replace(/\\\\\"/g, '\"');\n  }\n  return raw;\n}\n\nfunction lowerRlsPolicyFromBlock(\n  block: RlsPolicyExtensionBlock,\n  _ctx: AuthoringEntityContext,\n): PostgresRlsPolicy {\n  const prefix = block.name;\n  const targetModelName = readRefParam(block, 'target') ?? '';\n  const tableName = targetModelName.charAt(0).toLowerCase() + targetModelName.slice(1);\n  const roles = [...readListRefParams(block, 'roles')].sort();\n  const using = unwrapQuotedString(readValueParam(block, 'using') ?? '');\n\n  const wireHash = computeContentHash({\n    using: normalizePredicate(using),\n    roles,\n    operation: 'select',\n    permissive: true,\n  });\n  const wireName = `${prefix}_${wireHash}`;\n\n  return new PostgresRlsPolicy({\n    name: wireName,\n    prefix,\n    tableName,\n    namespaceId: block.namespaceId,\n    operation: 'select',\n    roles,\n    using,\n    permissive: true,\n  });\n}\n\nexport const postgresAuthoringEntityTypes = {\n  role: {\n    kind: 'entity',\n    discriminator: 'role',\n    validatorSchema: PostgresRoleSchema,\n    output: {\n      factory: (input: PostgresRoleInput): PostgresRole => new PostgresRole(input),\n    },\n  },\n  policy: {\n    kind: 'entity',\n    discriminator: 'policy',\n    validatorSchema: PostgresRlsPolicySchema,\n    output: {\n      factory: lowerRlsPolicyFromBlock,\n    },\n  },\n} as const satisfies AuthoringEntityTypeNamespace;\n\n/**\n * Field presets contributed by the Postgres target pack.\n *\n * These mirror the PSL scalar-to-codec mapping used by the Postgres adapter\n * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field\n * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar\n * surface (e.g. `Int`) lowers to byte-identical contracts.\n *\n * The `uuidNative` / `id.uuidv4Native` / `id.uuidv7Native` presets use the\n * native Postgres `uuid` type (codecId `pg/uuid@1`). For cross-target\n * portability use `uuidString` / `id.uuidv4String` / `id.uuidv7String` from\n * the family pack instead.\n */\n/**\n * PSL block descriptor for `policy_select`.\n *\n * The parser learns the block shape from this descriptor; lowering from\n * `PslExtensionBlock` to `PostgresRlsPolicy` is wired in the PSL\n * interpreter (a later dispatch). The `discriminator` matches\n * `PostgresRlsPolicy.kind` so the parsed block node carries the same\n * discriminant as the IR class it will lower to.\n *\n * The `roles` list uses `scope:'cross-space'` because same-namespace\n * role ref resolution requires PSL namespace entries keyed by `refKind`\n * (i.e. `'role'`), which in turn requires the role block discriminator to\n * equal `'role'`. Aligning discriminator with refKind is tracked for\n * slice 4 (cross-space roles). Until then cross-space passes validation\n * unconditionally and the authored role names flow through unchanged.\n */\nexport const postgresAuthoringPslBlockDescriptors = {\n  policy_select: {\n    kind: 'pslBlock',\n    keyword: 'policy_select',\n    discriminator: 'policy',\n    name: { required: true },\n    parameters: {\n      target: { kind: 'ref', refKind: 'model', scope: 'same-namespace', required: true },\n      roles: {\n        kind: 'list',\n        of: { kind: 'ref', refKind: 'role', scope: 'cross-space' },\n      },\n      using: { kind: 'value', codecId: 'pg/text@1', required: true },\n    },\n  },\n} as const satisfies AuthoringPslBlockDescriptorNamespace;\n\nexport const postgresAuthoringFieldPresets = {\n  text: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/text@1',\n      nativeType: 'text',\n    },\n  },\n  int: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int4@1',\n      nativeType: 'int4',\n    },\n  },\n  bigint: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int8@1',\n      nativeType: 'int8',\n    },\n  },\n  float: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/float8@1',\n      nativeType: 'float8',\n    },\n  },\n  decimal: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/numeric@1',\n      nativeType: 'numeric',\n    },\n  },\n  boolean: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bool@1',\n      nativeType: 'bool',\n    },\n  },\n  json: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/jsonb@1',\n      nativeType: 'jsonb',\n    },\n  },\n  bytes: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bytea@1',\n      nativeType: 'bytea',\n    },\n  },\n  dateTime: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/timestamptz@1',\n      nativeType: 'timestamptz',\n    },\n  },\n  temporal: /* @__PURE__ */ temporalAuthoringPresets({\n    codecId: 'pg/timestamptz@1',\n    nativeType: 'timestamptz',\n  }),\n  uuidNative: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/uuid@1',\n      nativeType: 'uuid',\n    },\n  },\n  id: {\n    uuidv4Native: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: 'pg/uuid@1',\n        nativeType: 'uuid',\n        executionDefaults: {\n          onCreate: {\n            kind: 'generator',\n            id: 'uuidv4',\n          },\n        },\n        id: true,\n      },\n    },\n    uuidv7Native: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: 'pg/uuid@1',\n        nativeType: 'uuid',\n        executionDefaults: {\n          onCreate: {\n            kind: 'generator',\n            id: 'uuidv7',\n          },\n        },\n        id: true,\n      },\n    },\n  },\n} as const satisfies AuthoringFieldNamespace;\n","// Runtime-safe slice of the postgres target descriptor metadata.\n//\n// This file exists separately from ./descriptor-meta on purpose: the runtime\n// plane reads only `kind/familyId/targetId/id/version/capabilities` (plus the\n// `__codecTypes` phantom). The `authoring` slot lives on the pack/control\n// descriptor only, because authoring contributions are consumed at\n// contract-construction time by `assembleAuthoringContributions` (control\n// plane) and the PSL interpreter — never at runtime.\n//\n// Keeping the runtime closure free of the `./authoring` import is what lets\n// the bundler tree-shake `@prisma-next/family-sql/control` (and its\n// transitive `verify-sql-schema` chunk) out of the runtime entry. Do not\n// add an `authoring` field here — if you need to, the pack/control meta in\n// `./descriptor-meta` is the right place. See TML-2766 for context.\nimport type { CodecTypes } from '../exports/codec-types';\n\nconst postgresTargetDescriptorMetaRuntimeBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n} as const;\n\nexport const postgresTargetDescriptorMetaRuntime: typeof postgresTargetDescriptorMetaRuntimeBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaRuntimeBase;\n"],"mappings":"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"}