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

package/src/core/codec-helpers.ts

@@ -7,6 +7,7 @@
  */
 
 import type { JsonValue } from '@prisma-next/contract/types';
+import { postgresError } from './errors';
 
 export function renderLength(
   typeName: string,
@@ -17,8 +18,10 @@ export function renderLength(
     return undefined;
   }
   if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {
-    throw new Error(
+    throw postgresError(
+      'RUNTIME.TYPE_PARAMS_INVALID',
       `renderOutputType: expected integer "length" in typeParams for ${typeName}, got ${String(length)}`,
+      { meta: { nativeType: typeName, param: 'length', received: String(length) } },
     );
   }
   return `${typeName}<${length}>`;
@@ -34,8 +37,10 @@ export function renderPrecision(typeName: string, typeParams: Record<string, unk
     !Number.isFinite(precision) ||
     !Number.isInteger(precision)
   ) {
-    throw new Error(
+    throw postgresError(
+      'RUNTIME.TYPE_PARAMS_INVALID',
       `renderOutputType: expected integer "precision" in typeParams for ${typeName}, got ${String(precision)}`,
+      { meta: { nativeType: typeName, param: 'precision', received: String(precision) } },
     );
   }
   return `${typeName}<${precision}>`;
@@ -57,15 +62,19 @@ export const pgNumericRenderOutputType = (typeParams: {
     !Number.isFinite(precision) ||
     !Number.isInteger(precision)
   ) {
-    throw new Error(
+    throw postgresError(
+      'RUNTIME.TYPE_PARAMS_INVALID',
       `renderOutputType: expected integer "precision" in typeParams for Numeric, got ${String(precision)}`,
+      { meta: { nativeType: 'Numeric', param: 'precision', received: String(precision) } },
     );
   }
   const scale = typeParams.scale;
   if (scale === undefined) return `Numeric<${precision}>`;
   if (typeof scale !== 'number' || !Number.isFinite(scale) || !Number.isInteger(scale)) {
-    throw new Error(
+    throw postgresError(
+      'RUNTIME.TYPE_PARAMS_INVALID',
       `renderOutputType: expected integer "scale" in typeParams for Numeric, got ${String(scale)}`,
+      { meta: { nativeType: 'Numeric', param: 'scale', received: String(scale) } },
     );
   }
   return `Numeric<${precision}, ${scale}>`;
@@ -78,14 +87,26 @@ const ISO_8601_TIMESTAMPTZ =
 export const pgTimestampEncodeJson = (value: Date): JsonValue => value.toISOString().slice(0, -1);
 export const pgTimestampDecodeJson = (json: JsonValue): Date => {
   if (typeof json !== 'string') {
-    throw new Error(`Expected ISO date string for pg/timestamp@1, got ${typeof json}`);
+    throw postgresError(
+      'RUNTIME.DECODE_FAILED',
+      `Expected ISO date string for pg/timestamp@1, got ${typeof json}`,
+      { meta: { codecId: 'pg/timestamp@1', received: typeof json } },
+    );
   }
   if (!ISO_8601_TIMESTAMP.test(json)) {
-    throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
+    throw postgresError(
+      'RUNTIME.DECODE_FAILED',
+      `Invalid ISO date string for pg/timestamp@1: ${json}`,
+      { meta: { codecId: 'pg/timestamp@1', received: json } },
+    );
   }
   const date = new Date(`${json}Z`);
   if (Number.isNaN(date.getTime())) {
-    throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
+    throw postgresError(
+      'RUNTIME.DECODE_FAILED',
+      `Invalid ISO date string for pg/timestamp@1: ${json}`,
+      { meta: { codecId: 'pg/timestamp@1', received: json } },
+    );
   }
   return date;
 };
@@ -94,14 +115,26 @@ export const pgTimestamptzEncodeJson = (value: Date): JsonValue =>
   value.toISOString().replace(/Z$/, '+00:00');
 export const pgTimestamptzDecodeJson = (json: JsonValue): Date => {
   if (typeof json !== 'string') {
-    throw new Error(`Expected ISO date string for pg/timestamptz@1, got ${typeof json}`);
+    throw postgresError(
+      'RUNTIME.DECODE_FAILED',
+      `Expected ISO date string for pg/timestamptz@1, got ${typeof json}`,
+      { meta: { codecId: 'pg/timestamptz@1', received: typeof json } },
+    );
   }
   if (!ISO_8601_TIMESTAMPTZ.test(json)) {
-    throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
+    throw postgresError(
+      'RUNTIME.DECODE_FAILED',
+      `Invalid ISO date string for pg/timestamptz@1: ${json}`,
+      { meta: { codecId: 'pg/timestamptz@1', received: json } },
+    );
   }
   const date = new Date(json);
   if (Number.isNaN(date.getTime())) {
-    throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
+    throw postgresError(
+      'RUNTIME.DECODE_FAILED',
+      `Invalid ISO date string for pg/timestamptz@1: ${json}`,
+      { meta: { codecId: 'pg/timestamptz@1', received: json } },
+    );
   }
   return date;
 };
@@ -141,11 +174,17 @@ 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}`);
+    throw postgresError(
+      'RUNTIME.DECODE_FAILED',
+      `Expected date string for pg/date@1, got ${typeof json}`,
+      { meta: { codecId: 'pg/date@1', received: typeof json } },
+    );
   }
   const match = ISO_8601_DATE.exec(json);
   if (!match) {
-    throw new Error(`Invalid date string for pg/date@1: ${json}`);
+    throw postgresError('RUNTIME.DECODE_FAILED', `Invalid date string for pg/date@1: ${json}`, {
+      meta: { codecId: 'pg/date@1', received: json },
+    });
   }
   const [, yearText, monthText, dayText] = match;
   const year = Number(yearText);
@@ -153,7 +192,9 @@ export const pgDateDecodeJson = (json: JsonValue): Date => {
   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}`);
+    throw postgresError('RUNTIME.DECODE_FAILED', `Invalid date string for pg/date@1: ${json}`, {
+      meta: { codecId: 'pg/date@1', received: json },
+    });
   }
   return date;
 };
@@ -168,19 +209,31 @@ export const pgByteaEncodeJson = (value: Uint8Array): JsonValue =>
 
 export const pgByteaDecodeJson = (value: JsonValue): Uint8Array => {
   if (typeof value !== 'string' || !value.startsWith('\\x')) {
-    throw new Error(`Expected Postgres bytea hex text to start with "\\x"`);
+    throw postgresError(
+      'RUNTIME.DECODE_FAILED',
+      `Expected Postgres bytea hex text to start with "\\x"`,
+      { meta: { codecId: 'pg/bytea@1' } },
+    );
   }
 
   const hex = value.slice(2);
   if (hex.length % 2 !== 0) {
-    throw new Error(`Invalid Postgres bytea hex text length: ${hex.length}`);
+    throw postgresError(
+      'RUNTIME.DECODE_FAILED',
+      `Invalid Postgres bytea hex text length: ${hex.length}`,
+      { meta: { codecId: 'pg/bytea@1', received: hex.length } },
+    );
   }
 
   const bytes = new Uint8Array(hex.length / 2);
   for (let offset = 0; offset < hex.length; offset += 2) {
     const pair = hex.slice(offset, offset + 2);
     if (!/^[0-9a-fA-F]{2}$/.test(pair)) {
-      throw new Error(`Invalid Postgres bytea hex pair "${pair}" at offset ${offset}`);
+      throw postgresError(
+        'RUNTIME.DECODE_FAILED',
+        `Invalid Postgres bytea hex pair "${pair}" at offset ${offset}`,
+        { meta: { codecId: 'pg/bytea@1', received: pair } },
+      );
     }
     bytes[offset / 2] = Number.parseInt(pair, 16);
   }

package/src/core/codec-type-map.ts

@@ -21,6 +21,7 @@ import {
   pgBoolDescriptor,
   pgByteaDescriptor,
   pgCharDescriptor,
+  pgDateDescriptor,
   pgEnumDescriptor,
   pgFloat4Descriptor,
   pgFloat8Descriptor,
@@ -63,6 +64,7 @@ export const codecDescriptorMap = {
   float4: pgFloat4Descriptor,
   float8: pgFloat8Descriptor,
   numeric: pgNumericDescriptor,
+  date: pgDateDescriptor,
   timestamp: pgTimestampDescriptor,
   timestamptz: pgTimestamptzDescriptor,
   time: pgTimeDescriptor,

package/src/core/codecs.ts

@@ -92,6 +92,7 @@ import {
   PG_VARBIT_CODEC_ID,
   PG_VARCHAR_CODEC_ID,
 } from './codec-ids';
+import { postgresError } from './errors';
 import { DEFAULT_NAMESPACE_ID } from './namespace-ids';
 import { PostgresNativeEnum } from './postgres-native-enum';
 
@@ -218,18 +219,26 @@ export class PgEnumCodec extends CodecImpl<
   }
 }
 
-type PgEnumParams = { readonly typeName: string };
+export type PgEnumParams = { readonly typeName: string };
+
+/**
+ * Narrows codec `typeParams` to {@link PgEnumParams} — the shape that binds a
+ * column to a named database type (a native enum's `CREATE TYPE` name).
+ */
+export function isPgEnumParams(value: unknown): value is PgEnumParams {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    !Array.isArray(value) &&
+    'typeName' in value &&
+    typeof value.typeName === 'string'
+  );
+}
 
 const pgEnumParamsSchema = arktype({
   typeName: 'string',
 }) satisfies StandardSchemaV1<PgEnumParams>;
 
-function isJsonObject(
-  value: JsonValue | undefined,
-): value is { readonly [key: string]: JsonValue } {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
 export class PgEnumDescriptor extends CodecDescriptorImpl<PgEnumParams> {
   override readonly codecId = PG_ENUM_CODEC_ID;
   override readonly traits = ['equality', 'order', 'textual'] as const;
@@ -240,10 +249,8 @@ export class PgEnumDescriptor extends CodecDescriptorImpl<PgEnumParams> {
     return renderTsLiteral(value);
   }
   override metaFor(typeParams: JsonValue | undefined): CodecMeta | undefined {
-    if (!isJsonObject(typeParams)) return this.meta;
-    const typeName = typeParams['typeName'];
-    return typeof typeName === 'string'
-      ? { db: { sql: { postgres: { nativeType: typeName } } } }
+    return isPgEnumParams(typeParams)
+      ? { db: { sql: { postgres: { nativeType: typeParams.typeName } } } }
       : this.meta;
   }
   override factory(_params: PgEnumParams): (ctx: CodecInstanceContext) => PgEnumCodec {
@@ -626,13 +633,21 @@ export class PgNumericCodec extends CodecImpl<
   encodeJson(value: string): JsonValue {
     const number = Number(value);
     if (!Number.isFinite(number)) {
-      throw new TypeError('pg/numeric@1 database JSON value must be a finite number');
+      throw postgresError(
+        'RUNTIME.ENCODE_FAILED',
+        'pg/numeric@1 database JSON value must be a finite number',
+        { meta: { codecId: 'pg/numeric@1', received: value } },
+      );
     }
     return number;
   }
   decodeJson(json: JsonValue): string {
     if (typeof json !== 'number') {
-      throw new TypeError('pg/numeric@1 database JSON value must be a number');
+      throw postgresError(
+        'RUNTIME.DECODE_FAILED',
+        'pg/numeric@1 database JSON value must be a number',
+        { meta: { codecId: 'pg/numeric@1', received: typeof json } },
+      );
     }
     return pgNumericDecode(json);
   }
@@ -1336,7 +1351,7 @@ 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.
+  // PSL `Date` pins this codec by ID rather than activating a second target-type mapping.
   pgDateDescriptor,
   pgTimestampDescriptor,
   pgTimestamptzDescriptor,

package/src/core/ddl/nodes.ts

@@ -73,6 +73,9 @@ export interface PostgresDdlVisitor<R> {
   createPolicy(node: PostgresCreatePolicy): R;
   dropPolicy(node: PostgresDropPolicy): R;
   alterPolicyRename(node: PostgresAlterPolicyRename): R;
+  createIndex(node: PostgresCreateIndex): R;
+  dropIndex(node: PostgresDropIndex): R;
+  alterIndexRename(node: PostgresAlterIndexRename): R;
   disableRowLevelSecurity(node: PostgresDisableRowLevelSecurity): R;
 }
 
@@ -284,6 +287,104 @@ export class PostgresAlterPolicyRename extends PostgresDdlNode {
   }
 }
 
+/**
+ * The element list between the parens of CREATE INDEX: either a column
+ * tuple (each identifier quoted by the renderer) or one opaque expression
+ * string covering the entire list, inserted verbatim — the same opaque-SQL
+ * stance as RLS policy predicates (ADR 234).
+ */
+export type DdlIndexElements =
+  | { readonly columns: readonly string[] }
+  | { readonly expression: string };
+
+export class PostgresCreateIndex extends PostgresDdlNode {
+  readonly kind = 'create-index' as const;
+  /** Absent ⇔ unqualified (the unbound namespace — `search_path` decides). */
+  readonly schema: string | undefined;
+  readonly table: string;
+  readonly name: string;
+  readonly unique: boolean;
+  readonly elements: DdlIndexElements;
+  readonly type: string | undefined;
+  readonly options: Record<string, unknown> | undefined;
+  /**
+   * Partial-index predicate (WHERE body, without the keyword). Inserted
+   * verbatim, never quoted or escaped.
+   */
+  readonly where: string | undefined;
+
+  constructor(options: {
+    readonly schema: string | undefined;
+    readonly table: string;
+    readonly name: string;
+    readonly unique: boolean;
+    readonly elements: DdlIndexElements;
+    readonly type: string | undefined;
+    readonly options: Record<string, unknown> | undefined;
+    readonly where: string | undefined;
+  }) {
+    super();
+    this.schema = options.schema;
+    this.table = options.table;
+    this.name = options.name;
+    this.unique = options.unique;
+    this.elements =
+      'columns' in options.elements
+        ? { columns: Object.freeze([...options.elements.columns]) }
+        : { expression: options.elements.expression };
+    this.type = options.type;
+    this.options = options.options;
+    this.where = options.where;
+    this.freeze();
+  }
+
+  override accept<R>(visitor: PostgresDdlVisitor<R>): R {
+    return visitor.createIndex(this);
+  }
+}
+
+export class PostgresDropIndex extends PostgresDdlNode {
+  readonly kind = 'drop-index' as const;
+  /** Absent ⇔ unqualified (the unbound namespace). */
+  readonly schema: string | undefined;
+  readonly name: string;
+
+  constructor(options: { readonly schema: string | undefined; readonly name: string }) {
+    super();
+    this.schema = options.schema;
+    this.name = options.name;
+    this.freeze();
+  }
+
+  override accept<R>(visitor: PostgresDdlVisitor<R>): R {
+    return visitor.dropIndex(this);
+  }
+}
+
+export class PostgresAlterIndexRename extends PostgresDdlNode {
+  readonly kind = 'alter-index-rename' as const;
+  /** Absent ⇔ unqualified (the unbound namespace). */
+  readonly schema: string | undefined;
+  readonly from: string;
+  readonly to: string;
+
+  constructor(options: {
+    readonly schema: string | undefined;
+    readonly from: string;
+    readonly to: string;
+  }) {
+    super();
+    this.schema = options.schema;
+    this.from = options.from;
+    this.to = options.to;
+    this.freeze();
+  }
+
+  override accept<R>(visitor: PostgresDdlVisitor<R>): R {
+    return visitor.alterIndexRename(this);
+  }
+}
+
 export class PostgresDisableRowLevelSecurity extends PostgresDdlNode {
   readonly kind = 'disable-row-level-security' as const;
   readonly schema: string;
@@ -310,4 +411,7 @@ export type AnyPostgresDdlNode =
   | PostgresCreatePolicy
   | PostgresDropPolicy
   | PostgresAlterPolicyRename
+  | PostgresCreateIndex
+  | PostgresDropIndex
+  | PostgresAlterIndexRename
   | PostgresDisableRowLevelSecurity;

package/src/core/errors.ts

@@ -1,4 +1,34 @@
 import { CliStructuredError } from '@prisma-next/errors/control';
+import type { StructuredError, StructuredErrorOptions } from '@prisma-next/utils/structured-error';
+import { structuredError } from '@prisma-next/utils/structured-error';
+
+export type PostgresTargetErrorCode =
+  | 'CONTRACT.CODEC_DESCRIPTOR_MISSING'
+  | 'CONTRACT.DEFAULT_INVALID'
+  | 'CONTRACT.ENTITY_KIND_INVALID'
+  | 'CONTRACT.IDENTIFIER_INVALID'
+  | 'CONTRACT.INDEX_INVALID'
+  | 'CONTRACT.INFER_UNSUPPORTED'
+  | 'CONTRACT.MODEL_UNKNOWN'
+  | 'CONTRACT.NAME_DUPLICATE'
+  | 'CONTRACT.NATIVE_TYPE_INVALID'
+  | 'CONTRACT.PACK_CONTRIBUTION_INVALID'
+  | 'CONTRACT.POLICY_INVALID'
+  | 'CONTRACT.ROLE_INVALID'
+  | 'MIGRATION.CONTRACT_SPACE_VIOLATION'
+  | 'MIGRATION.POSTGRES_CONTROL_STACK_MISSING'
+  | 'MIGRATION.TARGET_MISMATCH'
+  | 'RUNTIME.DECODE_FAILED'
+  | 'RUNTIME.ENCODE_FAILED'
+  | 'RUNTIME.TYPE_PARAMS_INVALID';
+
+export function postgresError(
+  code: PostgresTargetErrorCode,
+  message: string,
+  options?: StructuredErrorOptions,
+): StructuredError {
+  return structuredError(code, message, options);
+}
 
 /**
  * A `PostgresMigration` operation that needs the materialized control adapter

package/src/core/migrations/column-ddl-rendering.ts

@@ -5,6 +5,7 @@ import * as contractFree from '@prisma-next/sql-relational-core/contract-free';
 import type { SqlColumnDefaultIR, SqlColumnIR } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { InternalError } from '@prisma-next/utils/internal-error';
 import { postgresDefaultToDdlColumnDefault } from './op-factory-call';
 import { buildColumnDefaultSql, buildColumnTypeSql } from './planner-ddl-builders';
 import { resolveIdentityValue } from './planner-identity-values';
@@ -29,7 +30,7 @@ function columnLike(
   'nativeType' | 'codecId' | 'nullable' | 'many' | 'typeParams' | 'typeRef' | 'default'
 > {
   if (column.codecRef === undefined || column.codecBaseNativeType === undefined) {
-    throw new Error(
+    throw new InternalError(
       `columnLike: expected column "${column.name}" carries no codec identity — the expected tree must be derived via contractToSchemaIR for planning`,
     );
   }

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

@@ -10,6 +10,7 @@ import {
   SqlUniqueIR,
 } from '@prisma-next/sql-schema-ir/types';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { postgresError } from '../errors';
 import type { PostgresRlsPolicy } from '../postgres-rls-policy';
 import type { PostgresContract } from '../postgres-schema';
 import { isPostgresSchema } from '../postgres-schema';
@@ -192,18 +193,30 @@ export function contractToPostgresDatabaseSchemaNode(
             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 indexes = sqlTable.indexes.map((i) => {
+        const base = {
+          name: i.name,
+          prefix: i.prefix,
+          where: i.where,
+          unique: i.unique,
+          partial: i.partial,
+          type: i.type,
+          options: i.options,
+          annotations: i.annotations,
+          // Expression indexes stamp chains to every column of the table —
+          // the same over-approximation the family derivation uses.
+          dependsOn: columnDependsOn(
+            ddlSchema,
+            tableName,
+            i.columns ?? Object.keys(sqlTable.columns),
+          ),
+        };
+        return new SqlIndexIR(
+          i.expression !== undefined
+            ? { ...base, expression: i.expression }
+            : { ...base, columns: i.columns ?? [] },
+        );
+      });
       const primaryKey =
         sqlTable.primaryKey !== undefined
           ? new PrimaryKey({
@@ -231,14 +244,25 @@ export function contractToPostgresDatabaseSchemaNode(
     for (const [tableName, tablePolicies] of policiesByTable) {
       if (!(tableName in tables)) {
         const policyName = tablePolicies[0]?.name ?? '(unknown)';
-        throw new Error(
+        throw postgresError(
+          'CONTRACT.POLICY_INVALID',
           `contract-to-postgres-database-schema-node: policy "${policyName}" references table "${tableName}" not present in namespace "${ddlSchema}"`,
+          { meta: { policyName, tableName, namespaceId: ddlSchema, reason: 'table-missing' } },
         );
       }
       if (!Object.hasOwn(ns.rls, tableName)) {
         const policyPrefix = tablePolicies[0]?.prefix ?? '(unknown)';
-        throw new Error(
+        throw postgresError(
+          'CONTRACT.POLICY_INVALID',
           `contract-to-postgres-database-schema-node: policy "${policyPrefix}" targets table "${tableName}" in namespace "${ddlSchema}", which is not RLS-controlled. Mark the model with @@rls (entries.rls["${tableName}"]) or remove the policy.`,
+          {
+            meta: {
+              policyName: policyPrefix,
+              tableName,
+              namespaceId: ddlSchema,
+              reason: 'table-not-rls-controlled',
+            },
+          },
         );
       }
     }

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

@@ -30,7 +30,6 @@ 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';
 import * as contractFree from '@prisma-next/sql-relational-core/contract-free';
-import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
 import {
   RelationalSchemaNodeKind,
   type SqlColumnDefaultIR,
@@ -200,6 +199,7 @@ function classifyCall(call: PostgresOpFactoryCall): CallCategory {
     case 'addUnique':
       return 'unique';
     case 'createIndex':
+    case 'renameIndex':
       return 'index';
     case 'addForeignKey':
       return 'foreignKey';
@@ -248,6 +248,7 @@ function conflictKindForCall(call: PostgresOpFactoryCall): SqlPlannerConflict['k
     case 'dropConstraint':
       return 'foreignKeyConflict';
     case 'createIndex':
+    case 'renameIndex':
     case 'dropIndex':
       return 'indexIncompatible';
     default:
@@ -263,6 +264,7 @@ function locationForCall(call: PostgresOpFactoryCall): SqlPlannerConflict['locat
     tableName?: string;
     columnName?: string;
     indexName?: string;
+    newIndexName?: string;
     constraintName?: string;
     typeName?: string;
   };
@@ -281,7 +283,10 @@ function locationForCall(call: PostgresOpFactoryCall): SqlPlannerConflict['locat
     location.entityName = anyCall.typeName;
   }
   if (anyCall.columnName) location.column = anyCall.columnName;
+  // A rename call carries old/new index names; the new name is the index's
+  // contract-side identity, so it is the conflict location.
   if (anyCall.indexName) location.index = anyCall.indexName;
+  else if (anyCall.newIndexName) location.index = anyCall.newIndexName;
   if (anyCall.constraintName) location.constraint = anyCall.constraintName;
   return Object.keys(location).length > 0 ? (location as SqlPlannerConflictLocation) : undefined;
 }
@@ -476,11 +481,7 @@ function buildCreateTableCallsFromNode(
     ),
   ];
   for (const index of table.indexes) {
-    const indexName = index.name ?? defaultIndexName(table.name, index.columns);
-    const extras: { type?: string; options?: Record<string, unknown> } = {};
-    if (index.type !== undefined) extras.type = index.type;
-    if (index.options !== undefined) extras.options = index.options;
-    calls.push(new CreateIndexCall(schemaName, table.name, indexName, [...index.columns], extras));
+    calls.push(createIndexCallFromNode(index, schemaName, table.name));
   }
   for (const fk of table.foreignKeys) {
     calls.push(new AddForeignKeyCall(schemaName, table.name, fkSpecFromNode(fk, table.name)));
@@ -808,6 +809,37 @@ function mapUniqueNodeIssue(
   return notOk(nodeConflict('indexIncompatible', issue.path.join('/')));
 }
 
+/**
+ * The CreateIndexCall for a name-identified index node: the node's own name
+ * verbatim, its element list (column tuple or opaque expression), and the
+ * unique/type/options/where attributes carried through.
+ */
+export function createIndexCallFromNode(
+  index: SqlIndexIR,
+  schemaName: string,
+  tableName: string,
+): CreateIndexCall {
+  const extras: {
+    type?: string;
+    options?: Record<string, unknown>;
+    where?: string;
+    unique?: boolean;
+  } = {};
+  if (index.type !== undefined) extras.type = index.type;
+  if (index.options !== undefined) extras.options = index.options;
+  if (index.where !== undefined) extras.where = index.where;
+  if (index.unique) extras.unique = true;
+  return new CreateIndexCall(
+    schemaName,
+    tableName,
+    index.name,
+    index.columns !== undefined
+      ? { columns: [...index.columns] }
+      : { expression: index.expression ?? '' },
+    extras,
+  );
+}
+
 function mapIndexNodeIssue(
   issue: SchemaDiffIssue,
   schemaName: string,
@@ -818,19 +850,14 @@ function mapIndexNodeIssue(
       SqlIndexIR,
       'a not-found index issue always carries the expected index node'
     >(issue.expected);
-    const indexName = index.name ?? defaultIndexName(tableName, index.columns);
-    const extras: { type?: string; options?: Record<string, unknown> } = {};
-    if (index.type !== undefined) extras.type = index.type;
-    if (index.options !== undefined) extras.options = index.options;
-    return ok([new CreateIndexCall(schemaName, tableName, indexName, [...index.columns], extras)]);
+    return ok([createIndexCallFromNode(index, schemaName, tableName)]);
   }
   if (issueOutcome(issue) === 'not-expected') {
     const index = blindCast<
       SqlIndexIR,
       'a not-expected index issue always carries the actual index node'
     >(issue.actual);
-    const indexName = index.name ?? defaultIndexName(tableName, index.columns);
-    return ok([new DropIndexCall(schemaName, tableName, indexName)]);
+    return ok([new DropIndexCall(schemaName, tableName, index.name)]);
   }
   return notOk(nodeConflict('indexIncompatible', issue.path.join('/')));
 }