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

package/src/core/psl-infer/postgres-default-mapping.ts

@@ -0,0 +1,16 @@
+import type { DefaultMappingOptions } from '@prisma-next/family-sql/psl-infer';
+
+const POSTGRES_FUNCTION_ATTRIBUTES: Readonly<Record<string, string>> = {
+  'gen_random_uuid()': '@default(dbgenerated("gen_random_uuid()"))',
+};
+
+function formatDbGeneratedAttribute(expression: string): string {
+  return `@default(dbgenerated(${JSON.stringify(expression)}))`;
+}
+
+export function createPostgresDefaultMapping(): DefaultMappingOptions {
+  return {
+    functionAttributes: POSTGRES_FUNCTION_ATTRIBUTES,
+    fallbackFunctionAttribute: formatDbGeneratedAttribute,
+  };
+}

package/src/core/psl-infer/postgres-type-map.ts

@@ -0,0 +1,157 @@
+import type {
+  EnumInfo,
+  PslNativeTypeAttribute,
+  PslTypeMap,
+  PslTypeResolution,
+} from '@prisma-next/family-sql/psl-infer';
+
+const POSTGRES_TO_PSL: Record<string, string> = {
+  text: 'String',
+  bool: 'Boolean',
+  boolean: 'Boolean',
+  int4: 'Int',
+  integer: 'Int',
+  int8: 'BigInt',
+  bigint: 'BigInt',
+  float8: 'Float',
+  'double precision': 'Float',
+  numeric: 'Decimal',
+  decimal: 'Decimal',
+  timestamptz: 'DateTime',
+  'timestamp with time zone': 'DateTime',
+  jsonb: 'Json',
+  bytea: 'Bytes',
+};
+
+const PRESERVED_NATIVE_TYPES: Record<
+  string,
+  { readonly pslType: string; readonly attributeName: string }
+> = {
+  'character varying': { pslType: 'String', attributeName: 'db.VarChar' },
+  character: { pslType: 'String', attributeName: 'db.Char' },
+  char: { pslType: 'String', attributeName: 'db.Char' },
+  varchar: { pslType: 'String', attributeName: 'db.VarChar' },
+  uuid: { pslType: 'String', attributeName: 'db.Uuid' },
+  int2: { pslType: 'Int', attributeName: 'db.SmallInt' },
+  smallint: { pslType: 'Int', attributeName: 'db.SmallInt' },
+  float4: { pslType: 'Float', attributeName: 'db.Real' },
+  real: { pslType: 'Float', attributeName: 'db.Real' },
+  timestamp: { pslType: 'DateTime', attributeName: 'db.Timestamp' },
+  'timestamp without time zone': { pslType: 'DateTime', attributeName: 'db.Timestamp' },
+  date: { pslType: 'DateTime', attributeName: 'db.Date' },
+  time: { pslType: 'DateTime', attributeName: 'db.Time' },
+  'time without time zone': { pslType: 'DateTime', attributeName: 'db.Time' },
+  timetz: { pslType: 'DateTime', attributeName: 'db.Timetz' },
+  'time with time zone': { pslType: 'DateTime', attributeName: 'db.Timetz' },
+  json: { pslType: 'Json', attributeName: 'db.Json' },
+};
+
+const PARAMETERIZED_NATIVE_TYPES: Record<
+  string,
+  { readonly pslType: string; readonly attributeName: string }
+> = {
+  'character varying': { pslType: 'String', attributeName: 'db.VarChar' },
+  character: { pslType: 'String', attributeName: 'db.Char' },
+  char: { pslType: 'String', attributeName: 'db.Char' },
+  varchar: { pslType: 'String', attributeName: 'db.VarChar' },
+  numeric: { pslType: 'Decimal', attributeName: 'db.Numeric' },
+  timestamp: { pslType: 'DateTime', attributeName: 'db.Timestamp' },
+  timestamptz: { pslType: 'DateTime', attributeName: 'db.Timestamptz' },
+  time: { pslType: 'DateTime', attributeName: 'db.Time' },
+  timetz: { pslType: 'DateTime', attributeName: 'db.Timetz' },
+};
+
+const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
+
+function getOwnMappingValue(map: Record<string, string>, key: string): string | undefined {
+  return Object.hasOwn(map, key) ? map[key] : undefined;
+}
+
+function getOwnRecordValue<T>(map: Record<string, T>, key: string): T | undefined {
+  return Object.hasOwn(map, key) ? map[key] : undefined;
+}
+
+function createNativeTypeAttribute(name: string, args?: readonly string[]): PslNativeTypeAttribute {
+  return args && args.length > 0 ? { name, args } : { name };
+}
+
+function splitTypeParameterList(params: string): readonly string[] {
+  return params
+    .split(',')
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+}
+
+export function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslTypeMap {
+  return {
+    resolve(nativeType: string): PslTypeResolution {
+      if (enumTypeNames?.has(nativeType)) {
+        return { pslType: nativeType, nativeType };
+      }
+
+      const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
+      if (paramMatch) {
+        const [, baseType = nativeType, params = ''] = paramMatch;
+        const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);
+        if (template) {
+          return {
+            pslType: template.pslType,
+            nativeType,
+            typeParams: { baseType, params },
+            nativeTypeAttribute: createNativeTypeAttribute(
+              template.attributeName,
+              splitTypeParameterList(params),
+            ),
+          };
+        }
+      }
+
+      const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
+      if (preservedType) {
+        return {
+          pslType: preservedType.pslType,
+          nativeType,
+          nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName),
+        };
+      }
+
+      const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
+      if (pslType) {
+        return {
+          pslType,
+          nativeType,
+        };
+      }
+
+      return { unsupported: true, nativeType };
+    },
+  };
+}
+
+export function extractEnumInfo(annotations?: Record<string, unknown>): EnumInfo {
+  const pgAnnotations = annotations?.['pg'] as Record<string, unknown> | undefined;
+  const nativeEnumTypeNames = pgAnnotations?.['nativeEnumTypeNames'];
+
+  const typeNames = new Set<string>();
+  const definitions = new Map<string, readonly string[]>();
+
+  if (Array.isArray(nativeEnumTypeNames)) {
+    for (const name of nativeEnumTypeNames) {
+      if (typeof name === 'string') {
+        typeNames.add(name);
+      }
+    }
+  }
+
+  return { typeNames, definitions };
+}
+
+export function extractEnumTypeNames(annotations?: Record<string, unknown>): ReadonlySet<string> {
+  return extractEnumInfo(annotations).typeNames;
+}
+
+export function extractEnumDefinitions(
+  annotations?: Record<string, unknown>,
+): ReadonlyMap<string, readonly string[]> {
+  return extractEnumInfo(annotations).definitions;
+}

package/src/core/schema-ir/postgres-database-schema-node.ts

@@ -0,0 +1,63 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import type { PostgresNamespaceSchemaNode } from './postgres-namespace-schema-node';
+import type { PostgresRoleSchemaNode } from './postgres-role-schema-node';
+import { PostgresSchemaNodeKind } from './schema-node-kinds';
+
+export interface PostgresDatabaseSchemaNodeInput {
+  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;
+  readonly roles: readonly PostgresRoleSchemaNode[];
+  readonly existingSchemas: readonly string[];
+  readonly pgVersion: string;
+}
+
+/**
+ * The root of the Postgres schema-diff tree: one node per database.
+ *
+ * `id` is the fixed sentinel `'database'` — the root has no siblings and
+ * the value is never emitted into migration paths. `isEqualTo` is identity
+ * (roots always share the `'database'` id). `children()` returns namespace
+ * nodes only; roles are held on the root but not yielded (role diffing is a
+ * later slice).
+ */
+export class PostgresDatabaseSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  override readonly nodeKind = PostgresSchemaNodeKind.database;
+  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;
+  readonly roles: readonly PostgresRoleSchemaNode[];
+  readonly existingSchemas: readonly string[];
+  readonly pgVersion: string;
+
+  constructor(input: PostgresDatabaseSchemaNodeInput) {
+    super();
+    this.namespaces = Object.freeze({ ...input.namespaces });
+    this.roles = Object.freeze([...input.roles]);
+    this.existingSchemas = Object.freeze([...input.existingSchemas]);
+    this.pgVersion = input.pgVersion;
+    freezeNode(this);
+  }
+
+  get id(): string {
+    return 'database';
+  }
+
+  isEqualTo(other: DiffableNode): boolean {
+    return this.id === other.id;
+  }
+
+  children(): readonly DiffableNode[] {
+    return Object.values(this.namespaces);
+  }
+
+  static is(node: SqlSchemaIRNode): node is PostgresDatabaseSchemaNode {
+    return node.nodeKind === PostgresSchemaNodeKind.database;
+  }
+
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresDatabaseSchemaNode {
+    if (!PostgresDatabaseSchemaNode.is(node)) {
+      throw new Error(
+        `Expected a PostgresDatabaseSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,
+      );
+    }
+  }
+}

package/src/core/schema-ir/postgres-namespace-schema-node.ts

@@ -0,0 +1,61 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import type { PostgresTableSchemaNode } from './postgres-table-schema-node';
+import { PostgresSchemaNodeKind } from './schema-node-kinds';
+
+export interface PostgresNamespaceSchemaNodeInput {
+  readonly schemaName: string;
+  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;
+  readonly nativeEnumTypeNames: readonly string[];
+}
+
+/**
+ * One-per-Postgres-schema diff-tree node. Groups the tables belonging to a
+ * single namespace and satisfies the `SqlSchemaIR` shape so legacy per-schema
+ * consumers (verifySqlSchema, the relational planner, toSchemaView) can
+ * accept it unchanged in Unit 6.
+ *
+ * `id` is the schema name. `isEqualTo` is identity — two namespace nodes are
+ * equal iff their ids (schema names) match. `children()` returns the table
+ * nodes. Per-schema metadata is carried on the typed `nativeEnumTypeNames`
+ * field, not an annotations bag.
+ */
+export class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  override readonly nodeKind = PostgresSchemaNodeKind.namespace;
+  readonly schemaName: string;
+  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;
+  readonly nativeEnumTypeNames: readonly string[];
+
+  constructor(input: PostgresNamespaceSchemaNodeInput) {
+    super();
+    this.schemaName = input.schemaName;
+    this.tables = Object.freeze({ ...input.tables });
+    this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);
+    freezeNode(this);
+  }
+
+  get id(): string {
+    return this.schemaName;
+  }
+
+  isEqualTo(other: DiffableNode): boolean {
+    return this.id === other.id;
+  }
+
+  children(): readonly DiffableNode[] {
+    return Object.values(this.tables);
+  }
+
+  static is(node: SqlSchemaIRNode): node is PostgresNamespaceSchemaNode {
+    return node.nodeKind === PostgresSchemaNodeKind.namespace;
+  }
+
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresNamespaceSchemaNode {
+    if (!PostgresNamespaceSchemaNode.is(node)) {
+      throw new Error(
+        `Expected a PostgresNamespaceSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,
+      );
+    }
+  }
+}

package/src/core/schema-ir/postgres-policy-schema-node.ts

@@ -0,0 +1,93 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import type { RlsPolicyOperation } from '../postgres-rls-policy';
+import { PostgresSchemaNodeKind } from './schema-node-kinds';
+
+export interface PostgresPolicySchemaNodeInput {
+  /** Full wire name: `<prefix>_<8hex>`. */
+  readonly name: string;
+  /** User-supplied prefix (the part before the `_<8hex>` suffix). */
+  readonly prefix: string;
+  /** Name of the table this policy attaches to, by name within the same schema. */
+  readonly tableName: string;
+  /** Namespace coordinate (schema name). */
+  readonly namespaceId: string;
+  readonly operation: RlsPolicyOperation;
+  /** Sorted role names rendered in `TO <roles>`. */
+  readonly roles: readonly string[];
+  /** USING predicate SQL string, if present. */
+  readonly using?: string;
+  /** WITH CHECK predicate SQL string, if present. */
+  readonly withCheck?: string;
+  /** `true` = `AS PERMISSIVE`, `false` = `AS RESTRICTIVE`. */
+  readonly permissive: boolean;
+}
+
+/**
+ * Schema-diff leaf node for a Postgres row-level security policy.
+ *
+ * This is a derived, transient node walked by the differ — it is NEVER serialized.
+ * Built by project-from-contract and project-from-database from their respective
+ * `PostgresRlsPolicy` contract entities / introspected rows.
+ *
+ * `id` is the wire name (`<prefix>_<sha256(body)[0..8]>`), so name-equality is
+ * body-equality. `isEqualTo` compares names only — never byte-compare predicate
+ * bodies, because Postgres reprints them.
+ */
+export class PostgresPolicySchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  override readonly nodeKind = PostgresSchemaNodeKind.policy;
+  readonly name: string;
+  readonly prefix: string;
+  readonly tableName: string;
+  readonly namespaceId: string;
+  readonly operation: RlsPolicyOperation;
+  readonly roles: readonly string[];
+  declare readonly using?: string;
+  declare readonly withCheck?: string;
+  readonly permissive: boolean;
+
+  constructor(input: PostgresPolicySchemaNodeInput) {
+    super();
+    this.name = input.name;
+    this.prefix = input.prefix;
+    this.tableName = input.tableName;
+    this.namespaceId = input.namespaceId;
+    this.operation = input.operation;
+    this.roles = Object.freeze([...input.roles]);
+    if (input.using !== undefined) this.using = input.using;
+    if (input.withCheck !== undefined) this.withCheck = input.withCheck;
+    this.permissive = input.permissive;
+    freezeNode(this);
+  }
+
+  get id(): string {
+    return this.name;
+  }
+
+  children(): readonly DiffableNode[] {
+    return [];
+  }
+
+  isEqualTo(other: DiffableNode): boolean {
+    const node = blindCast<
+      SqlSchemaIRNode,
+      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-policy kinds'
+    >(other);
+    PostgresPolicySchemaNode.assert(node);
+    return this.id === node.id;
+  }
+
+  static is(node: SqlSchemaIRNode): node is PostgresPolicySchemaNode {
+    return node.nodeKind === PostgresSchemaNodeKind.policy;
+  }
+
+  static assert(node: SqlSchemaIRNode | undefined): asserts node is PostgresPolicySchemaNode {
+    if (node === undefined || !PostgresPolicySchemaNode.is(node)) {
+      throw new Error(
+        `Expected a PostgresPolicySchemaNode but got nodeKind=${node?.nodeKind ?? 'undefined'}`,
+      );
+    }
+  }
+}

package/src/core/schema-ir/postgres-role-schema-node.ts

@@ -0,0 +1,66 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { PostgresSchemaNodeKind } from './schema-node-kinds';
+
+export interface PostgresRoleSchemaNodeInput {
+  readonly name: string;
+  /**
+   * Namespace coordinate. Roles are cluster-scoped; callers pass
+   * `UNBOUND_NAMESPACE_ID` from `@prisma-next/framework-components/ir`.
+   */
+  readonly namespaceId: string;
+}
+
+/**
+ * Schema-diff leaf node for a Postgres database role.
+ *
+ * This is a derived, transient node walked by the differ — it is NEVER serialized.
+ * Built by project-from-contract and project-from-database from their respective
+ * `PostgresRole` contract entities / introspected rows.
+ *
+ * Roles are cluster-scoped, so `id` is the role name alone. `isEqualTo` compares
+ * names — name-equality is role-equality for cluster-scoped objects.
+ */
+export class PostgresRoleSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  override readonly nodeKind = PostgresSchemaNodeKind.role;
+  readonly name: string;
+  readonly namespaceId: string;
+
+  constructor(input: PostgresRoleSchemaNodeInput) {
+    super();
+    this.name = input.name;
+    this.namespaceId = input.namespaceId;
+    freezeNode(this);
+  }
+
+  get id(): string {
+    return this.name;
+  }
+
+  children(): readonly DiffableNode[] {
+    return [];
+  }
+
+  isEqualTo(other: DiffableNode): boolean {
+    const node = blindCast<
+      SqlSchemaIRNode,
+      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-role kinds'
+    >(other);
+    PostgresRoleSchemaNode.assert(node);
+    return this.id === node.id;
+  }
+
+  static is(node: SqlSchemaIRNode): node is PostgresRoleSchemaNode {
+    return node.nodeKind === PostgresSchemaNodeKind.role;
+  }
+
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresRoleSchemaNode {
+    if (!PostgresRoleSchemaNode.is(node)) {
+      throw new Error(
+        `Expected a PostgresRoleSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,
+      );
+    }
+  }
+}

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

@@ -11,25 +11,28 @@ import {
   type SqlTableIRInput,
   SqlUniqueIR,
 } from '@prisma-next/sql-schema-ir/types';
-import type { PostgresRlsPolicy } from './postgres-rls-policy';
+import type { PostgresPolicySchemaNode } from './postgres-policy-schema-node';
+import { PostgresSchemaNodeKind } from './schema-node-kinds';
 
-export interface PostgresTableIRInput extends SqlTableIRInput {
-  readonly rlsPolicies?: readonly PostgresRlsPolicy[];
+export interface PostgresTableSchemaNodeInput extends SqlTableIRInput {
+  readonly policies?: readonly PostgresPolicySchemaNode[];
 }
 
 /**
- * Postgres-specific table IR node. Carries all `SqlTableIR` fields plus
- * `rlsPolicies`, and implements `DiffableNode` so the table instance is
+ * Postgres-specific table schema-diff node. Carries all `SqlTableIR` fields
+ * plus `policies`, 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`.
+ * subclass field initialisation.
  *
- * `id` is the table name. `children()` returns the policies on this table.
- * `isEqualTo` is always true — table-level attributes are not diffed yet.
+ * `id` is the table name. `children()` returns the policy nodes on this table.
+ * `isEqualTo` is identity — two table nodes are equal iff their ids (names)
+ * match. Columns are not compared here; they become child nodes later.
  */
-export class PostgresTableIR extends SqlSchemaIRNode implements DiffableNode {
+export class PostgresTableSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  override readonly nodeKind = PostgresSchemaNodeKind.table;
   readonly name: string;
   readonly columns: Readonly<Record<string, SqlColumnIR>>;
   readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;
@@ -38,9 +41,9 @@ export class PostgresTableIR extends SqlSchemaIRNode implements DiffableNode {
   declare readonly primaryKey?: PrimaryKey;
   declare readonly annotations?: SqlAnnotations;
   declare readonly checks?: ReadonlyArray<SqlCheckConstraintIR>;
-  readonly rlsPolicies: readonly PostgresRlsPolicy[];
+  readonly policies: readonly PostgresPolicySchemaNode[];
 
-  constructor(input: PostgresTableIRInput) {
+  constructor(input: PostgresTableSchemaNodeInput) {
     super();
     this.name = input.name;
     this.columns = Object.freeze(
@@ -74,7 +77,7 @@ export class PostgresTableIR extends SqlSchemaIRNode implements DiffableNode {
         ),
       );
     }
-    this.rlsPolicies = Object.freeze([...(input.rlsPolicies ?? [])]);
+    this.policies = Object.freeze([...(input.policies ?? [])]);
     freezeNode(this);
   }
 
@@ -82,15 +85,23 @@ export class PostgresTableIR extends SqlSchemaIRNode implements DiffableNode {
     return this.name;
   }
 
-  isEqualTo(_other: DiffableNode): boolean {
-    return true;
+  isEqualTo(other: DiffableNode): boolean {
+    return this.id === other.id;
   }
 
   children(): readonly DiffableNode[] {
-    return this.rlsPolicies;
+    return this.policies;
+  }
+
+  static is(node: SqlSchemaIRNode): node is PostgresTableSchemaNode {
+    return node.nodeKind === PostgresSchemaNodeKind.table;
   }
-}
 
-export function isPostgresTableIR(node: DiffableNode): node is PostgresTableIR {
-  return node instanceof PostgresTableIR;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresTableSchemaNode {
+    if (!PostgresTableSchemaNode.is(node)) {
+      throw new Error(
+        `Expected a PostgresTableSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,
+      );
+    }
+  }
 }

package/src/core/schema-ir/schema-node-kinds.ts

@@ -0,0 +1,28 @@
+import type { DiffableNode } from '@prisma-next/framework-components/control';
+import type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+
+/**
+ * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements
+ * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`
+ * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)
+ * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node
+ * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).
+ */
+export type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;
+
+/**
+ * The `nodeKind` discriminant for each Postgres schema-diff node. Each node
+ * carries a unique value; the static `is`/`assert` guards compare against these
+ * identifiers rather than spelling the string inline or using `instanceof`. The
+ * field is an enumerable own property carried on every node instance.
+ */
+export const PostgresSchemaNodeKind = {
+  database: 'postgres-database',
+  namespace: 'postgres-namespace',
+  table: 'postgres-table',
+  policy: 'postgres-policy',
+  role: 'postgres-role',
+} as const;
+
+export type PostgresSchemaNodeKind =
+  (typeof PostgresSchemaNodeKind)[keyof typeof PostgresSchemaNodeKind];

package/src/exports/control.ts

@@ -11,7 +11,11 @@ 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 { contractToPostgresDatabaseSchemaNode } from '../core/migrations/contract-to-postgres-database-schema-node';
+import {
+  diffPostgresDatabaseSchema,
+  verifyPostgresDatabaseSchema,
+} from '../core/migrations/diff-database-schema';
 import { createPostgresMigrationPlanner } from '../core/migrations/planner';
 import { renderDefaultLiteral } from '../core/migrations/planner-ddl-builders';
 import type { PostgresPlanTargetDetails } from '../core/migrations/planner-target-details';
@@ -19,6 +23,8 @@ 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';
+import { inferPostgresPslContract } from '../core/psl-infer/infer-psl-contract';
+import { PostgresDatabaseSchemaNode } from '../core/schema-ir/postgres-database-schema-node';
 
 function buildNativeTypeExpander(
   frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', 'postgres'>>,
@@ -52,6 +58,28 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
     ...postgresTargetDescriptorMeta,
     contractSerializer: new PostgresContractSerializer(),
     schemaVerifier: new PostgresSchemaVerifier(),
+    inferPslContract(schema) {
+      PostgresDatabaseSchemaNode.assert(schema);
+      return inferPostgresPslContract(schema);
+    },
+    diffDatabaseSchema(input) {
+      return diffPostgresDatabaseSchema({
+        contract: input.contract,
+        actualSchema: input.schema,
+        strict: input.strict,
+        typeMetadataRegistry: input.typeMetadataRegistry,
+        frameworkComponents: input.frameworkComponents,
+      });
+    },
+    verifyDatabaseSchema(input) {
+      return verifyPostgresDatabaseSchema({
+        contract: input.contract,
+        actualSchema: input.schema,
+        strict: input.strict,
+        typeMetadataRegistry: input.typeMetadataRegistry,
+        frameworkComponents: input.frameworkComponents,
+      });
+    },
     migrations: {
       createPlanner(adapter: SqlControlAdapter<'postgres'>) {
         return createPostgresMigrationPlanner(adapter);
@@ -65,7 +93,7 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
           PostgresContract | null,
           'the family resolver only binds this hook for a Postgres-target contract'
         >(contract);
-        return contractToPostgresSchemaIR(postgresContract, {
+        return contractToPostgresDatabaseSchemaNode(postgresContract, {
           annotationNamespace: 'pg',
           ...ifDefined('expandNativeType', expander),
           renderDefault: postgresRenderDefault,

package/src/exports/planner.ts

@@ -1,6 +1,3 @@
-export { contractToPostgresSchemaIR } from '../core/migrations/contract-to-postgres-schema-ir';
-export {
-  diffPostgresSchema,
-  filterIssuesByOwnership,
-} from '../core/migrations/diff-postgres-schema';
+export { contractToPostgresDatabaseSchemaNode } from '../core/migrations/contract-to-postgres-database-schema-node';
+export { diffPostgresDatabaseSchema } from '../core/migrations/diff-database-schema';
 export { createPostgresMigrationPlanner } from '../core/migrations/planner';

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

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