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

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

@@ -2,9 +2,9 @@ import type { Contract } from '@prisma-next/contract/types';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 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 type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
 import { isPostgresSchema } from '../postgres-schema';
-import { isPostgresSchemaIR } from '../schema-ir/postgres-schema-ir';
+import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 
 /**
  * Resolves the live-database schema name for a given namespace
@@ -24,20 +24,23 @@ function resolveDdlSchemaName(storage: SqlStorage, namespaceId: string): string
 }
 
 /**
- * Reads the introspected list of schema names from a `PostgresSchemaIR`.
- * Defaults to the always-present `public` schema when the schema IR is not a
- * `PostgresSchemaIR` — a fresh Postgres database always carries `public`
- * (unless an operator dropped it manually), so any verifier path that runs
- * without an enriched introspection still suppresses the redundant
- * `CREATE SCHEMA "public"`.
+ * Reads the introspected list of schema names from the database-root schema
+ * node. `existingSchemas` is database-level, so it lives on the
+ * `PostgresDatabaseSchemaNode` root — not on the per-schema namespace nodes.
+ *
+ * Defaults to the always-present `public` schema when the node is not the
+ * database root — a fresh Postgres database always carries `public` (unless an
+ * operator dropped it manually), so any verifier path that runs without an
+ * enriched introspection still suppresses the redundant `CREATE SCHEMA
+ * "public"`.
  *
  * Production introspection (`PostgresControlAdapter.introspect`) is the
  * authoritative source: it queries `pg_namespace` and sets `existingSchemas`
- * on the returned `PostgresSchemaIR`. Tests that want to assert against a
- * richer initial state construct a `PostgresSchemaIR` explicitly.
+ * on the returned root. Tests that want to assert against a richer initial
+ * state construct a `PostgresDatabaseSchemaNode` explicitly.
  */
-function existingSchemasFromSchema(schema: SqlSchemaIR): readonly string[] {
-  if (isPostgresSchemaIR(schema)) {
+function existingSchemasFromSchema(schema: SqlSchemaIRNode): readonly string[] {
+  if (PostgresDatabaseSchemaNode.is(schema)) {
     return schema.existingSchemas;
   }
   return ['public'];
@@ -45,7 +48,11 @@ function existingSchemasFromSchema(schema: SqlSchemaIR): readonly string[] {
 
 /**
  * Emits a `missing_schema` issue for every contract-declared Postgres
- * namespace whose live container does not yet exist.
+ * namespace whose live container does not yet exist. The planner's
+ * `collectSchemaIssues` prepends these to the relational findings so a
+ * multi-schema plan emits `CREATE SCHEMA` before the tables that need it —
+ * a planner-only concern (verify already rejects via the `missing_table` a
+ * missing schema produces), so this is not part of the shared diff.
  *
  * A namespace's live container is the schema returned by its
  * polymorphic `ddlSchemaName(storage)` method — named schemas resolve
@@ -63,7 +70,7 @@ function existingSchemasFromSchema(schema: SqlSchemaIR): readonly string[] {
  */
 export function verifyPostgresNamespacePresence(input: {
   readonly contract: Contract<SqlStorage>;
-  readonly schema: SqlSchemaIR;
+  readonly schema: SqlSchemaIRNode;
 }): readonly SchemaIssue[] {
   const { contract, schema } = input;
   const existing = new Set(existingSchemasFromSchema(schema));
@@ -76,6 +83,7 @@ export function verifyPostgresNamespacePresence(input: {
     if (existing.has(ddlName)) continue;
     issues.push({
       kind: 'missing_schema',
+      reason: 'not-found',
       namespaceId,
       message: `Schema "${ddlName}" is missing from database`,
     });

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

@@ -1,4 +1,3 @@
-import type { DiffableNode } from '@prisma-next/framework-components/control';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from '@prisma-next/sql-contract/types';
 
@@ -25,7 +24,11 @@ export interface PostgresRlsPolicyInput {
 }
 
 /**
- * Postgres IR class for a row-level security policy (`CREATE POLICY … ON …`).
+ * Postgres contract-IR class for a row-level security policy (`CREATE POLICY … ON …`).
+ *
+ * This is an authored, serialized Contract-IR entity — it is registered as an entity
+ * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;
+ * the schema-diff tree uses `PostgresPolicySchemaNode` for that role.
  *
  * Target-only concept — no SQL-family abstract. Extends `SqlNode` directly.
  * Frozen at construction via `freezeNode(this)`. The `kind: 'policy'`
@@ -33,7 +36,7 @@ export interface PostgresRlsPolicyInput {
  * survives JSON serialization and enables dispatch. The literal matches the
  * entries key (one-string rule: node.kind === entries key === entity kind).
  */
-export class PostgresRlsPolicy extends SqlNode implements DiffableNode {
+export class PostgresRlsPolicy extends SqlNode {
   override readonly kind = 'policy' as const;
   readonly name: string;
   readonly prefix: string;
@@ -58,44 +61,4 @@ export class PostgresRlsPolicy extends SqlNode implements DiffableNode {
     this.permissive = input.permissive;
     freezeNode(this);
   }
-
-  get id(): string {
-    return this.name;
-  }
-
-  children(): readonly DiffableNode[] {
-    return [];
-  }
-
-  /**
-   * Equality by wire name only. The wire name is `<prefix>_<sha256(body)[0..8]>`,
-   * so name-equality IS body-equality — two policies with different bodies
-   * have different hashes and therefore different names. We deliberately
-   * skip comparing bodies directly because Postgres reprints predicate
-   * expressions (e.g. strips outer parentheses), so a byte-compare against
-   * the authored body would produce false mismatches on a clean re-verify.
-   */
-  isEqualTo(other: DiffableNode): boolean {
-    if (!isPostgresRlsPolicy(other)) {
-      throw new Error(
-        `PostgresRlsPolicy.isEqualTo: expected a PostgresRlsPolicy, got ${other.constructor?.name ?? typeof other}`,
-      );
-    }
-    return this.name === other.name;
-  }
-}
-
-export function isPostgresRlsPolicy(node: DiffableNode | undefined): node is PostgresRlsPolicy {
-  return node !== undefined && 'kind' in node && node.kind === 'policy';
-}
-
-export function assertPostgresRlsPolicy(
-  node: DiffableNode | undefined,
-): asserts node is PostgresRlsPolicy {
-  if (!isPostgresRlsPolicy(node)) {
-    const kind = node !== undefined && 'kind' in node ? String(node.kind) : typeof node;
-    throw new Error(
-      `planPostgresSchemaDiff: expected a PostgresRlsPolicy on the policy-diff path but got ${kind}`,
-    );
-  }
 }

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

@@ -1,4 +1,3 @@
-import type { DiffableNode } from '@prisma-next/framework-components/control';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from '@prisma-next/sql-contract/types';
 
@@ -12,7 +11,11 @@ export interface PostgresRoleInput {
 }
 
 /**
- * Postgres IR class for a database role (`CREATE ROLE …`).
+ * Postgres contract-IR class for a database role (`CREATE ROLE …`).
+ *
+ * This is an authored, serialized Contract-IR entity — it is registered as an entity
+ * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;
+ * the schema-diff tree uses `PostgresRoleSchemaNode` for that role.
  *
  * Roles are cluster-scoped, so their namespace coordinate is always
  * `UNBOUND_NAMESPACE_ID`. Target-only concept — no SQL-family abstract.
@@ -20,7 +23,7 @@ export interface PostgresRoleInput {
  * The `kind: 'role'` discriminant is enumerable so it survives JSON.
  * Matches the entries key (one-string rule).
  */
-export class PostgresRole extends SqlNode implements DiffableNode {
+export class PostgresRole extends SqlNode {
   override readonly kind = 'role' as const;
   readonly name: string;
   readonly namespaceId: string;
@@ -31,22 +34,4 @@ export class PostgresRole extends SqlNode implements DiffableNode {
     this.namespaceId = input.namespaceId;
     freezeNode(this);
   }
-
-  /** 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.constructor?.name ?? typeof other}`,
-      );
-    }
-    return this.name === other.name;
-  }
 }

package/src/core/postgres-schema.ts

@@ -20,8 +20,8 @@ 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 './schema-ir/postgres-rls-policy';
-import type { PostgresRole } from './schema-ir/postgres-role';
+import type { PostgresRlsPolicy } from './postgres-rls-policy';
+import type { PostgresRole } from './postgres-role';
 import { escapeLiteral } from './sql-utils';
 
 export type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgres' };