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

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

@@ -1,7 +1,11 @@
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { indexExistsAst } from '../../../contract-free/checks';
-import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
-import { qualifyTableName } from '../planner-sql-checks';
+import {
+  alterIndexRename as alterIndexRenameDdl,
+  createIndex as createIndexDdl,
+  dropIndex as dropIndexDdl,
+} from '../../../contract-free/ddl';
 import { type Op, step, targetDetails } from './shared';
 
 type CheckStep = { sql: string; params?: readonly unknown[] };
@@ -17,40 +21,51 @@ async function indexExistsSteps(
   return { present, absent };
 }
 
+/** An unbound-namespace object renders unqualified: the DDL node takes no schema. */
+function ddlSchemaOf(schemaName: string): string | undefined {
+  return schemaName === UNBOUND_NAMESPACE_ID ? undefined : schemaName;
+}
+
 export interface CreateIndexExtras {
   readonly type?: string;
   readonly options?: Record<string, unknown>;
+  /**
+   * Partial-index predicate (WHERE body, without the keyword). Inserted
+   * verbatim, never quoted or escaped — the same opaque-SQL stance as RLS
+   * policy predicates.
+   */
+  readonly where?: string;
+  readonly unique?: boolean;
 }
 
-function renderIndexOptionValue(key: string, value: unknown): string {
-  if (typeof value === 'string') return `'${escapeLiteral(value)}'`;
-  if (typeof value === 'number' && Number.isFinite(value)) return String(value);
-  if (typeof value === 'boolean') return value ? 'true' : 'false';
-  throw new Error(
-    `Index option "${key}" must be a string, finite number, or boolean; got ${typeof value}`,
-  );
-}
-
-function renderIndexOptions(options: Record<string, unknown>): string {
-  return Object.entries(options)
-    .map(([key, value]) => `${quoteIdentifier(key)} = ${renderIndexOptionValue(key, value)}`)
-    .join(', ');
-}
+/**
+ * The element list between the parens of CREATE INDEX: either a column
+ * tuple (each identifier quoted) or one opaque expression string covering
+ * the entire list, inserted verbatim.
+ */
+export type CreateIndexElements =
+  | { readonly columns: readonly string[] }
+  | { readonly expression: string };
 
 export async function createIndex(
   schemaName: string,
   tableName: string,
   indexName: string,
-  columns: readonly string[],
+  elements: CreateIndexElements,
   lowerer: ExecuteRequestLowerer,
   extras?: CreateIndexExtras,
 ): Promise<Op> {
-  const qualified = qualifyTableName(schemaName, tableName);
-  const columnList = columns.map(quoteIdentifier).join(', ');
-  const using = extras?.type ? ` USING ${quoteIdentifier(extras.type)}` : '';
-  const options = extras?.options;
-  const withClause =
-    options && Object.keys(options).length > 0 ? ` WITH (${renderIndexOptions(options)})` : '';
+  const ddlNode = createIndexDdl({
+    schema: ddlSchemaOf(schemaName),
+    table: tableName,
+    name: indexName,
+    unique: extras?.unique === true,
+    elements,
+    type: extras?.type,
+    options: extras?.options,
+    where: extras?.where,
+  });
+  const execute = await lowerer.lowerToExecuteRequest(ddlNode);
   const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
   return {
     id: `index.${tableName}.${indexName}`,
@@ -58,22 +73,57 @@ export async function createIndex(
     operationClass: 'additive',
     target: targetDetails('index', indexName, schemaName, tableName),
     precheck: [step(`ensure index "${indexName}" does not exist`, absent.sql, absent.params)],
-    execute: [
-      step(
-        `create index "${indexName}"`,
-        `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified}${using} (${columnList})${withClause}`,
-      ),
-    ],
+    execute: [step(`create index "${indexName}"`, execute.sql, execute.params)],
     postcheck: [step(`verify index "${indexName}" exists`, present.sql, present.params)],
   };
 }
 
+/**
+ * `ALTER INDEX … RENAME TO`. `widening` for the same typology reason as the
+ * RLS policy rename: 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.
+ */
+export async function renameIndex(
+  schemaName: string,
+  tableName: string,
+  fromName: string,
+  toName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const fromChecks = indexExistsAst(schemaName, fromName);
+  const toChecks = indexExistsAst(schemaName, toName);
+  const fromPresent = await lowerer.lowerToExecuteRequest(fromChecks.indexPresent());
+  const toAbsent = await lowerer.lowerToExecuteRequest(toChecks.indexAbsent());
+  const toPresent = await lowerer.lowerToExecuteRequest(toChecks.indexPresent());
+  const ddlNode = alterIndexRenameDdl({
+    schema: ddlSchemaOf(schemaName),
+    from: fromName,
+    to: toName,
+  });
+  const execute = await lowerer.lowerToExecuteRequest(ddlNode);
+  return {
+    id: `index.${schemaName}.${tableName}.${fromName}.rename`,
+    label: `Rename index "${fromName}" to "${toName}" on "${tableName}"`,
+    operationClass: 'widening',
+    target: targetDetails('index', toName, schemaName, tableName),
+    precheck: [
+      step(`ensure index "${fromName}" exists`, fromPresent.sql, fromPresent.params),
+      step(`ensure index "${toName}" does not exist`, toAbsent.sql, toAbsent.params),
+    ],
+    execute: [step(`rename index "${fromName}" to "${toName}"`, execute.sql, execute.params)],
+    postcheck: [step(`verify index "${toName}" exists`, toPresent.sql, toPresent.params)],
+  };
+}
+
 export async function dropIndex(
   schemaName: string,
   tableName: string,
   indexName: string,
   lowerer: ExecuteRequestLowerer,
 ): Promise<Op> {
+  const ddlNode = dropIndexDdl({ schema: ddlSchemaOf(schemaName), name: indexName });
+  const execute = await lowerer.lowerToExecuteRequest(ddlNode);
   const { present, absent } = await indexExistsSteps(lowerer, schemaName, indexName);
   return {
     id: `dropIndex.${tableName}.${indexName}`,
@@ -81,9 +131,7 @@ export async function dropIndex(
     operationClass: 'destructive',
     target: targetDetails('index', indexName, schemaName, tableName),
     precheck: [step(`ensure index "${indexName}" exists`, present.sql, present.params)],
-    execute: [
-      step(`drop index "${indexName}"`, `DROP INDEX ${qualifyTableName(schemaName, indexName)}`),
-    ],
+    execute: [step(`drop index "${indexName}"`, execute.sql, execute.params)],
     postcheck: [step(`verify index "${indexName}" does not exist`, absent.sql, absent.params)],
   };
 }

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

@@ -7,6 +7,7 @@ import {
   disableRowLevelSecurity as disableRowLevelSecurityDdl,
   dropPolicy,
 } from '../../../contract-free/ddl';
+import { postgresError } from '../../errors';
 import type { PostgresRlsPolicy } from '../../postgres-rls-policy';
 import { qualifyTableName } from '../planner-sql-checks';
 import { type Op, step, targetDetails } from './shared';
@@ -15,8 +16,10 @@ const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_$]*$/;
 
 function validateRoleName(role: string): string {
   if (!PLAIN_IDENTIFIER.test(role)) {
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.ROLE_INVALID',
       `Invalid role name ${JSON.stringify(role)}: role names must be plain SQL identifiers matching ^[A-Za-z_][A-Za-z0-9_$]*$`,
+      { meta: { role, reason: 'not-a-plain-identifier' } },
     );
   }
   return role;

package/src/core/migrations/planner-ddl-builders.ts

@@ -1,6 +1,8 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
 import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { isPgEnumParams } from '../codecs';
+import { postgresError } from '../errors';
 import { escapeLiteral, quoteIdentifier, quoteQualifiedName } from '../sql-utils';
 import type { PostgresColumnDefault } from '../types';
 import { resolveColumnTypeMetadata } from './planner-type-resolution';
@@ -14,9 +16,11 @@ const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\[\])?$/;
 
 function assertSafeNativeType(nativeType: string): void {
   if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) {
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.NATIVE_TYPE_INVALID',
       `Unsafe native type name in contract: "${nativeType}". ` +
         'Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?$/',
+      { meta: { nativeType } },
     );
   }
 }
@@ -28,9 +32,11 @@ function assertSafeNativeType(nativeType: string): void {
  */
 function assertSafeDefaultExpression(expression: string): void {
   if (expression.includes(';') || /--|\/\*|\$\$|\bSELECT\b/i.test(expression)) {
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.DEFAULT_INVALID',
       `Unsafe default expression in contract: "${expression}". ` +
         'Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.',
+      { meta: { expression } },
     );
   }
 }
@@ -70,7 +76,7 @@ export function buildColumnTypeSql(
   // as its quoted, schema-qualified type-name identifier. DDL-render only — the
   // verify comparison value (`resolvedNativeType`) stays the bare name the
   // family expander produces, matching introspection.
-  if (typeof resolved.typeParams?.['typeName'] === 'string') {
+  if (isPgEnumParams(resolved.typeParams)) {
     const quoted = quoteQualifiedName(resolved.nativeType);
     return column.many ? `${quoted}[]` : quoted;
   }
@@ -98,9 +104,11 @@ function expandParameterizedTypeSql(
   }
 
   if (!column.codecId) {
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.CODEC_DESCRIPTOR_MISSING',
       `Column declares typeParams for nativeType "${column.nativeType}" but has no codecId. ` +
         'Ensure the column is associated with a codec.',
+      { meta: { nativeType: column.nativeType } },
     );
   }
 
@@ -109,10 +117,12 @@ function expandParameterizedTypeSql(
     if (hooks?.planTypeOperations) {
       return null;
     }
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.PACK_CONTRIBUTION_INVALID',
       `Column declares typeParams for nativeType "${column.nativeType}" ` +
         `but no expandNativeType hook is registered for codecId "${column.codecId}". ` +
-        'Ensure the extension providing this codec is included in extensionPacks.',
+        'Ensure the extension providing this codec is included in extensions.',
+      { meta: { codecId: column.codecId, nativeType: column.nativeType } },
     );
   }
 

package/src/core/migrations/planner-produced-postgres-migration.ts

@@ -42,6 +42,7 @@ export class TypeScriptRenderablePostgresMigration
   readonly #calls: readonly OpFactoryCall[];
   readonly #meta: MigrationMeta;
   readonly #spaceId: string;
+  readonly #snapshotsImportPath: string;
   readonly #lowerer: ExecuteRequestLowerer | undefined;
   #operationsCache:
     | readonly (
@@ -54,12 +55,14 @@ export class TypeScriptRenderablePostgresMigration
     calls: readonly OpFactoryCall[],
     meta: MigrationMeta,
     spaceId: string,
+    snapshotsImportPath: string,
     lowerer?: ExecuteRequestLowerer,
   ) {
     super();
     this.#calls = calls;
     this.#meta = meta;
     this.#spaceId = spaceId;
+    this.#snapshotsImportPath = snapshotsImportPath;
     this.#lowerer = lowerer;
   }
 
@@ -85,6 +88,10 @@ export class TypeScriptRenderablePostgresMigration
   }
 
   renderTypeScript(): string {
-    return renderCallsToTypeScript(this.#calls, { from: this.#meta.from, to: this.#meta.to });
+    return renderCallsToTypeScript(this.#calls, {
+      from: this.#meta.from,
+      to: this.#meta.to,
+      snapshotsImportPath: this.#snapshotsImportPath,
+    });
   }
 }

package/src/core/migrations/planner-schema-lookup.ts

@@ -23,9 +23,9 @@ export function buildSchemaLookupMap(schema: SqlSchemaIR): ReadonlyMap<string, S
 
 function buildSchemaTableLookup(table: SqlSchemaIR['tables'][string]): SchemaTableLookup {
   const uniqueKeys = new Set(table.uniques.map((u) => u.columns.join(',')));
-  const indexKeys = new Set(table.indexes.map((i) => i.columns.join(',')));
+  const indexKeys = new Set(table.indexes.map((i) => (i.columns ?? []).join(',')));
   const uniqueIndexKeys = new Set(
-    table.indexes.filter((i) => i.unique).map((i) => i.columns.join(',')),
+    table.indexes.filter((i) => i.unique).map((i) => (i.columns ?? []).join(',')),
   );
   const fkKeys = new Set<string>();
   for (const fk of table.foreignKeys) {

package/src/core/migrations/planner.ts

@@ -24,11 +24,12 @@ import type {
 import { 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 { parseWireName } from '@prisma-next/sql-schema-ir/naming';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import { SqlIndexIR } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PostgresRlsPolicy } from '../postgres-rls-policy';
-import { parseRlsPolicyWireName } from '../rls/wire-name';
 import { postgresNodeStorageCoordinate } from '../schema-ir/node-storage-coordinate';
 import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 import { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';
@@ -46,6 +47,7 @@ import type { PostgresOpFactoryCall } from './op-factory-call';
 import {
   CreatePostgresRlsPolicyCall,
   DropPostgresRlsPolicyCall,
+  RenameIndexCall,
   RenamePostgresRlsPolicyCall,
 } from './op-factory-call';
 import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
@@ -141,6 +143,12 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
      * {@link SqlMigrationPlannerPlanOptions.ownership}.
      */
     readonly ownership?: SchemaOwnership;
+    /**
+     * POSIX-relative path from the migration package dir to
+     * `migrations/snapshots` — see
+     * {@link SqlMigrationPlannerPlanOptions.snapshotsImportPath}.
+     */
+    readonly snapshotsImportPath: string;
   }): PostgresPlanResult {
     return this.planSql(options as SqlMigrationPlannerPlanOptions);
   }
@@ -156,6 +164,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         to: context.toHash,
       },
       spaceId,
+      context.snapshotsImportPath,
       this.#lowerer,
     );
   }
@@ -229,6 +238,18 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     });
     const schemaIssues = [...namespaceIssues, ...gated];
 
+    // Index rename post-pass (the policy pass's structure, generalized): a
+    // `not-found` and a `not-expected` index that are one rename collapse
+    // into a single widening `ALTER INDEX … RENAME TO` before the per-issue
+    // mapping turns them into create + drop. Consumed issues never reach
+    // `planIssues`; the rename calls go through the same call-side
+    // control-policy partition the policy ops use.
+    const indexRenames = this.pairIndexRenames(options, schemaIssues);
+    const plannableIssues =
+      indexRenames.consumed.size === 0
+        ? schemaIssues
+        : schemaIssues.filter((issue) => !indexRenames.consumed.has(issue));
+
     const codecHooks = extractCodecControlHooks(options.frameworkComponents);
     const storageTypes = options.contract.storage.types ?? {};
     // The strategy layer reads the live schema by bare table name for existence
@@ -246,7 +267,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     // user-visible message survives even when the planner would have failed
     // to model the subject's live shape.
     const issuePartition = partitionIssuesByControlPolicy({
-      issues: schemaIssues,
+      issues: plannableIssues,
       contract: options.contract,
       resolveControlPolicySubject: (issue) =>
         resolvePostgresNodeIssueControlPolicySubject(issue, options.contract),
@@ -275,6 +296,14 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       return plannerFailure(result.failure);
     }
 
+    const indexRenamePartition = partitionCallsByControlPolicy({
+      calls: indexRenames.calls,
+      contract: options.contract,
+      resolveControlPolicySubject: (call) =>
+        resolvePostgresCallControlPolicySubject(call, options.contract),
+      resolveFactoryName: (call) => call.factoryName,
+    });
+
     const schemaDiffCalls = this.planPostgresSchemaDiff(options, policyDiffIssues);
     const schemaDiffPartition = partitionCallsByControlPolicy({
       calls: schemaDiffCalls,
@@ -307,9 +336,15 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         resolvePostgresCallControlPolicySubject(call, options.contract),
       resolveFactoryName: (call) => call.factoryName,
     });
-    const calls = [...result.value.calls, ...schemaDiffPartition.kept, ...fieldEventPartition.kept];
+    const calls = [
+      ...result.value.calls,
+      ...indexRenamePartition.kept,
+      ...schemaDiffPartition.kept,
+      ...fieldEventPartition.kept,
+    ];
     const warnings: SqlPlannerConflict[] = [
       ...issuePartition.suppressions,
+      ...indexRenamePartition.suppressions,
       ...schemaDiffPartition.suppressions,
       ...fieldEventPartition.suppressions,
     ].map((record) => renderPostgresSuppression(record, options.contract));
@@ -323,12 +358,135 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
           to: options.contract.storage.storageHash,
         },
         options.spaceId,
+        options.snapshotsImportPath,
         this.#lowerer,
       ),
       ...(warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}),
     });
   }
 
+  /**
+   * Rename post-pass for indexes, per `(schema, table)`, widening-only,
+   * deterministic by sorted names — the same structure as the policy pass
+   * below (which stays untouched: policies pair by hash only).
+   *
+   * Phase 1 — hash pairing: extras whose live names parse as wire names,
+   * grouped by `(schema, table, hash)`; missing nodes iterated in sorted-name
+   * order consume the sorted-name-first candidate — a prefix-only rename.
+   *
+   * Phase 2 — content pairing: the remaining managed-missing nodes
+   * (`prefix` defined) against the remaining extras of any name shape,
+   * paired iff content-equal (columns ordered-strict both-defined-or-
+   * both-undefined, `unique`/`type` strict, `options` loose, bodies
+   * byte-equal) — exact→managed adoption convergence.
+   *
+   * Leftovers proceed as create/drop exactly as before; without the
+   * widening allowance the pass is skipped and pairing degrades to the
+   * additive half, like the policy pass.
+   */
+  private pairIndexRenames(
+    options: PlannerOptionsWithComponents,
+    issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],
+  ): {
+    readonly calls: readonly RenameIndexCall[];
+    readonly consumed: ReadonlySet<SchemaDiffIssue<SqlSchemaDiffNode>>;
+  } {
+    const consumed = new Set<SchemaDiffIssue<SqlSchemaDiffNode>>();
+    const calls: RenameIndexCall[] = [];
+    if (!options.policy.allowedOperationClasses.includes('widening')) {
+      return { calls, consumed };
+    }
+
+    interface IndexFinding {
+      readonly issue: SchemaDiffIssue<SqlSchemaDiffNode>;
+      readonly node: SqlIndexIR;
+      readonly ddlSchema: string;
+      readonly tableName: string;
+    }
+    const missing: IndexFinding[] = [];
+    const extra: IndexFinding[] = [];
+    for (const issue of issues) {
+      const node = issueNode(issue);
+      if (node === undefined || !SqlIndexIR.is(node)) continue;
+      const ddlSchema = issue.path[1];
+      const tableName = issue.path[2];
+      if (ddlSchema === undefined || tableName === undefined) continue;
+      if (issueOutcome(issue) === 'not-found') {
+        missing.push({ issue, node, ddlSchema, tableName });
+      } else if (issueOutcome(issue) === 'not-expected') {
+        extra.push({ issue, node, ddlSchema, tableName });
+      }
+    }
+    if (missing.length === 0 || extra.length === 0) {
+      return { calls, consumed };
+    }
+
+    const byName = (a: IndexFinding, b: IndexFinding): number =>
+      a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0;
+    // DDL emission must stay unqualified for the unbound namespace, exactly
+    // like the per-issue mapping's `emissionSchemaName`.
+    const emissionSchema = (ddlSchema: string): string =>
+      resolveNamespaceIdForDdlSchema(options.contract, ddlSchema) === UNBOUND_NAMESPACE_ID
+        ? UNBOUND_NAMESPACE_ID
+        : ddlSchema;
+    const pairingKey = (finding: IndexFinding, hash: string): string =>
+      JSON.stringify([finding.ddlSchema, finding.tableName, hash]);
+    const rename = (missingFinding: IndexFinding, candidate: IndexFinding): void => {
+      consumed.add(missingFinding.issue);
+      consumed.add(candidate.issue);
+      calls.push(
+        new RenameIndexCall(
+          emissionSchema(missingFinding.ddlSchema),
+          missingFinding.tableName,
+          candidate.node.name,
+          missingFinding.node.name,
+        ),
+      );
+    };
+
+    const sortedMissing = [...missing].sort(byName);
+
+    const extrasByHash = new Map<string, IndexFinding[]>();
+    for (const finding of extra) {
+      const parsed = parseWireName(finding.node.name);
+      if (parsed === undefined) continue;
+      const key = pairingKey(finding, parsed.hash);
+      const group = extrasByHash.get(key) ?? [];
+      group.push(finding);
+      extrasByHash.set(key, group);
+    }
+    for (const group of extrasByHash.values()) {
+      group.sort(byName);
+    }
+    for (const missingFinding of sortedMissing) {
+      const parsed = parseWireName(missingFinding.node.name);
+      if (parsed === undefined) continue;
+      const candidate = extrasByHash.get(pairingKey(missingFinding, parsed.hash))?.shift();
+      if (candidate === undefined) continue;
+      rename(missingFinding, candidate);
+    }
+
+    const sortedExtras = [...extra].sort(byName);
+    for (const missingFinding of sortedMissing) {
+      if (consumed.has(missingFinding.issue)) continue;
+      if (missingFinding.node.prefix === undefined) continue;
+      const candidate = sortedExtras.find(
+        (extraFinding) =>
+          !consumed.has(extraFinding.issue) &&
+          extraFinding.ddlSchema === missingFinding.ddlSchema &&
+          extraFinding.tableName === missingFinding.tableName &&
+          missingFinding.node.contentEquals(extraFinding.node, {
+            columnPresence: 'matching',
+            bodies: 'verbatim',
+          }),
+      );
+      if (candidate === undefined) continue;
+      rename(missingFinding, candidate);
+    }
+
+    return { calls, consumed };
+  }
+
   /**
    * Maps the RLS policy presence findings of the one combined tree diff
    * (`buildPostgresPlanDiff`, already ownership-filtered) into
@@ -404,7 +562,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     if (allowsWidening) {
       const extrasByGroup = new Map<string, PolicyFinding[]>();
       for (const finding of extra) {
-        const parsed = parseRlsPolicyWireName(finding.node.name);
+        const parsed = parseWireName(finding.node.name);
         if (parsed === undefined) continue;
         const key = pairingKey(finding, parsed.hash);
         const group = extrasByGroup.get(key) ?? [];
@@ -419,7 +577,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0,
       );
       for (const missingFinding of sortedMissing) {
-        const parsed = parseRlsPolicyWireName(missingFinding.node.name);
+        const parsed = parseWireName(missingFinding.node.name);
         if (parsed === undefined) continue;
         const candidates = extrasByGroup.get(pairingKey(missingFinding, parsed.hash));
         const candidate = candidates?.shift();

package/src/core/migrations/postgres-migration.ts

@@ -34,6 +34,7 @@ import {
   DropPostgresRlsPolicyCall,
   DropTableCall,
   EnableRowLevelSecurityCall,
+  RenameIndexCall,
   RenamePostgresRlsPolicyCall,
   SetDefaultCall,
   SetNotNullCall,
@@ -392,22 +393,39 @@ export abstract class PostgresMigration<
     );
   }
 
-  protected createIndex(options: {
-    readonly schema: string;
-    readonly table: string;
-    readonly index: string;
-    readonly columns: readonly string[];
-    readonly extras?: CreateIndexExtras;
-  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+  protected createIndex(
+    options: {
+      readonly schema: string;
+      readonly table: string;
+      readonly index: string;
+      readonly extras?: CreateIndexExtras;
+    } & (
+      | { readonly columns: readonly string[]; readonly expression?: never }
+      | { readonly expression: string; readonly columns?: never }
+    ),
+  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
     return new CreateIndexCall(
       options.schema,
       options.table,
       options.index,
-      options.columns,
+      options.columns !== undefined
+        ? { columns: options.columns }
+        : { expression: options.expression },
       options.extras,
     ).toOp(this.controlAdapterFor('createIndex'));
   }
 
+  protected renameIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly from: string;
+    readonly to: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    return new RenameIndexCall(options.schema, options.table, options.from, options.to).toOp(
+      this.controlAdapterFor('renameIndex'),
+    );
+  }
+
   protected dropIndex(options: {
     readonly schema: string;
     readonly table: string;

package/src/core/migrations/render-ops.ts

@@ -6,6 +6,7 @@ import type {
 } from '@prisma-next/framework-components/control';
 import { blindCast } from '@prisma-next/utils/casts';
 import { isThenable } from '@prisma-next/utils/promise';
+import { postgresError } from '../errors';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
@@ -23,8 +24,10 @@ function assertPostgresOp(op: MigrationPlanOperation, callFactoryName: string):
     'op.target is present on concrete SqlMigrationPlanOperation but absent on the framework MigrationPlanOperation base'
   >(op).target?.id;
   if (targetId !== 'postgres') {
-    throw new Error(
+    throw postgresError(
+      'MIGRATION.TARGET_MISMATCH',
       `renderOps: expected postgres op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,
+      { meta: { opId: op.id, targetId: String(targetId), factoryName: callFactoryName } },
     );
   }
 }