@prisma-next/target-postgres 0.14.0-dev.5 → 0.14.0-dev.50

package/src/core/migrations/control-policy.ts

@@ -1,10 +1,15 @@
 import type { Contract } from '@prisma-next/contract/types';
 import type { ControlPolicySubject } from '@prisma-next/family-sql/control';
-import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import type { SchemaDiffIssue } from '@prisma-next/framework-components/control';
 import { entityAt, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlStorage, StorageTable } from '@prisma-next/sql-contract/types';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { isPostgresSchema } from '../postgres-schema';
+import type { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';
+import type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';
+import { PostgresSchemaNodeKind } from '../schema-ir/schema-node-kinds';
+import { issueColumnName } from './issue-planner';
 import type { PostgresOpFactoryCall } from './op-factory-call';
 
 /**
@@ -21,6 +26,8 @@ import type { PostgresOpFactoryCall } from './op-factory-call';
 const OBJECT_CREATION_FACTORIES: ReadonlySet<string> = new Set<string>([
   'createTable',
   'createSchema',
+  'createRlsPolicy',
+  'enableRowLevelSecurity',
 ]);
 
 function createsNewTopLevelObject(call: PostgresOpFactoryCall): boolean {
@@ -54,7 +61,7 @@ function resolveNamespaceIdForTable(
   return UNBOUND_NAMESPACE_ID;
 }
 
-function resolveNamespaceIdForDdlSchema(
+export function resolveNamespaceIdForDdlSchema(
   contract: Contract<SqlStorage>,
   ddlSchemaName: string,
 ): string {
@@ -141,64 +148,80 @@ export function resolvePostgresCallControlPolicySubject(
 }
 
 /**
- * Issue kinds that describe the absence of a whole, top-level Postgres
- * object — the same kinds `createsNewTopLevelObject` recognises for calls.
- * Used by {@link resolvePostgresIssueCreationFactoryName} to decide whether
- * a `tolerated` subject permits the issue to flow into the planner
+ * Node kinds that describe the absence of a whole, top-level Postgres
+ * object — the same objects `createsNewTopLevelObject` recognises for calls.
+ * Used by {@link resolvePostgresNodeIssueCreationFactoryName} to decide
+ * whether a `tolerated` subject permits the issue to flow into the planner
  * (create-if-absent) and to seed the suppressed-subject warning's
- * `factoryName` when the planner is skipped.
+ * `factoryName` when the planner is skipped. RLS policy creation is not
+ * listed here — policy issues never reach this issue-based partition (they
+ * are routed to `planPostgresSchemaDiff` and gated via the call-based
+ * {@link resolvePostgresCallControlPolicySubject} instead).
  */
-const POSTGRES_ISSUE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.freeze({
-  missing_schema: 'createSchema',
-  missing_table: 'createTable',
+const POSTGRES_NODE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.freeze({
+  [PostgresSchemaNodeKind.namespace]: 'createSchema',
+  [PostgresSchemaNodeKind.table]: 'createTable',
 });
 
-export function resolvePostgresIssueCreationFactoryName(issue: SchemaIssue): string | undefined {
-  return POSTGRES_ISSUE_CREATION_FACTORY[issue.kind];
+export function resolvePostgresNodeIssueCreationFactoryName(
+  issue: SchemaDiffIssue<SqlSchemaDiffNode>,
+): string | undefined {
+  if (issue.reason !== 'not-found') return undefined;
+  const node = issue.expected ?? issue.actual;
+  if (node === undefined) return undefined;
+  return POSTGRES_NODE_CREATION_FACTORY[node.nodeKind];
 }
 
 /**
- * Resolve the control-policy subject coordinate for a single
- * {@link SchemaIssue}. Mirrors the resolution `resolvePostgresCallControlPolicySubject`
- * performs for a generated DDL call, but works *off the issue* — so the
- * planner can partition issues by effective policy before the diff engine
- * runs. `createsNewObject` is derived from the issue's kind: schema/table/
- * type-missing issues describe a brand-new top-level object; everything else
- * touches an existing object.
+ * Resolve the control-policy subject coordinate for a single node-typed
+ * {@link SchemaDiffIssue}. Mirrors the resolution
+ * `resolvePostgresCallControlPolicySubject` performs for a generated DDL
+ * call, but works *off the issue* — so the planner can partition issues by
+ * effective policy before the diff engine runs. `createsNewObject` is
+ * derived from the node kind + reason: a `not-found` schema/table describes
+ * a brand-new top-level object; everything else touches an existing object.
  *
- * An `extra_table` issue carries no contract namespace coordinate (the table
- * isn't in any contract namespace), so the subject's `namespaceId` falls
- * back to {@link UNBOUND_NAMESPACE_ID}; the call-side resolver does the same
- * for the `DropTableCall` it produces.
+ * A `not-expected` table carries no contract namespace coordinate (the live
+ * table isn't claimed by any contract namespace), so the subject's
+ * `namespaceId` falls back to {@link UNBOUND_NAMESPACE_ID} via
+ * `resolveNamespaceIdForTable`'s own fallback — the call-side resolver does
+ * the same for the `DropTableCall` it produces.
  */
-export function resolvePostgresIssueControlPolicySubject(
-  issue: SchemaIssue,
+export function resolvePostgresNodeIssueControlPolicySubject(
+  issue: SchemaDiffIssue<SqlSchemaDiffNode>,
   contract: Contract<SqlStorage>,
 ): ControlPolicySubject | undefined {
-  const createsNewObject = POSTGRES_ISSUE_CREATION_FACTORY[issue.kind] !== undefined;
-
-  if (issue.kind === 'missing_schema' && issue.namespaceId) {
-    return { namespaceId: issue.namespaceId, createsNewObject };
-  }
-
-  if ('table' in issue && issue.table) {
-    const namespaceId =
-      'namespaceId' in issue && issue.namespaceId
-        ? issue.namespaceId
-        : resolveNamespaceIdForTable(contract, issue.table, undefined);
-    const table = entityAt<StorageTable>(contract.storage, {
-      namespaceId,
-      entityKind: 'table',
-      entityName: issue.table,
-    });
+  const node = issue.expected ?? issue.actual;
+  if (node === undefined) return undefined;
+
+  if (node.nodeKind === PostgresSchemaNodeKind.namespace) {
+    const namespaceNode = blindCast<
+      PostgresNamespaceSchemaNode,
+      'a postgres-namespace diff node is always a PostgresNamespaceSchemaNode'
+    >(node);
     return {
-      namespaceId,
-      ...ifDefined('explicitNodeControlPolicy', table?.control),
-      table: issue.table,
-      ...ifDefined('column', 'column' in issue ? issue.column : undefined),
-      createsNewObject,
+      namespaceId: resolveNamespaceIdForDdlSchema(contract, namespaceNode.schemaName),
+      createsNewObject: issue.reason === 'not-found',
     };
   }
 
-  return undefined;
+  const tableName = issue.path[2];
+  if (tableName === undefined) return undefined;
+  const ddlSchemaName = issue.path[1];
+  const namespaceId = resolveNamespaceIdForTable(contract, tableName, ddlSchemaName);
+  const table = entityAt<StorageTable>(contract.storage, {
+    namespaceId,
+    entityKind: 'table',
+    entityName: tableName,
+  });
+  const createsNewObject =
+    node.nodeKind === PostgresSchemaNodeKind.table && issue.reason === 'not-found';
+
+  return {
+    namespaceId,
+    ...ifDefined('explicitNodeControlPolicy', table?.control),
+    table: tableName,
+    ...ifDefined('column', issueColumnName(issue)),
+    createsNewObject,
+  };
 }

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

@@ -0,0 +1,280 @@
+import type { Contract, ControlPolicy } from '@prisma-next/contract/types';
+import type { SqlSchemaDiffResult } from '@prisma-next/family-sql/control';
+import { buildNativeTypeExpander } from '@prisma-next/family-sql/control';
+import {
+  classifyDiffSubjectGranularity,
+  resolveSemanticSatisfaction,
+} from '@prisma-next/family-sql/diff';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type { SchemaDiffIssue } from '@prisma-next/framework-components/control';
+import { diffSchemas } 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 { ifDefined } from '@prisma-next/utils/defined';
+import type { PostgresContract } from '../postgres-schema';
+import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
+import { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';
+import { PostgresTableSchemaNode } from '../schema-ir/postgres-table-schema-node';
+import {
+  postgresDiffSubjectGranularity,
+  type SqlSchemaDiffNode,
+} from '../schema-ir/schema-node-kinds';
+import { contractToPostgresDatabaseSchemaNode } from './contract-to-postgres-database-schema-node';
+import { resolvePostgresNodeIssueControlPolicySubject } from './control-policy';
+
+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]);
+}
+
+/**
+ * Applies the family's semantic-satisfaction normalization across a Postgres
+ * tree pair: every actual table with an expected counterpart (paired by
+ * namespace id, then table id) gets its unique/index child lists adjusted;
+ * everything else passes through untouched.
+ */
+export function normalizePostgresActualForDiff(
+  expected: PostgresDatabaseSchemaNode,
+  actual: PostgresDatabaseSchemaNode,
+): PostgresDatabaseSchemaNode {
+  const namespaces: Record<string, PostgresNamespaceSchemaNode> = {};
+  for (const [nsId, actualNs] of Object.entries(actual.namespaces)) {
+    const expectedNs = expected.namespaces[nsId];
+    if (expectedNs === undefined) {
+      namespaces[nsId] = actualNs;
+      continue;
+    }
+    const tables: Record<string, PostgresTableSchemaNode> = {};
+    for (const [tableName, actualTable] of Object.entries(actualNs.tables)) {
+      const expectedTable = expectedNs.tables[tableName];
+      if (expectedTable === undefined) {
+        tables[tableName] = actualTable;
+        continue;
+      }
+      const adjusted = resolveSemanticSatisfaction({
+        expectedUniques: expectedTable.uniques,
+        expectedIndexes: expectedTable.indexes,
+        actualUniques: actualTable.uniques,
+        actualIndexes: actualTable.indexes,
+      });
+      tables[tableName] = new PostgresTableSchemaNode({
+        name: actualTable.name,
+        columns: actualTable.columns,
+        foreignKeys: actualTable.foreignKeys,
+        uniques: adjusted.actualUniques,
+        indexes: adjusted.actualIndexes,
+        ...ifDefined('primaryKey', actualTable.primaryKey),
+        ...ifDefined('annotations', actualTable.annotations),
+        ...ifDefined('checks', actualTable.checks),
+        policies: [...actualTable.policies],
+      });
+    }
+    namespaces[nsId] = new PostgresNamespaceSchemaNode({
+      schemaName: actualNs.schemaName,
+      tables,
+      nativeEnumTypeNames: actualNs.nativeEnumTypeNames,
+    });
+  }
+  return new PostgresDatabaseSchemaNode({
+    namespaces,
+    roles: [...actual.roles],
+    existingSchemas: [...actual.existingSchemas],
+    pgVersion: actual.pgVersion,
+  });
+}
+
+/**
+ * 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: PostgresDatabaseSchemaNode,
+): PostgresDatabaseSchemaNode {
+  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] !== undefined),
+    pgVersion: expected.pgVersion,
+  });
+}
+
+/**
+ * Resolves a verdict-diff issue's subject table'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 table.
+ */
+function resolveControlPolicy(
+  issue: SchemaDiffIssue,
+  contract: Contract<SqlStorage>,
+): ControlPolicy | undefined {
+  const nodeIssue = blindCast<
+    SchemaDiffIssue<SqlSchemaDiffNode>,
+    'every node in a Postgres schema diff tree is a SqlSchemaDiffNode'
+  >(issue);
+  return resolvePostgresNodeIssueControlPolicySubject(nodeIssue, 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), normalize the actual tree for
+ * semantic satisfaction, run the generic
+ * differ, and scope out `not-expected` findings under namespaces the
+ * contract does not own. Ownership is role-aware, 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 `nativeEnumTypeNames`).
+ */
+export function diffPostgresSchema(input: {
+  readonly contract: Contract<SqlStorage>;
+  readonly schema: SqlSchemaIRNode;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}): SqlSchemaDiffResult {
+  const postgresContract = blindCast<
+    PostgresContract,
+    'diffPostgresSchema is only called with a postgres contract'
+  >(input.contract);
+  PostgresDatabaseSchemaNode.assert(input.schema);
+  const actual = input.schema;
+  const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);
+  const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
+    annotationNamespace: 'pg',
+    ...ifDefined('expandNativeType', expandNativeType),
+  });
+  const expected = pruneTableLessNamespaces(fullExpected);
+  const normalizedActual = normalizePostgresActualForDiff(expected, actual);
+  const relationalOwned = ownedSchemaNames(expected);
+  const structuralOwned = ownedSchemaNames(fullExpected);
+  const issues = diffSchemas(expected, normalizedActual).filter((issue) => {
+    if (issue.reason !== 'not-expected') return true;
+    const namespaceSegment = issue.path[1];
+    if (namespaceSegment === undefined) return true;
+    const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
+    const owned = granularity === 'structural' ? structuralOwned : relationalOwned;
+    return owned.has(namespaceSegment);
+  });
+  const namespacePairs = Object.values(expected.namespaces).map((ns) => ({
+    actual: actual.namespaces[ns.schemaName],
+  }));
+  return {
+    issues,
+    resolveControlPolicy: (issue) => resolveControlPolicy(issue, postgresContract),
+    namespacePairs,
+  };
+}
+
+/**
+ * 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: PostgresDatabaseSchemaNode,
+  actual: PostgresDatabaseSchemaNode,
+): PostgresDatabaseSchemaNode {
+  const namespaces: Record<string, PostgresNamespaceSchemaNode> = { ...actual.namespaces };
+  let padded = false;
+  for (const schemaName of Object.keys(expected.namespaces)) {
+    if (namespaces[schemaName] === undefined) {
+      namespaces[schemaName] = new PostgresNamespaceSchemaNode({
+        schemaName,
+        tables: {},
+        nativeEnumTypeNames: [],
+      });
+      padded = true;
+    }
+  }
+  if (!padded) return actual;
+  return new PostgresDatabaseSchemaNode({
+    namespaces,
+    roles: [...actual.roles],
+    existingSchemas: [...actual.existingSchemas],
+    pgVersion: actual.pgVersion,
+  });
+}
+
+export 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 and normalized for semantic satisfaction against `expected`. */
+  readonly actual: PostgresDatabaseSchemaNode;
+  /** The one node diff over the two trees: relational + policy drift, role-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, actual normalized for semantic satisfaction,
+ * role-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.
+ */
+export function buildPostgresPlanDiff(input: {
+  readonly contract: Contract<SqlStorage>;
+  readonly actualSchema: SqlSchemaIRNode;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}): PostgresPlanDiff {
+  const postgresContract = blindCast<
+    PostgresContract,
+    'buildPostgresPlanDiff is only called with a postgres contract'
+  >(input.contract);
+  PostgresDatabaseSchemaNode.assert(input.actualSchema);
+  const actual = input.actualSchema;
+  const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);
+  const projectionOptions = {
+    annotationNamespace: 'pg',
+    ...ifDefined('expandNativeType', expandNativeType),
+  };
+  const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, projectionOptions);
+  const expected = pruneTableLessNamespaces(fullExpected);
+  const paddedActual = padActualNamespaces(expected, actual);
+  const normalizedActual = normalizePostgresActualForDiff(expected, paddedActual);
+  const relationalOwned = ownedSchemaNames(expected);
+  const structuralOwned = ownedSchemaNames(fullExpected);
+  const issues = blindCast<
+    readonly SchemaDiffIssue<SqlSchemaDiffNode>[],
+    'both trees are PostgresDatabaseSchemaNodes, so every diff-issue node is a SqlSchemaDiffNode'
+  >(diffSchemas(expected, normalizedActual)).filter((issue) => {
+    if (issue.reason !== 'not-expected') return true;
+    const namespaceSegment = issue.path[1];
+    if (namespaceSegment === undefined) return true;
+    const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
+    const owned = granularity === 'structural' ? structuralOwned : relationalOwned;
+    return owned.has(namespaceSegment);
+  });
+  return { expected, actual: normalizedActual, issues };
+}