@prisma-next/target-postgres 0.16.0-dev.3 → 0.16.0-dev.31

package/src/core/migrations/op-factory-call.ts

@@ -38,6 +38,7 @@ import { FunctionColumnDefault, LiteralColumnDefault } from '@prisma-next/sql-re
 import { type ImportRequirement, jsonToTsSource, TsExpression } from '@prisma-next/ts-render';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { assertNever } from '@prisma-next/utils/internal-error';
 import {
   columnExistsAst,
   nativeEnumTypeExistsAst,
@@ -45,6 +46,7 @@ import {
   tableExistsAst,
 } from '../../contract-free/checks';
 import * as contractFreeDdl from '../../contract-free/ddl';
+import { postgresError } from '../errors';
 import type { PostgresRlsPolicy, PostgresRlsPolicyInput } from '../postgres-rls-policy';
 import {
   escapeLiteral,
@@ -72,7 +74,13 @@ import {
   dropConstraint,
 } from './operations/constraints';
 import { createExtension } from './operations/dependencies';
-import { createIndex, dropIndex } from './operations/indexes';
+import {
+  type CreateIndexElements,
+  type CreateIndexExtras,
+  createIndex,
+  dropIndex,
+  renameIndex,
+} from './operations/indexes';
 import { createNativeEnumType, dropNativeEnumType } from './operations/native-enum-types';
 import {
   createRlsPolicy,
@@ -138,7 +146,8 @@ export function postgresDefaultToDdlColumnDefault(
       );
     default: {
       const exhaustive: never = columnDefault;
-      throw new Error(
+      return assertNever(
+        exhaustive,
         `postgresDefaultToDdlColumnDefault: unhandled kind "${blindCast<{ kind: string }, 'exhaustiveness: surface the unhandled default kind'>(exhaustive).kind}"`,
       );
     }
@@ -241,8 +250,10 @@ export class CreateTableCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `CreateTableCall.toOp: a DDL lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'CreateTableCall' } },
       );
     }
     const ddlNode = contractFreeDdl.createTable({
@@ -324,8 +335,10 @@ export class DropTableCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropTableCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropTableCall' } },
       );
     }
     return dropTable(this.schemaName, this.tableName, lowerer);
@@ -368,8 +381,10 @@ export class AddColumnCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddColumnCall.toOp: a DDL lowerer is required on the Postgres planner path (column "${this.column.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddColumnCall' } },
       );
     }
     const ddlNode = contractFreeDdl.alterTable({
@@ -435,8 +450,10 @@ export class DropColumnCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropColumnCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropColumnCall' } },
       );
     }
     return dropColumn(this.schemaName, this.tableName, this.columnName, lowerer);
@@ -490,8 +507,10 @@ export class AlterColumnTypeCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AlterColumnTypeCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AlterColumnTypeCall' } },
       );
     }
     return alterColumnType(this.schemaName, this.tableName, this.columnName, this.options, lowerer);
@@ -532,8 +551,10 @@ export class SetNotNullCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `SetNotNullCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'SetNotNullCall' } },
       );
     }
     return setNotNull(this.schemaName, this.tableName, this.columnName, lowerer);
@@ -573,8 +594,10 @@ export class DropNotNullCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropNotNullCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropNotNullCall' } },
       );
     }
     return dropNotNull(this.schemaName, this.tableName, this.columnName, lowerer);
@@ -623,8 +646,10 @@ export class SetDefaultCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `SetDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'SetDefaultCall' } },
       );
     }
     return setDefault(
@@ -675,8 +700,10 @@ export class DropDefaultCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropDefaultCall' } },
       );
     }
     return dropDefault(this.schemaName, this.tableName, this.columnName, lowerer);
@@ -730,8 +757,10 @@ export class AddNotNullColumnDirectCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddNotNullColumnDirectCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddNotNullColumnDirectCall' } },
       );
     }
     return addNotNullColumnDirect(this.schemaName, this.tableName, this.column, lowerer);
@@ -787,8 +816,10 @@ export class AddNotNullColumnWithTempDefaultCall extends PostgresOpFactoryCallNo
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddNotNullColumnWithTempDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddNotNullColumnWithTempDefaultCall' } },
       );
     }
     return buildAddNotNullColumnWithTemporaryDefaultOperation({
@@ -852,8 +883,10 @@ export class AddPrimaryKeyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddPrimaryKeyCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddPrimaryKeyCall' } },
       );
     }
     return addPrimaryKey(
@@ -900,8 +933,10 @@ export class AddUniqueCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddUniqueCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddUniqueCall' } },
       );
     }
     return addUnique(this.schemaName, this.tableName, this.constraintName, this.columns, lowerer);
@@ -935,8 +970,10 @@ export class AddForeignKeyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddForeignKeyCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.fk.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddForeignKeyCall' } },
       );
     }
     return addForeignKey(this.schemaName, this.tableName, this.fk, lowerer);
@@ -983,8 +1020,10 @@ export class DropConstraintCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropConstraintCall' } },
       );
     }
     return dropConstraint(this.schemaName, this.tableName, this.constraintName, lowerer, this.kind);
@@ -1032,8 +1071,10 @@ export class AddCheckConstraintCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddCheckConstraintCall' } },
       );
     }
     return addCheckConstraint(
@@ -1074,8 +1115,10 @@ export class DropCheckConstraintCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropCheckConstraintCall' } },
       );
     }
     return dropCheckConstraint(this.schemaName, this.tableName, this.constraintName, lowerer);
@@ -1100,45 +1143,64 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
   readonly schemaName: string;
   readonly tableName: string;
   readonly indexName: string;
-  readonly columns: readonly string[];
+  /** Column tuple when the index is column-based; absent for expression indexes. */
+  readonly columns: readonly string[] | undefined;
+  /** Opaque whole element list when the index is expression-based. */
+  readonly expression: string | undefined;
   // Named indexType (not typeName): `locationForCall` in issue-planner.ts reads
   // a call's `typeName` as a CREATE TYPE target location, which an index is not.
   readonly indexType: string | undefined;
   readonly options: Record<string, unknown> | undefined;
+  readonly where: string | undefined;
+  readonly unique: boolean;
   readonly label: string;
 
   constructor(
     schemaName: string,
     tableName: string,
     indexName: string,
-    columns: readonly string[],
-    extras?: { readonly type?: string; readonly options?: Record<string, unknown> },
+    elements: CreateIndexElements,
+    extras?: CreateIndexExtras,
   ) {
     super();
     this.schemaName = schemaName;
     this.tableName = tableName;
     this.indexName = indexName;
-    this.columns = columns;
+    this.columns = 'columns' in elements ? elements.columns : undefined;
+    this.expression = 'expression' in elements ? elements.expression : undefined;
     this.indexType = extras?.type;
     this.options = extras?.options;
+    this.where = extras?.where;
+    this.unique = extras?.unique === true;
     this.label = `Create index "${indexName}" on "${tableName}"`;
     this.freeze();
   }
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `CreateIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'CreateIndexCall' } },
       );
     }
-    const extras: { type?: string; options?: Record<string, unknown> } = {};
+    const extras: {
+      type?: string;
+      options?: Record<string, unknown>;
+      where?: string;
+      unique?: boolean;
+    } = {};
     if (this.indexType !== undefined) extras.type = this.indexType;
     if (this.options !== undefined) extras.options = this.options;
+    if (this.where !== undefined) extras.where = this.where;
+    if (this.unique) extras.unique = true;
     return createIndex(
       this.schemaName,
       this.tableName,
       this.indexName,
-      this.columns,
+      this.columns !== undefined
+        ? { columns: this.columns }
+        : { expression: this.expression ?? '' },
       lowerer,
       extras,
     );
@@ -1151,11 +1213,22 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
     }
     opts.push(`table: ${jsonToTsSource(this.tableName)}`);
     opts.push(`index: ${jsonToTsSource(this.indexName)}`);
-    opts.push(`columns: ${jsonToTsSource(this.columns)}`);
-    if (this.indexType !== undefined || this.options !== undefined) {
+    if (this.columns !== undefined) {
+      opts.push(`columns: ${jsonToTsSource(this.columns)}`);
+    } else {
+      opts.push(`expression: ${jsonToTsSource(this.expression ?? '')}`);
+    }
+    if (
+      this.indexType !== undefined ||
+      this.options !== undefined ||
+      this.where !== undefined ||
+      this.unique
+    ) {
       const extrasParts: string[] = [];
       if (this.indexType !== undefined) extrasParts.push(`type: ${jsonToTsSource(this.indexType)}`);
       if (this.options !== undefined) extrasParts.push(`options: ${jsonToTsSource(this.options)}`);
+      if (this.where !== undefined) extrasParts.push(`where: ${jsonToTsSource(this.where)}`);
+      if (this.unique) extrasParts.push('unique: true');
       opts.push(`extras: { ${extrasParts.join(', ')} }`);
     }
     return `this.createIndex({ ${opts.join(', ')} })`;
@@ -1166,6 +1239,62 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
   }
 }
 
+export class RenameIndexCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'renameIndex' as const;
+  // `widening` is chosen so the rename plans under every allowance set except
+  // additive-only init — a rename is neither additive-creation nor
+  // destructive, and the class vocabulary has no neutral middle class. It is
+  // NOT that a rename widens anything; this is the accepted typology tradeoff.
+  readonly operationClass = 'widening' as const;
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly oldIndexName: string;
+  readonly newIndexName: string;
+  readonly label: string;
+
+  constructor(schemaName: string, tableName: string, oldIndexName: string, newIndexName: string) {
+    super();
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.oldIndexName = oldIndexName;
+    this.newIndexName = newIndexName;
+    this.label = `Rename index "${oldIndexName}" to "${newIndexName}" on "${tableName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
+        `RenameIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.oldIndexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'RenameIndexCall' } },
+      );
+    }
+    return renameIndex(
+      this.schemaName,
+      this.tableName,
+      this.oldIndexName,
+      this.newIndexName,
+      lowerer,
+    );
+  }
+
+  renderTypeScript(): string {
+    const opts: string[] = [];
+    if (this.schemaName !== UNBOUND_NAMESPACE_ID) {
+      opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+    }
+    opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+    opts.push(`from: ${jsonToTsSource(this.oldIndexName)}`);
+    opts.push(`to: ${jsonToTsSource(this.newIndexName)}`);
+    return `this.renameIndex({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
+  }
+}
+
 export class DropIndexCall extends PostgresOpFactoryCallNode {
   readonly factoryName = 'dropIndex' as const;
   readonly operationClass = 'destructive' as const;
@@ -1185,8 +1314,10 @@ export class DropIndexCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropIndexCall.toOp: a lowerer is required on the Postgres planner path (index "${this.indexName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropIndexCall' } },
       );
     }
     return dropIndex(this.schemaName, this.tableName, this.indexName, lowerer);
@@ -1288,8 +1419,10 @@ export class CreateSchemaCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `CreateSchemaCall.toOp: a DDL lowerer is required on the Postgres planner path (schema "${this.schemaName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'CreateSchemaCall' } },
       );
     }
     const ddlNode = contractFreeDdl.createSchema({ schema: this.schemaName, ifNotExists: true });
@@ -1344,8 +1477,10 @@ export class CreateNativeEnumTypeCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `CreateNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'CreateNativeEnumTypeCall' } },
       );
     }
     return createNativeEnumType(this.schemaName, this.typeName, this.members, lowerer);
@@ -1382,8 +1517,10 @@ export class DropNativeEnumTypeCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropNativeEnumTypeCall' } },
       );
     }
     return dropNativeEnumType(this.schemaName, this.typeName, lowerer);
@@ -1444,8 +1581,10 @@ export class AddNativeEnumValueCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `AddNativeEnumValueCall.toOp: a lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'AddNativeEnumValueCall' } },
       );
     }
     const { schemaName, typeName, value } = this;
@@ -1547,12 +1686,7 @@ export class DataTransformCall extends PostgresOpFactoryCallNode {
   override importRequirements(): readonly ImportRequirement[] {
     return [
       { moduleSpecifier: POSTGRES_MIGRATION_FACADE, symbol: 'placeholder' },
-      {
-        moduleSpecifier: './end-contract.json',
-        symbol: 'endContract',
-        kind: 'default',
-        attributes: { type: 'json' },
-      },
+      // endContract is imported by the migration scaffold's contractImports; an op never renders outside it.
     ];
   }
 }
@@ -1576,8 +1710,10 @@ export class CreatePostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `CreatePostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.policy.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'CreatePostgresRlsPolicyCall' } },
       );
     }
     return createRlsPolicy(this.schemaName, this.tableName, this.policy, lowerer);
@@ -1623,8 +1759,10 @@ export class DropPostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DropPostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.policyName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DropPostgresRlsPolicyCall' } },
       );
     }
     return dropRlsPolicy(this.schemaName, this.tableName, this.policyName, lowerer);
@@ -1656,8 +1794,10 @@ export class EnableRowLevelSecurityCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `EnableRowLevelSecurityCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'EnableRowLevelSecurityCall' } },
       );
     }
     return enableRowLevelSecurity(this.schemaName, this.tableName, lowerer);
@@ -1689,8 +1829,10 @@ export class DisableRowLevelSecurityCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `DisableRowLevelSecurityCall.toOp: a lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'DisableRowLevelSecurityCall' } },
       );
     }
     return disableRowLevelSecurity(this.schemaName, this.tableName, lowerer);
@@ -1730,8 +1872,10 @@ export class RenamePostgresRlsPolicyCall extends PostgresOpFactoryCallNode {
 
   async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
         `RenamePostgresRlsPolicyCall.toOp: a lowerer is required on the Postgres planner path (policy "${this.oldPolicyName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+        { meta: { factory: 'RenamePostgresRlsPolicyCall' } },
       );
     }
     return renameRlsPolicy(
@@ -1770,6 +1914,7 @@ export type PostgresOpFactoryCall =
   | AddCheckConstraintCall
   | DropCheckConstraintCall
   | CreateIndexCall
+  | RenameIndexCall
   | DropIndexCall
   | DropConstraintCall
   | RawSqlCall

package/src/core/migrations/operations/constraints.ts

@@ -1,5 +1,6 @@
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
+import { InternalError } from '@prisma-next/utils/internal-error';
 import { constraintExistsAst } from '../../../contract-free/checks';
 import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
 import { qualifyTableName } from '../planner-sql-checks';
@@ -29,14 +30,14 @@ REFERENCES ${qualifyTableName(fk.references.schema, fk.references.table)} (${fk.
   if (fk.onDelete !== undefined) {
     const action = REFERENTIAL_ACTION_SQL[fk.onDelete];
     if (!action) {
-      throw new Error(`Unknown referential action for onDelete: ${String(fk.onDelete)}`);
+      throw new InternalError(`Unknown referential action for onDelete: ${String(fk.onDelete)}`);
     }
     sql += `\nON DELETE ${action}`;
   }
   if (fk.onUpdate !== undefined) {
     const action = REFERENTIAL_ACTION_SQL[fk.onUpdate];
     if (!action) {
-      throw new Error(`Unknown referential action for onUpdate: ${String(fk.onUpdate)}`);
+      throw new InternalError(`Unknown referential action for onUpdate: ${String(fk.onUpdate)}`);
     }
     sql += `\nON UPDATE ${action}`;
   }

package/src/core/migrations/operations/data-transform.ts

@@ -5,7 +5,7 @@
  * supplies the control adapter from the migration's injected stack:
  *
  * ```ts
- * import endContract from './end-contract.json' with { type: 'json' };
+ * import endContract from '../../snapshots/93f07d1b…c9e1e5a2/contract.json' with { type: 'json' };
  *
  * class M extends Migration {
  *   override get operations() {