@prisma-next/target-postgres 0.15.0 → 0.16.0-dev.10

package/src/core/codec-helpers.ts

@@ -47,7 +47,7 @@ export const pgNumericDecode = (wire: string | number): string => {
 };
 
 export const pgNumericRenderOutputType = (typeParams: {
-  readonly precision: number;
+  readonly precision?: number;
   readonly scale?: number;
 }): string | undefined => {
   const precision = typeParams.precision;
@@ -106,6 +106,58 @@ export const pgTimestamptzDecodeJson = (json: JsonValue): Date => {
   return date;
 };
 
+const ISO_8601_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+function formatDateOnly(year: number, month: number, day: number): string {
+  return `${String(year).padStart(4, '0')}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+}
+
+/**
+ * A Postgres `date` has no time-of-day or timezone component, so `pg/date@1`
+ * canonicalizes its JS-level value as a `Date` at UTC midnight
+ * (`Date.UTC(y, m, d)`), independent of the process's local timezone.
+ *
+ * `pgDateEncode` reads the calendar date via UTC getters (matching that
+ * canonical form) and formats it as `YYYY-MM-DD` directly, bypassing the pg
+ * driver's own `Date` serialization (`dateToString`), which reads *local*
+ * getters and would shift the calendar day near midnight in negative-UTC-offset
+ * environments.
+ */
+export const pgDateEncode = (value: Date): string =>
+  formatDateOnly(value.getUTCFullYear(), value.getUTCMonth() + 1, value.getUTCDate());
+
+/**
+ * Normalizes the pg driver's already-parsed `Date` for a `date` column into
+ * the canonical UTC-midnight form. The driver (via `postgres-date`) builds
+ * that `Date` at *local* midnight from the wire text; reading it back with the
+ * same (local) getters recovers the exact calendar date the driver parsed,
+ * and reconstructing via `Date.UTC` makes the result's instant independent of
+ * the process's timezone.
+ */
+export const pgDateDecode = (wire: Date): Date =>
+  new Date(Date.UTC(wire.getFullYear(), wire.getMonth(), wire.getDate()));
+
+export const pgDateEncodeJson = (value: Date): JsonValue => pgDateEncode(value);
+
+export const pgDateDecodeJson = (json: JsonValue): Date => {
+  if (typeof json !== 'string') {
+    throw new Error(`Expected date string for pg/date@1, got ${typeof json}`);
+  }
+  const match = ISO_8601_DATE.exec(json);
+  if (!match) {
+    throw new Error(`Invalid date string for pg/date@1: ${json}`);
+  }
+  const [, yearText, monthText, dayText] = match;
+  const year = Number(yearText);
+  const month = Number(monthText) - 1;
+  const day = Number(dayText);
+  const date = new Date(Date.UTC(year, month, day));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) {
+    throw new Error(`Invalid date string for pg/date@1: ${json}`);
+  }
+  return date;
+};
+
 export const pgIntervalDecode = (wire: string | Record<string, unknown>): string => {
   if (typeof wire === 'string') return wire;
   return JSON.stringify(wire);

package/src/core/codec-ids.ts

@@ -22,6 +22,7 @@ export const PG_NUMERIC_CODEC_ID = 'pg/numeric@1' as const;
 export const PG_BOOL_CODEC_ID = 'pg/bool@1' as const;
 export const PG_BIT_CODEC_ID = 'pg/bit@1' as const;
 export const PG_VARBIT_CODEC_ID = 'pg/varbit@1' as const;
+export const PG_DATE_CODEC_ID = 'pg/date@1' as const;
 export const PG_TIMESTAMP_CODEC_ID = 'pg/timestamp@1' as const;
 export const PG_TIMESTAMPTZ_CODEC_ID = 'pg/timestamptz@1' as const;
 export const PG_TIME_CODEC_ID = 'pg/time@1' as const;

package/src/core/codecs.ts

@@ -45,6 +45,10 @@ import { type as arktype } from 'arktype';
 import {
   pgByteaDecodeJson,
   pgByteaEncodeJson,
+  pgDateDecode,
+  pgDateDecodeJson,
+  pgDateEncode,
+  pgDateEncodeJson,
   pgIntervalDecode,
   pgJsonbDecode,
   pgJsonbEncode,
@@ -64,6 +68,7 @@ import {
   PG_BOOL_CODEC_ID,
   PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
+  PG_DATE_CODEC_ID,
   PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
@@ -92,14 +97,14 @@ import { PostgresNativeEnum } from './postgres-native-enum';
 
 type LengthParams = { readonly length?: number };
 type PrecisionParams = { readonly precision?: number };
-type NumericParams = { readonly precision: number; readonly scale?: number };
+type NumericParams = { readonly precision?: number; readonly scale?: number };
 
 const lengthParamsSchema = arktype({
   'length?': 'number.integer > 0',
 }) satisfies StandardSchemaV1<LengthParams>;
 
 const numericParamsSchema = arktype({
-  precision: 'number.integer > 0 & number.integer <= 1000',
+  'precision?': 'number.integer > 0 & number.integer <= 1000',
   'scale?': 'number.integer >= 0',
 }) satisfies StandardSchemaV1<NumericParams>;
 
@@ -115,6 +120,7 @@ const PG_INT8_META = { db: { sql: { postgres: { nativeType: 'bigint' } } } } as
 const PG_FLOAT4_META = { db: { sql: { postgres: { nativeType: 'real' } } } } as const;
 const PG_FLOAT8_META = { db: { sql: { postgres: { nativeType: 'double precision' } } } } as const;
 const PG_NUMERIC_META = { db: { sql: { postgres: { nativeType: 'numeric' } } } } as const;
+const PG_DATE_META = { db: { sql: { postgres: { nativeType: 'date' } } } } as const;
 const PG_TIMESTAMP_META = {
   db: { sql: { postgres: { nativeType: 'timestamp without time zone' } } },
 } as const;
@@ -648,12 +654,57 @@ export class PgNumericDescriptor extends CodecDescriptorImpl<NumericParams> {
 
 export const pgNumericDescriptor = new PgNumericDescriptor();
 
-export const pgNumericColumn = (params: NumericParams) =>
+export const pgNumericColumn = (params: NumericParams = {}) =>
   column(pgNumericDescriptor.factory(params), pgNumericDescriptor.codecId, params, 'numeric');
 
 pgNumericColumn satisfies ColumnHelperFor<PgNumericDescriptor>;
 pgNumericColumn satisfies ColumnHelperForStrict<PgNumericDescriptor>;
 
+/**
+ * A Postgres `date` has no time-of-day or timezone component. This codec
+ * canonicalizes its JS-level value as a `Date` at UTC midnight, so its
+ * round-trip is independent of the process's local timezone — see
+ * `pgDateEncode`/`pgDateDecode` in `codec-helpers.ts`.
+ */
+export class PgDateCodec extends CodecImpl<
+  typeof PG_DATE_CODEC_ID,
+  readonly ['equality', 'order'],
+  Date | string,
+  Date
+> {
+  async encode(value: Date, _ctx: CodecCallContext): Promise<string> {
+    return pgDateEncode(value);
+  }
+  async decode(wire: Date, _ctx: CodecCallContext): Promise<Date> {
+    return pgDateDecode(wire);
+  }
+  encodeJson(value: Date): JsonValue {
+    return pgDateEncodeJson(value);
+  }
+  decodeJson(json: JsonValue): Date {
+    return pgDateDecodeJson(json);
+  }
+}
+
+export class PgDateDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = PG_DATE_CODEC_ID;
+  override readonly traits = ['equality', 'order'] as const;
+  override readonly targetTypes = ['date'] as const;
+  override readonly meta = PG_DATE_META;
+  override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => PgDateCodec {
+    return () => new PgDateCodec(this);
+  }
+}
+
+export const pgDateDescriptor = new PgDateDescriptor();
+
+export const pgDateColumn = () =>
+  column(pgDateDescriptor.factory(), pgDateDescriptor.codecId, undefined, 'date');
+
+pgDateColumn satisfies ColumnHelperFor<PgDateDescriptor>;
+pgDateColumn satisfies ColumnHelperForStrict<PgDateDescriptor>;
+
 export class PgTimestampCodec extends CodecImpl<
   typeof PG_TIMESTAMP_CODEC_ID,
   readonly ['equality', 'order'],
@@ -1285,6 +1336,8 @@ export const codecDescriptors: readonly AnyCodecDescriptor[] = [
   pgFloat4Descriptor,
   pgFloat8Descriptor,
   pgNumericDescriptor,
+  // PSL `@db.Date` binding is deferred to remove-db-attributes' `Date` type; pin it via codecId, not a second targetTypes activation here.
+  pgDateDescriptor,
   pgTimestampDescriptor,
   pgTimestamptzDescriptor,
   pgTimeDescriptor,

package/src/core/default-normalizer.ts

@@ -249,3 +249,25 @@ export function parsePostgresDefault(
 
   return { kind: 'function', expression: trimmed };
 }
+
+/**
+ * Normalizes a contract-declared default through {@link parsePostgresDefault}
+ * — the same parser introspection uses — so a function-shaped default the
+ * parser recognizes as a literal (e.g. `dbgenerated("'{}'::jsonb")`)
+ * resolves to the same `resolvedDefault` shape a live introspected column
+ * would produce. Compensates once, at `SchemaIR` construction of the
+ * expected (contract-derived) side (`contractToSchemaIR`'s `resolveDefault`
+ * hook), instead of at every site that later compares the two sides. A
+ * literal default, or a function form the parser doesn't recognize, passes
+ * through unchanged; `nextval(...)` normalizes to `autoincrement()` on both
+ * sides, matching a `serial`/identity column's introspected counterpart.
+ */
+export function postgresResolveDefault(
+  def: ColumnDefault,
+  resolvedNativeType: string,
+): ColumnDefault {
+  if (def.kind !== 'function') {
+    return def;
+  }
+  return parsePostgresDefault(def.expression, resolvedNativeType) ?? def;
+}

package/src/core/descriptor-meta.ts

@@ -9,12 +9,14 @@ import {
 } from './authoring';
 import { postgresQualifyColumnType } from './codecs';
 import { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';
+import { postgresIndexTypes } from './index-types';
 import { DEFAULT_NAMESPACE_ID } from './namespace-ids';
 import { postgresCreateNamespace } from './postgres-schema';
 
 const postgresTargetDescriptorMetaBase = {
   ...postgresTargetDescriptorMetaRuntime,
   defaultNamespaceId: DEFAULT_NAMESPACE_ID,
+  indexTypes: postgresIndexTypes,
   authoring: {
     type: postgresAuthoringTypes,
     field: postgresAuthoringFieldPresets,

package/src/core/errors.ts

@@ -12,9 +12,10 @@ import { CliStructuredError } from '@prisma-next/errors/control';
  * The `operation` argument is required so every throw site names the operation
  * that actually failed; a new operation cannot inherit a misattributed message.
  *
- * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
- * (data-transform query plan against wrong contract) because the missing
- * input is the stack itself, not the per-operation contract.
+ * Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)
+ * and `MIGRATION.DATA_TRANSFORM_CONTRACT_MISMATCH` (data-transform query
+ * plan against wrong contract) because the missing input is the stack
+ * itself, not the per-operation contract.
  *
  * Lives in `@prisma-next/target-postgres/errors` rather than the shared
  * framework migration errors module because the failure is target-specific:
@@ -23,10 +24,9 @@ import { CliStructuredError } from '@prisma-next/errors/control';
  */
 export function errorPostgresMigrationStackMissing(operation: string): CliStructuredError {
   return new CliStructuredError(
-    '2007',
+    'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
     `PostgresMigration.${operation} requires a control adapter`,
     {
-      domain: 'MIG',
       why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,
       fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',
       meta: { operation },

package/src/core/index-types.ts

@@ -0,0 +1,15 @@
+import { defineIndexTypes } from '@prisma-next/sql-contract/index-types';
+import { type } from 'arktype';
+
+// Postgres's built-in index access methods (`CREATE INDEX ... USING <method>`).
+// Per-method option validation (e.g. `gin` operator classes) is out of scope;
+// every method accepts any options object until a later slice narrows it.
+export const postgresIndexTypes = defineIndexTypes()
+  .add('btree', { options: type('object') })
+  .add('hash', { options: type('object') })
+  .add('gin', { options: type('object') })
+  .add('gist', { options: type('object') })
+  .add('spgist', { options: type('object') })
+  .add('brin', { options: type('object') });
+
+export type IndexTypes = typeof postgresIndexTypes.IndexTypes;

package/src/core/migrations/contract-to-postgres-database-schema-node.ts

@@ -1,7 +1,14 @@
 import type { ContractToSchemaIROptions } from '@prisma-next/family-sql/control';
 import { contractNamespaceToSchemaIR } from '@prisma-next/family-sql/control';
+import type { SchemaNodeRef } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
-import { SqlForeignKeyIR } from '@prisma-next/sql-schema-ir/types';
+import {
+  PrimaryKey,
+  RelationalSchemaNodeKind,
+  SqlForeignKeyIR,
+  SqlIndexIR,
+  SqlUniqueIR,
+} from '@prisma-next/sql-schema-ir/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { PostgresRlsPolicy } from '../postgres-rls-policy';
 import type { PostgresContract } from '../postgres-schema';
@@ -12,8 +19,43 @@ import { PostgresNativeEnumSchemaNode } from '../schema-ir/postgres-native-enum-
 import { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';
 import { PostgresRoleSchemaNode } from '../schema-ir/postgres-role-schema-node';
 import { PostgresTableSchemaNode } from '../schema-ir/postgres-table-schema-node';
+import { PostgresSchemaNodeKind } from '../schema-ir/schema-node-kinds';
 import { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';
 
+/** The database root's fixed sentinel id (`PostgresDatabaseSchemaNode#id`). */
+function databaseStep(): { readonly nodeKind: string; readonly id: string } {
+  return { nodeKind: PostgresSchemaNodeKind.database, id: 'database' };
+}
+
+function tableDependsOn(namespaceId: string, tableName: string): SchemaNodeRef {
+  return [
+    databaseStep(),
+    { nodeKind: PostgresSchemaNodeKind.namespace, id: namespaceId },
+    { nodeKind: PostgresSchemaNodeKind.table, id: tableName },
+  ];
+}
+
+function roleDependsOn(role: string): SchemaNodeRef {
+  return [databaseStep(), { nodeKind: PostgresSchemaNodeKind.role, id: role }];
+}
+
+/**
+ * The chains from a table-child object (foreign key, index, unique, primary
+ * key) to each of the own columns it is built on, in the Postgres tree.
+ * Dropping a covered column auto-drops the object, so the object's drop must
+ * precede the column's; the graph derives that direction from these edges.
+ */
+function columnDependsOn(
+  namespaceId: string,
+  tableName: string,
+  columns: readonly string[],
+): readonly SchemaNodeRef[] {
+  return columns.map((column) => [
+    ...tableDependsOn(namespaceId, tableName),
+    { nodeKind: RelationalSchemaNodeKind.column, id: `column:${column}` },
+  ]);
+}
+
 function toPolicyNode(policy: PostgresRlsPolicy, namespaceId: string): PostgresPolicySchemaNode {
   return new PostgresPolicySchemaNode({
     name: policy.name,
@@ -25,6 +67,7 @@ function toPolicyNode(policy: PostgresRlsPolicy, namespaceId: string): PostgresP
     ...ifDefined('using', policy.using),
     ...ifDefined('withCheck', policy.withCheck),
     permissive: policy.permissive,
+    dependsOn: [tableDependsOn(namespaceId, policy.tableName), ...policy.roles.map(roleDependsOn)],
   });
 }
 
@@ -115,30 +158,67 @@ export function contractToPostgresDatabaseSchemaNode(
       // clauses, and resolves the real live DDL schema — introspected FKs
       // already carry the live schema, so this is what lets an expected FK
       // pair (by diff-node id) with its introspected counterpart.
-      const foreignKeys = sqlTable.foreignKeys.map(
-        (fk) =>
-          new SqlForeignKeyIR({
-            columns: fk.columns,
-            referencedTable: fk.referencedTable,
-            referencedColumns: fk.referencedColumns,
-            referencedSchema: fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,
-            ...ifDefined('name', fk.name),
-            ...ifDefined('onDelete', fk.onDelete),
-            ...ifDefined('onUpdate', fk.onUpdate),
-            ...ifDefined('annotations', fk.annotations),
-            resolvedReferencedNamespace: resolveDdlSchemaForNamespaceStorage(
-              contract.storage,
-              fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,
-            ),
+      const foreignKeys = sqlTable.foreignKeys.map((fk) => {
+        const resolvedReferencedNamespace = resolveDdlSchemaForNamespaceStorage(
+          contract.storage,
+          fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,
+        );
+        return new SqlForeignKeyIR({
+          columns: fk.columns,
+          referencedTable: fk.referencedTable,
+          referencedColumns: fk.referencedColumns,
+          referencedSchema: fk.referencedSchema ?? UNBOUND_NAMESPACE_ID,
+          ...ifDefined('name', fk.name),
+          ...ifDefined('onDelete', fk.onDelete),
+          ...ifDefined('onUpdate', fk.onUpdate),
+          ...ifDefined('annotations', fk.annotations),
+          resolvedReferencedNamespace,
+          dependsOn: [
+            tableDependsOn(resolvedReferencedNamespace, fk.referencedTable),
+            ...columnDependsOn(ddlSchema, tableName, fk.columns),
+          ],
+        });
+      });
+      // The family stamped these children's own-column `dependsOn` with the
+      // flat (single-schema) chain; the Postgres tree nests them under a
+      // namespace, so re-stamp with the multi-schema chain that matches this
+      // tree's paths. Every other field is carried through unchanged.
+      const uniques = sqlTable.uniques.map(
+        (u) =>
+          new SqlUniqueIR({
+            columns: u.columns,
+            ...ifDefined('name', u.name),
+            ...ifDefined('annotations', u.annotations),
+            dependsOn: columnDependsOn(ddlSchema, tableName, u.columns),
+          }),
+      );
+      const indexes = sqlTable.indexes.map(
+        (i) =>
+          new SqlIndexIR({
+            columns: i.columns,
+            unique: i.unique,
+            ...ifDefined('name', i.name),
+            ...ifDefined('type', i.type),
+            ...ifDefined('options', i.options),
+            ...ifDefined('annotations', i.annotations),
+            dependsOn: columnDependsOn(ddlSchema, tableName, i.columns),
           }),
       );
+      const primaryKey =
+        sqlTable.primaryKey !== undefined
+          ? new PrimaryKey({
+              columns: sqlTable.primaryKey.columns,
+              ...ifDefined('name', sqlTable.primaryKey.name),
+              dependsOn: columnDependsOn(ddlSchema, tableName, sqlTable.primaryKey.columns),
+            })
+          : undefined;
       tables[tableName] = new PostgresTableSchemaNode({
         name: sqlTable.name,
         columns: sqlTable.columns,
         foreignKeys,
-        uniques: sqlTable.uniques,
-        indexes: sqlTable.indexes,
-        ...ifDefined('primaryKey', sqlTable.primaryKey),
+        uniques,
+        indexes,
+        ...ifDefined('primaryKey', primaryKey),
         ...ifDefined('annotations', sqlTable.annotations),
         ...ifDefined('checks', sqlTable.checks),
         policies: policiesByTable.get(tableName) ?? [],

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

@@ -5,6 +5,7 @@ import type {
   SuppressionRecord,
 } from '@prisma-next/family-sql/control';
 import type { SchemaDiffIssue } from '@prisma-next/framework-components/control';
+import { issueOutcome } 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';
@@ -252,7 +253,7 @@ const POSTGRES_NODE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.
  * it is not admitted as creation-class here.
  */
 function isEnablementCreationIssue(issue: SchemaDiffIssue<SqlSchemaDiffNode>): boolean {
-  if (issue.reason !== 'not-equal') return false;
+  if (issueOutcome(issue) !== 'not-equal') return false;
   const { expected, actual } = issue;
   return (
     expected !== undefined &&
@@ -270,7 +271,7 @@ export function resolvePostgresNodeIssueCreationFactoryName(
   if (isEnablementCreationIssue(issue)) {
     return 'enableRowLevelSecurity';
   }
-  if (issue.reason !== 'not-found') return undefined;
+  if (issueOutcome(issue) !== 'not-found') return undefined;
   const node = issue.expected ?? issue.actual;
   if (node === undefined) return undefined;
   return POSTGRES_NODE_CREATION_FACTORY[node.nodeKind];
@@ -298,7 +299,7 @@ export function resolvePostgresNodeIssueControlPolicySubject(
     >(node);
     return {
       namespaceId: resolveNamespaceIdForDdlSchema(contract, namespaceNode.schemaName),
-      createsNewObject: issue.reason === 'not-found',
+      createsNewObject: issueOutcome(issue) === 'not-found',
     };
   }
 

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

@@ -4,12 +4,13 @@ import { buildNativeTypeExpander } from '@prisma-next/family-sql/control';
 import { classifyDiffSubjectGranularity } from '@prisma-next/family-sql/diff';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { DiffableNode, SchemaDiffIssue } from '@prisma-next/framework-components/control';
-import { diffSchemas } from '@prisma-next/framework-components/control';
+import { diffSchemas, issueOutcome } 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 { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { postgresResolveDefault } from '../default-normalizer';
 import type { PostgresContract } from '../postgres-schema';
 import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 import { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';
@@ -135,12 +136,13 @@ export function diffPostgresSchema(input: {
   const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
     annotationNamespace: 'pg',
     ...ifDefined('expandNativeType', expandNativeType),
+    resolveDefault: postgresResolveDefault,
   });
   const expected = pruneTableLessNamespaces(fullExpected);
   const relationalOwned = ownedSchemaNames(expected);
   const structuralOwned = ownedSchemaNames(fullExpected);
   const issues = diffSchemas(expected, actual).filter((issue) => {
-    if (issue.reason !== 'not-expected') return true;
+    if (issueOutcome(issue) !== 'not-expected') return true;
     if (isClusterScopedIssue(issue)) return true;
     const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
     const namespaceSegment = issue.path[1];
@@ -230,6 +232,7 @@ export function buildPostgresPlanDiff(input: {
   const projectionOptions = {
     annotationNamespace: 'pg',
     ...ifDefined('expandNativeType', expandNativeType),
+    resolveDefault: postgresResolveDefault,
   };
   const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, projectionOptions);
   const expected = pruneTableLessNamespaces(fullExpected);
@@ -240,7 +243,7 @@ export function buildPostgresPlanDiff(input: {
     readonly SchemaDiffIssue<SqlSchemaDiffNode>[],
     'both trees are PostgresDatabaseSchemaNodes, so every diff-issue node is a SqlSchemaDiffNode'
   >(diffSchemas(expected, paddedActual)).filter((issue) => {
-    if (issue.reason !== 'not-expected') return true;
+    if (issueOutcome(issue) !== 'not-expected') return true;
     if (isClusterScopedIssue(issue)) return true;
     const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
     const namespaceSegment = issue.path[1];