@prisma-next/target-postgres 0.15.0-dev.8 → 0.15.0

package/package.json

@@ -1,35 +1,35 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.15.0-dev.8",
+  "version": "0.15.0",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.15.0-dev.8",
-    "@prisma-next/contract": "0.15.0-dev.8",
-    "@prisma-next/errors": "0.15.0-dev.8",
-    "@prisma-next/family-sql": "0.15.0-dev.8",
-    "@prisma-next/framework-components": "0.15.0-dev.8",
-    "@prisma-next/migration-tools": "0.15.0-dev.8",
-    "@prisma-next/psl-parser": "0.15.0-dev.8",
-    "@prisma-next/sql-contract": "0.15.0-dev.8",
-    "@prisma-next/sql-errors": "0.15.0-dev.8",
-    "@prisma-next/sql-operations": "0.15.0-dev.8",
-    "@prisma-next/sql-relational-core": "0.15.0-dev.8",
-    "@prisma-next/sql-schema-ir": "0.15.0-dev.8",
-    "@prisma-next/ts-render": "0.15.0-dev.8",
-    "@prisma-next/utils": "0.15.0-dev.8",
+    "@prisma-next/cli": "0.15.0",
+    "@prisma-next/contract": "0.15.0",
+    "@prisma-next/errors": "0.15.0",
+    "@prisma-next/family-sql": "0.15.0",
+    "@prisma-next/framework-components": "0.15.0",
+    "@prisma-next/migration-tools": "0.15.0",
+    "@prisma-next/psl-parser": "0.15.0",
+    "@prisma-next/sql-contract": "0.15.0",
+    "@prisma-next/sql-errors": "0.15.0",
+    "@prisma-next/sql-operations": "0.15.0",
+    "@prisma-next/sql-relational-core": "0.15.0",
+    "@prisma-next/sql-schema-ir": "0.15.0",
+    "@prisma-next/ts-render": "0.15.0",
+    "@prisma-next/utils": "0.15.0",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.2",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/psl-printer": "0.15.0-dev.8",
-    "@prisma-next/sql-contract-psl": "0.15.0-dev.8",
-    "@prisma-next/test-utils": "0.15.0-dev.8",
-    "@prisma-next/tsconfig": "0.15.0-dev.8",
-    "@prisma-next/tsdown": "0.15.0-dev.8",
+    "@prisma-next/psl-printer": "0.15.0",
+    "@prisma-next/sql-contract-psl": "0.15.0",
+    "@prisma-next/test-utils": "0.15.0",
+    "@prisma-next/tsconfig": "0.15.0",
+    "@prisma-next/tsdown": "0.15.0",
     "tsdown": "0.22.3",
     "typescript": "5.9.3",
     "vitest": "4.1.10"

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

@@ -1,14 +1,7 @@
 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 {
-  PrimaryKey,
-  RelationalSchemaNodeKind,
-  SqlForeignKeyIR,
-  SqlIndexIR,
-  SqlUniqueIR,
-} from '@prisma-next/sql-schema-ir/types';
+import { SqlForeignKeyIR } 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';
@@ -19,43 +12,8 @@ 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,
@@ -67,7 +25,6 @@ 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)],
   });
 }
 
@@ -158,67 +115,30 @@ 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) => {
-        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 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 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,
-        indexes,
-        ...ifDefined('primaryKey', primaryKey),
+        uniques: sqlTable.uniques,
+        indexes: sqlTable.indexes,
+        ...ifDefined('primaryKey', sqlTable.primaryKey),
         ...ifDefined('annotations', sqlTable.annotations),
         ...ifDefined('checks', sqlTable.checks),
         policies: policiesByTable.get(tableName) ?? [],

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

@@ -5,7 +5,6 @@ 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';
@@ -253,7 +252,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 (issueOutcome(issue) !== 'not-equal') return false;
+  if (issue.reason !== 'not-equal') return false;
   const { expected, actual } = issue;
   return (
     expected !== undefined &&
@@ -271,7 +270,7 @@ export function resolvePostgresNodeIssueCreationFactoryName(
   if (isEnablementCreationIssue(issue)) {
     return 'enableRowLevelSecurity';
   }
-  if (issueOutcome(issue) !== 'not-found') return 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];
@@ -299,7 +298,7 @@ export function resolvePostgresNodeIssueControlPolicySubject(
     >(node);
     return {
       namespaceId: resolveNamespaceIdForDdlSchema(contract, namespaceNode.schemaName),
-      createsNewObject: issueOutcome(issue) === 'not-found',
+      createsNewObject: issue.reason === 'not-found',
     };
   }
 

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

@@ -4,7 +4,7 @@ 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, issueOutcome } from '@prisma-next/framework-components/control';
+import { diffSchemas } 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';
@@ -140,7 +140,7 @@ export function diffPostgresSchema(input: {
   const relationalOwned = ownedSchemaNames(expected);
   const structuralOwned = ownedSchemaNames(fullExpected);
   const issues = diffSchemas(expected, actual).filter((issue) => {
-    if (issueOutcome(issue) !== 'not-expected') return true;
+    if (issue.reason !== 'not-expected') return true;
     if (isClusterScopedIssue(issue)) return true;
     const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
     const namespaceSegment = issue.path[1];
@@ -240,7 +240,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 (issueOutcome(issue) !== 'not-expected') return true;
+    if (issue.reason !== 'not-expected') return true;
     if (isClusterScopedIssue(issue)) return true;
     const granularity = classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity);
     const namespaceSegment = issue.path[1];

package/src/core/migrations/issue-planner.ts

@@ -25,7 +25,6 @@ import type {
 } from '@prisma-next/family-sql/control';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { DiffableNode, SchemaDiffIssue } from '@prisma-next/framework-components/control';
-import { issueOutcome, orderIssuesByDependencies } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlStorage, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import type { DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
@@ -137,7 +136,6 @@ export interface IssuePlannerValue {
 type CallCategory =
   | 'dep'
   | 'drop'
-  | 'dropType'
   | 'table'
   | 'rlsEnable'
   | 'rlsPolicy'
@@ -153,13 +151,6 @@ type CallCategory =
  * legacy walk-schema planner's emission order so `db init` and `db update`
  * produce byte-identical plans for the shared shape (deps → drops → tables
  * → columns → alters → PKs → uniques → indexes → FKs).
- *
- * `dropType` (DROP TYPE for a managed native enum) is its own bucket, ordered
- * after the general drop bucket: a type can only be dropped once every table
- * whose column uses it is gone. A column→enum edge would make this precise,
- * but `coalesceSubtreeIssues` removes the column issue under a whole-table
- * drop, so the edge never reaches the graph; the coarse bucket stands in until
- * that edge lands (the coordinate work is a later slice).
  */
 function classifyCall(call: PostgresOpFactoryCall): CallCategory {
   switch (call.factoryName) {
@@ -168,9 +159,8 @@ function classifyCall(call: PostgresOpFactoryCall): CallCategory {
     case 'createNativeEnumType':
     case 'addNativeEnumValue':
       return 'dep';
-    case 'dropNativeEnumType':
-      return 'dropType';
     case 'dropTable':
+    case 'dropNativeEnumType':
     case 'dropColumn':
     case 'dropConstraint':
     case 'dropCheckConstraint':
@@ -379,6 +369,57 @@ export function columnTypeChanged(expected: SqlColumnIR, actual: SqlColumnIR): b
   );
 }
 
+// ----------------------------------------------------------------------------
+// Node-keyed issue ordering (re-keys ISSUE_KIND_ORDER on nodeKind + reason)
+// ----------------------------------------------------------------------------
+
+/**
+ * Re-keys the legacy `ISSUE_KIND_ORDER` on `(nodeKind, reason)`, numbers
+ * preserved so the dependency intent stays legible. Final emission order is
+ * fixed downstream by `classifyCall` bucketing (dep → drop → table → column →
+ * recipe → alter → primaryKey → unique → index → foreignKey), so this only
+ * breaks ties within a bucket.
+ */
+export function nodeIssueOrder(issue: SchemaDiffIssue): number {
+  const node = issueNode(issue);
+  if (node === undefined) return 99;
+  switch (node.nodeKind) {
+    case PostgresSchemaNodeKind.namespace:
+      return 1;
+    case PostgresSchemaNodeKind.nativeEnum:
+      // Creates order right after namespace creates within the 'dep' bucket
+      // (CREATE SCHEMA before CREATE TYPE); drops order after table drops
+      // within the 'drop' bucket (DROP TYPE only after its dependents left).
+      return issue.reason === 'not-expected' ? 17 : 2;
+    case RelationalSchemaNodeKind.foreignKey:
+      return issue.reason === 'not-expected' ? 10 : 60;
+    case RelationalSchemaNodeKind.unique:
+      return issue.reason === 'not-expected' ? 11 : 51;
+    case RelationalSchemaNodeKind.primaryKey:
+      return issue.reason === 'not-expected' ? 12 : 50;
+    case RelationalSchemaNodeKind.index:
+      return issue.reason === 'not-expected' ? 13 : 52;
+    case RelationalSchemaNodeKind.columnDefault:
+      if (issue.reason === 'not-expected') return 14;
+      return issue.reason === 'not-found' ? 42 : 43;
+    case RelationalSchemaNodeKind.column:
+      if (issue.reason === 'not-expected') return 15;
+      return issue.reason === 'not-found' ? 30 : 40;
+    case PostgresSchemaNodeKind.table:
+      return issue.reason === 'not-expected' ? 16 : 20;
+    case RelationalSchemaNodeKind.check:
+      if (issue.reason === 'not-found') return 53;
+      return issue.reason === 'not-expected' ? 55 : 54;
+    default:
+      return 99;
+  }
+}
+
+/** Deterministic tiebreak within an order bucket: the diff path already encodes schema → table → child. */
+export function nodeIssueKey(issue: SchemaDiffIssue): string {
+  return issue.path.join(' ');
+}
+
 // ----------------------------------------------------------------------------
 // Subtree coalescing (the planner's responsibility per the differ's contract)
 // ----------------------------------------------------------------------------
@@ -396,7 +437,7 @@ export function coalesceSubtreeIssues<TNode extends DiffableNode = DiffableNode>
   issues: readonly SchemaDiffIssue<TNode>[],
 ): readonly SchemaDiffIssue<TNode>[] {
   const collapsingPaths = issues
-    .filter((issue) => issueOutcome(issue) !== 'not-equal')
+    .filter((issue) => issue.reason === 'not-found' || issue.reason === 'not-expected')
     .map((issue) => issue.path);
   if (collapsingPaths.length === 0) return issues;
   return issues.filter(
@@ -560,14 +601,14 @@ function mapNativeEnumNodeIssue(
     );
   }
   const schemaName = emissionSchemaName(ctx, ddlSchemaName);
-  if (issueOutcome(issue) === 'not-found') {
+  if (issue.reason === 'not-found') {
     const expected = blindCast<
       PostgresNativeEnumSchemaNode,
       'a not-found native-enum issue always carries the expected PostgresNativeEnumSchemaNode'
     >(issue.expected);
     return ok([new CreateNativeEnumTypeCall(schemaName, expected.typeName, expected.members)]);
   }
-  if (issueOutcome(issue) === 'not-expected') {
+  if (issue.reason === 'not-expected') {
     const actual = blindCast<
       PostgresNativeEnumSchemaNode,
       'a not-expected native-enum issue always carries the actual PostgresNativeEnumSchemaNode'
@@ -613,14 +654,14 @@ function mapTableNodeIssue(
   ddlSchemaName: string,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
 ): Result<readonly PostgresOpFactoryCall[], SqlPlannerConflict> {
-  if (issueOutcome(issue) === 'not-found') {
+  if (issue.reason === 'not-found') {
     const table = blindCast<
       PostgresTableSchemaNode,
       'a not-found table issue always carries the expected PostgresTableSchemaNode'
     >(issue.expected);
     return ok(buildCreateTableCallsFromNode(schemaName, ddlSchemaName, table, codecHooks));
   }
-  if (issueOutcome(issue) === 'not-expected') {
+  if (issue.reason === 'not-expected') {
     const table = blindCast<
       PostgresTableSchemaNode,
       'a not-expected table issue always carries the actual PostgresTableSchemaNode'
@@ -662,7 +703,7 @@ function mapColumnNodeIssue(
   tableName: string,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
 ): Result<readonly PostgresOpFactoryCall[], SqlPlannerConflict> {
-  if (issueOutcome(issue) === 'not-found') {
+  if (issue.reason === 'not-found') {
     const column = blindCast<
       SqlColumnIR,
       'a not-found column issue always carries the expected column node'
@@ -671,7 +712,7 @@ function mapColumnNodeIssue(
       new AddColumnCall(schemaName, tableName, renderColumnDdl(column.name, column, codecHooks)),
     ]);
   }
-  if (issueOutcome(issue) === 'not-expected') {
+  if (issue.reason === 'not-expected') {
     const column = blindCast<
       SqlColumnIR,
       'a not-expected column issue always carries the actual column node'
@@ -714,7 +755,7 @@ function mapColumnDefaultNodeIssue(
   tableName: string,
   columnName: string,
 ): Result<readonly PostgresOpFactoryCall[], SqlPlannerConflict> {
-  if (issueOutcome(issue) === 'not-expected') {
+  if (issue.reason === 'not-expected') {
     return ok([new DropDefaultCall(schemaName, tableName, columnName)]);
   }
   // not-found (SET DEFAULT, additive) or not-equal (SET DEFAULT, widening).
@@ -731,7 +772,7 @@ function mapColumnDefaultNodeIssue(
       tableName,
       columnName,
       defaultSql,
-      issueOutcome(issue) === 'not-equal' ? 'widening' : 'additive',
+      issue.reason === 'not-equal' ? 'widening' : 'additive',
     ),
   ]);
 }
@@ -741,7 +782,7 @@ function mapPrimaryKeyNodeIssue(
   schemaName: string,
   tableName: string,
 ): Result<readonly PostgresOpFactoryCall[], SqlPlannerConflict> {
-  if (issueOutcome(issue) === 'not-found') {
+  if (issue.reason === 'not-found') {
     const pk = blindCast<
       { readonly columns: readonly string[]; readonly name?: string },
       'a not-found primary-key issue always carries the expected PrimaryKey node'
@@ -749,7 +790,7 @@ function mapPrimaryKeyNodeIssue(
     const constraintName = pk.name ?? `${tableName}_pkey`;
     return ok([new AddPrimaryKeyCall(schemaName, tableName, constraintName, [...pk.columns])]);
   }
-  if (issueOutcome(issue) === 'not-expected') {
+  if (issue.reason === 'not-expected') {
     const pk = blindCast<
       { readonly name?: string },
       'a not-expected primary-key issue always carries the actual PrimaryKey node'
@@ -766,14 +807,14 @@ function mapForeignKeyNodeIssue(
   schemaName: string,
   tableName: string,
 ): Result<readonly PostgresOpFactoryCall[], SqlPlannerConflict> {
-  if (issueOutcome(issue) === 'not-found') {
+  if (issue.reason === 'not-found') {
     const fk = blindCast<
       SqlForeignKeyIR,
       'a not-found foreign-key issue always carries the expected foreign-key node'
     >(issue.expected);
     return ok([new AddForeignKeyCall(schemaName, tableName, fkSpecFromNode(fk, tableName))]);
   }
-  if (issueOutcome(issue) === 'not-expected') {
+  if (issue.reason === 'not-expected') {
     const fk = blindCast<
       SqlForeignKeyIR,
       'a not-expected foreign-key issue always carries the actual foreign-key node'
@@ -789,7 +830,7 @@ function mapUniqueNodeIssue(
   schemaName: string,
   tableName: string,
 ): Result<readonly PostgresOpFactoryCall[], SqlPlannerConflict> {
-  if (issueOutcome(issue) === 'not-found') {
+  if (issue.reason === 'not-found') {
     const unique = blindCast<
       SqlUniqueIR,
       'a not-found unique issue always carries the expected unique node'
@@ -797,7 +838,7 @@ function mapUniqueNodeIssue(
     const name = unique.name ?? `${tableName}_${unique.columns.join('_')}_key`;
     return ok([new AddUniqueCall(schemaName, tableName, name, [...unique.columns])]);
   }
-  if (issueOutcome(issue) === 'not-expected') {
+  if (issue.reason === 'not-expected') {
     const unique = blindCast<
       SqlUniqueIR,
       'a not-expected unique issue always carries the actual unique node'
@@ -813,7 +854,7 @@ function mapIndexNodeIssue(
   schemaName: string,
   tableName: string,
 ): Result<readonly PostgresOpFactoryCall[], SqlPlannerConflict> {
-  if (issueOutcome(issue) === 'not-found') {
+  if (issue.reason === 'not-found') {
     const index = blindCast<
       SqlIndexIR,
       'a not-found index issue always carries the expected index node'
@@ -824,7 +865,7 @@ function mapIndexNodeIssue(
     if (index.options !== undefined) extras.options = index.options;
     return ok([new CreateIndexCall(schemaName, tableName, indexName, [...index.columns], extras)]);
   }
-  if (issueOutcome(issue) === 'not-expected') {
+  if (issue.reason === 'not-expected') {
     const index = blindCast<
       SqlIndexIR,
       'a not-expected index issue always carries the actual index node'
@@ -844,7 +885,7 @@ function mapCheckNodeIssue(
   // the default mapper handles directly; check_missing / check_mismatch are
   // consumed by `checkConstraintPlanCallStrategy` (drop+recreate), so reaching
   // here for them means the strategy did not run — a conflict.
-  if (issueOutcome(issue) === 'not-expected') {
+  if (issue.reason === 'not-expected') {
     const check = blindCast<
       { readonly name: string },
       'a not-expected check issue always carries the actual check node'
@@ -861,8 +902,8 @@ function mapCheckNodeIssue(
 
 /**
  * Maps one node-typed diff issue to its migration call(s), dispatching on the
- * node's `nodeKind` and the issue's presence-derived `issueOutcome`, reading
- * nodes and resolving column DDL from `codecRef` via `column-ddl-rendering.ts`.
+ * node's `nodeKind` + `issue.reason`, reading nodes and resolving column DDL
+ * from `codecRef` via `column-ddl-rendering.ts`.
  */
 export function mapNodeIssueToCall(
   issue: SchemaDiffIssue,
@@ -878,7 +919,7 @@ export function mapNodeIssueToCall(
     );
   }
   if (node.nodeKind === PostgresSchemaNodeKind.namespace) {
-    if (issueOutcome(issue) !== 'not-found') {
+    if (issue.reason !== 'not-found') {
       return notOk(
         nodeConflict('unsupportedOperation', `Unexpected namespace drift: ${issue.path.join('/')}`),
       );
@@ -1011,12 +1052,13 @@ export function planIssues(
     }
   }
 
-  // Dependency-graph order: a topological sort over the issues' `dependsOn`
-  // cross-links and containment edges (the ordering law drives edge direction
-  // by presence), path-tiebroken for determinism. `classifyCall` bucketing
-  // downstream fixes the coarse cross-entity DDL sequence; this settles the
-  // order within each bucket (notably the teardown order among drops).
-  const sorted = orderIssuesByDependencies(remaining);
+  const sorted = [...remaining].sort((a, b) => {
+    const kindDelta = nodeIssueOrder(a) - nodeIssueOrder(b);
+    if (kindDelta !== 0) return kindDelta;
+    const keyA = nodeIssueKey(a);
+    const keyB = nodeIssueKey(b);
+    return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
+  });
 
   const defaultCalls: PostgresOpFactoryCall[] = [];
   const conflicts: SqlPlannerConflict[] = [];
@@ -1064,9 +1106,6 @@ export function planIssues(
   const calls: PostgresOpFactoryCall[] = [
     ...byCategory('dep'),
     ...byCategory('drop'),
-    // DROP TYPE after every table drop — a managed enum type can only go once
-    // no live column still uses it.
-    ...byCategory('dropType'),
     ...byCategory('table'),
     ...byCategory('column'),
     ...gatedRecipe,

package/src/core/migrations/planner-strategies.ts

@@ -35,7 +35,6 @@ import type {
 import { resolveValueSetValues } from '@prisma-next/family-sql/control';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { SchemaDiffIssue } from '@prisma-next/framework-components/control';
-import { issueOutcome } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   type SqlStorage,
@@ -199,7 +198,7 @@ export const notNullBackfillCallStrategy: CallMigrationStrategy = (issues, ctx)
   const calls: PostgresOpFactoryCall[] = [];
 
   for (const issue of issues) {
-    if (issueOutcome(issue) !== 'not-found') continue;
+    if (issue.reason !== 'not-found') continue;
     const node = issueNode(issue);
     if (node === undefined || node.nodeKind !== RelationalSchemaNodeKind.column) continue;
     const expected = blindCast<
@@ -264,7 +263,7 @@ export const typeChangeCallStrategy: CallMigrationStrategy = (issues, ctx) => {
   const calls: PostgresOpFactoryCall[] = [];
 
   for (const issue of issues) {
-    if (issueOutcome(issue) !== 'not-equal') continue;
+    if (issue.reason !== 'not-equal') continue;
     const pair = columnNodePair(issue);
     if (pair === undefined) continue;
     const { expected, actual } = pair;
@@ -358,7 +357,7 @@ export const nullableTighteningCallStrategy: CallMigrationStrategy = (issues, ct
   const calls: PostgresOpFactoryCall[] = [];
 
   for (const issue of issues) {
-    if (issueOutcome(issue) !== 'not-equal') continue;
+    if (issue.reason !== 'not-equal') continue;
     const pair = columnNodePair(issue);
     if (pair === undefined) continue;
     const { expected, actual } = pair;
@@ -591,7 +590,7 @@ export const notNullAddColumnCallStrategy: CallMigrationStrategy = (issues, ctx)
   const mutableStorageTypes = ctx.storageTypes as Record<string, StorageTypeInstance>;
 
   for (const issue of issues) {
-    if (issueOutcome(issue) !== 'not-found') continue;
+    if (issue.reason !== 'not-found') continue;
     const node = issueNode(issue);
     if (node === undefined || node.nodeKind !== RelationalSchemaNodeKind.column) continue;
     const expected = blindCast<
@@ -686,7 +685,8 @@ function canUseSharedTemporaryDefaultStrategy(options: {
   }
 
   for (const foreignKey of table.foreignKeys) {
-    if (!foreignKey.source.columns.includes(columnName)) continue;
+    if (foreignKey.constraint === false || !foreignKey.source.columns.includes(columnName))
+      continue;
     if (!schemaLookup || !hasForeignKey(schemaLookup, foreignKey)) return false;
   }