fix(sql-schema-ir): normalize the btree default at SqlIndexIR construction

An authored type: "btree" drifted on verify: introspection dropped the
default access method before node construction while contract derivation
passed it through, so isEqualTo's strict type compare failed on the exact
spelling the ciphers scenario uses. The btree-to-undefined normalization
now lives in the SqlIndexIR constructor — every derivation path (contract
tree, introspection, flat family tree) constructs through it, making both
sides symmetric by definition; the adapter's pre-construction filter is
removed so the rule has one home. The contract JSON and the wire-name
content hash keep the authored spelling, so a btree-typed index and an
untyped index remain distinct wire names, and the planner's DDL renders
no USING clause for the default method. Phase-2 content pairing inherits
the symmetry (pinned by a planner test), verify is pinned clean at
integration level, and the ciphers e2e now authors the literal
type: "btree" spelling alongside the hash-typed registry proof.

Signed-off-by: willbot <w.a.madden+machine@gmail.com>
Signed-off-by: Will Madden <madden@prisma.io>

Author: wmadden-electric

packages/2-sql/1-core/schema-ir/src/ir/sql-index-ir.ts

@@ -32,8 +32,9 @@ export type SqlIndexElements =
 
 /**
  * Every non-element field is a required key. Values that may legitimately
- * be absent (an exact-named index's prefix, a default-method type) are
- * typed `| undefined` instead of optional, so each construction site
+ * be absent (an exact-named index's prefix, the btree→undefined type
+ * normalization) are typed `| undefined` instead of optional, so each
+ * construction site
  * states the absence explicitly rather than omitting the key silently.
  * Undefined values still produce an instance without the property.
  */
@@ -132,7 +133,8 @@ export class SqlIndexIR extends SqlSchemaIRNode implements DiffableNode {
     if (input.columns !== undefined) this.columns = input.columns;
     if (input.expression !== undefined) this.expression = input.expression;
     if (input.where !== undefined) this.where = input.where;
-    if (input.type !== undefined) this.type = input.type;
+    const normalizedType = normalizeIndexType(input.type);
+    if (normalizedType !== undefined) this.type = normalizedType;
     if (input.options !== undefined) this.options = input.options;
     if (input.annotations !== undefined) this.annotations = input.annotations;
     defineNonEnumerable(this, 'dependsOn', input.dependsOn);
@@ -221,12 +223,15 @@ export class SqlIndexIR extends SqlSchemaIRNode implements DiffableNode {
 }
 
 /**
- * Comparison-side normalization seam: the default access method (`btree` in
- * every supported SQL target) compares as absent, so an authored
- * `type: "btree"` and a default-method introspected index (whose type the
- * adapter or constructor normalized away) are equal. Applied by
- * {@link SqlIndexIR.contentEquals} only — the wire-name hash keeps the
- * authored spelling.
+ * The btree-default normalization seam: the default access method (`btree`
+ * in every supported SQL target) normalizes to absent. Applied at
+ * construction — every derivation path (contract tree, introspection, flat
+ * family tree) builds through the class, so both compare sides are
+ * symmetric by definition — and again inside
+ * {@link SqlIndexIR.contentEquals} so the relation holds for any input.
+ * The contract JSON and the wire-name content hash keep the authored
+ * spelling: `@@index([a], type: "btree")` and `@@index([a])` are distinct
+ * wire names whose shared content converges via a phase-2 rename.
  */
 function normalizeIndexType(type: string | undefined): string | undefined {
   return type === 'btree' ? undefined : type;

packages/2-sql/1-core/schema-ir/test/sql-index-ir.test.ts

@@ -104,6 +104,25 @@ describe('SqlIndexIR', () => {
     });
   });
 
+  describe('btree normalization at construction', () => {
+    it("normalizes type 'btree' to absent (both derivation paths construct here)", () => {
+      const authored = managed({ name: NAME, columns: ['email'], type: 'btree' });
+      expect(authored.type).toBeUndefined();
+      expect(Object.hasOwn(authored, 'type')).toBe(false);
+    });
+
+    it('keeps non-default types', () => {
+      const hashTyped = managed({ name: NAME, columns: ['email'], type: 'hash' });
+      expect(hashTyped.type).toBe('hash');
+    });
+
+    it("two 'btree' nodes are equal", () => {
+      const a = managed({ name: NAME, columns: ['email'], type: 'btree' });
+      const b = exact({ name: NAME, columns: ['email'], type: 'btree' });
+      expect(a.isEqualTo(b)).toBe(true);
+    });
+  });
+
   describe('contentEquals — the single node-owned relation', () => {
     it("a boolean option value equals its catalog reprint ('on'/'off')", () => {
       const authored = managed({ name: NAME, columns: ['email'], options: { fastupdate: true } });
@@ -120,7 +139,7 @@ describe('SqlIndexIR', () => {
       expect(authoredOff.isEqualTo(reprint)).toBe(false);
     });
 
-    it("an authored type 'btree' equals a normalized-away type through the comparison seam", () => {
+    it("an authored type 'btree' equals a normalized-away type through the seam", () => {
       const authored = managed({ name: NAME, columns: ['email'], type: 'btree' });
       const live = exact({ name: NAME, columns: ['email'] });
       expect(authored.isEqualTo(live)).toBe(true);

packages/3-targets/3-targets/postgres/src/core/psl-infer/infer-psl-contract.ts

@@ -1015,8 +1015,8 @@ function buildRelationField(
 
 /**
  * `indexType` carries a non-default index access method (e.g. `hash`) —
- * introspection already drops `btree` (the Postgres default) to `undefined`
- * (see the postgres control adapter), so this only ever fires for a real
+ * `SqlIndexIR`'s constructor drops `btree` (the default) to `undefined`,
+ * so this only ever fires for a real
  * non-default index, matching the same `@@index(type: "...")` argument
  * `contract-to-schema-ir.ts` reads back into the FK-backing-index
  * expectation `db verify` checks against the live database.

packages/3-targets/3-targets/postgres/test/migrations/index-rename-planner.test.ts

@@ -301,6 +301,16 @@ describe('phase 2 — content pairing (exact→managed convergence)', () => {
     ]);
   });
 
+  it("an authored 'btree' index content-pairs with a typeless live index", async () => {
+    const contract = buildContract([
+      managedIndex('items_email_idx', 'ab12cd34', { type: 'btree' }),
+    ]);
+    const schema = actualSchema([{ name: 'legacy_email_idx', columns: ['email'] }]);
+
+    const opIds = await planOpIds(contract, schema, ALL_CLASSES_POLICY);
+    expect(opIds).toEqual([`index.public.${TABLE_NAME}.legacy_email_idx.rename`]);
+  });
+
   it('an exact-named missing index never content-pairs (managed only)', async () => {
     const contract = buildContract([
       { name: 'items_email_exact', columns: ['email'], unique: false },

packages/3-targets/6-adapters/postgres/src/core/control-adapter.ts

@@ -1164,10 +1164,9 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         if (existing) {
           existing.elements.push({ attname: idxRow.attname, elementDef: idxRow.element_def });
         } else {
-          // Drop btree (the Postgres default) so a contract index without an
-          // explicit type matches a default-method introspected index without
-          // forcing DROP+CREATE on every plan.
-          const indexType = idxRow.amname && idxRow.amname !== 'btree' ? idxRow.amname : undefined;
+          // SqlIndexIR's constructor normalizes the btree default to absent
+          // for both derivation paths.
+          const indexType = idxRow.amname ?? undefined;
           const indexOptions = parsePgReloptions(idxRow.reloptions, idxRow.indexname);
           indexesMap.set(idxRow.indexname, {
             name: idxRow.indexname,

test/integration/test/cli-journeys/expression-index-migration.e2e.test.ts

@@ -4,7 +4,9 @@
  * and a body edit under the same name converges as create + drop.
  *
  * A `.prisma` contract carries the Cipherstash-style index
- * (`@@index(expression: "eql_v3.eq_term(email)", name: "users_email_eq")`),
+ * (`@@index(expression: "eql_v3.eq_term(email)", name: "users_email_eq",
+ * type: "btree")` — the default access method normalizes away in the schema
+ * IR, so the DDL carries no USING clause and verify is clean),
  * a partial index, a unique expression index, and a registry-typed
  * (`USING hash`) index; a `.ts` twin authors the same schema via
  * `constraints.index`. Both variants: emit → plan (DDL byte-asserted, the
@@ -39,7 +41,7 @@ const EQL_V3_SETUP = `
 
 const EXPECTED_INDEX_DDL = [
   'CREATE INDEX "users_email_active_0cd7caf9" ON "public"."user" ("email") WHERE ((archived_at IS NULL))',
-  'CREATE INDEX "users_email_eq_8b80d85b" ON "public"."user" (eql_v3.eq_term(email))',
+  'CREATE INDEX "users_email_eq_adef23ad" ON "public"."user" (eql_v3.eq_term(email))',
   'CREATE INDEX "users_email_hash_239baf6b" ON "public"."user" USING "hash" ("email")',
   'CREATE UNIQUE INDEX "users_email_lower_key_f84d49fd" ON "public"."user" (lower(email))',
 ];
@@ -80,18 +82,18 @@ async function runInitialFlow(ctx: JourneyContext, connectionString: string): Pr
   expect(verify.exitCode, `db verify clean\n${stripAnsi(verify.stderr)}`).toBe(0);
 
   await withClient(connectionString, (client) =>
-    client.query('DROP INDEX "public"."users_email_eq_8b80d85b"'),
+    client.query('DROP INDEX "public"."users_email_eq_adef23ad"'),
   );
   const verifyFail = await runDbVerify(ctx, ['--schema-only']);
   expect(verifyFail.exitCode, 'verify fails after out-of-band drop').toBe(1);
   expect(
     stripAnsi(verifyFail.stderr) + stripAnsi(verifyFail.stdout),
     'verify names the dropped index',
-  ).toContain('users_email_eq_8b80d85b');
+  ).toContain('users_email_eq_adef23ad');
 
   await withClient(connectionString, (client) =>
     client.query(
-      'CREATE INDEX "users_email_eq_8b80d85b" ON "public"."user" (eql_v3.eq_term(email))',
+      'CREATE INDEX "users_email_eq_adef23ad" ON "public"."user" (eql_v3.eq_term(email))',
     ),
   );
   const verifyRestored = await runDbVerify(ctx);
@@ -127,14 +129,17 @@ withTempDir(({ createTempDir }) => {
           'rename: the widening plan is exactly one rename',
         ).toEqual([
           {
-            id: 'index.public.user.users_email_eq_8b80d85b.rename',
-            sql: 'ALTER INDEX "public"."users_email_eq_8b80d85b" RENAME TO "users_email_eq_v2_8b80d85b"',
+            id: 'index.public.user.users_email_eq_adef23ad.rename',
+            sql: 'ALTER INDEX "public"."users_email_eq_adef23ad" RENAME TO "users_email_eq_v2_adef23ad"',
           },
         ]);
         const applyRename = await runMigrate(ctx);
         expect(applyRename.exitCode, `rename: apply\n${stripAnsi(applyRename.stderr)}`).toBe(0);
         const verifyRename = await runDbVerify(ctx);
-        expect(verifyRename.exitCode, `rename: verify clean\n${stripAnsi(verifyRename.stderr)}`).toBe(0);
+        expect(
+          verifyRename.exitCode,
+          `rename: verify clean\n${stripAnsi(verifyRename.stderr)}`,
+        ).toBe(0);
 
         // The expression changes under the same name:, so the
         // hash moves and the plan is create + drop — never a rename.
@@ -143,14 +148,20 @@ withTempDir(({ createTempDir }) => {
         expect(emitEdited.exitCode, `body-edit: emit\n${stripAnsi(emitEdited.stderr)}`).toBe(0);
         const planEdit = await runMigrationPlanAndEmit(ctx, ['--name', 'edit-search-index-body']);
         expect(planEdit.exitCode, `body-edit: plan\n${stripAnsi(planEdit.stderr)}`).toBe(0);
-        expect(indexSqlOf(readPlannedOps(ctx)).sort(), 'body-edit: create + drop, byte-exact').toEqual([
-          'CREATE INDEX "users_email_eq_v2_b1fbd0db" ON "public"."user" (eql_v3.eq_term(lower(email)))',
-          'DROP INDEX "public"."users_email_eq_v2_8b80d85b"',
+        expect(
+          indexSqlOf(readPlannedOps(ctx)).sort(),
+          'body-edit: create + drop, byte-exact',
+        ).toEqual([
+          'CREATE INDEX "users_email_eq_v2_449c97be" ON "public"."user" (eql_v3.eq_term(lower(email)))',
+          'DROP INDEX "public"."users_email_eq_v2_adef23ad"',
         ]);
         const applyEdit = await runMigrate(ctx);
         expect(applyEdit.exitCode, `body-edit: apply\n${stripAnsi(applyEdit.stderr)}`).toBe(0);
         const verifyEdit = await runDbVerify(ctx);
-        expect(verifyEdit.exitCode, `body-edit: verify clean\n${stripAnsi(verifyEdit.stderr)}`).toBe(0);
+        expect(
+          verifyEdit.exitCode,
+          `body-edit: verify clean\n${stripAnsi(verifyEdit.stderr)}`,
+        ).toBe(0);
       },
       timeouts.spinUpPpgDev,
     );

test/integration/test/family.schema-verify.index-drift.integration.test.ts

@@ -79,6 +79,49 @@ describe('index drift', () => {
     );
   });
 
+  describe("authored type: 'btree' is the default access method, not drift", () => {
+    it(
+      'verifies clean against a live index created with the default method',
+      async () => {
+        await withClient(getConnectionString(), async (client) => {
+          await client.query('DROP TABLE IF EXISTS "user"');
+          await client.query(`
+          CREATE TABLE "user" (
+            id INTEGER PRIMARY KEY,
+            email TEXT NOT NULL
+          )
+        `);
+          await client.query('CREATE INDEX "user_email_btree_73653512" ON "user" ("email")');
+        });
+
+        const contract = defineContract({}, ({ field: packField, model: packModel }) => ({
+          models: {
+            User: packModel('User', {
+              fields: {
+                id: packField.column(int4Column).id(),
+                email: packField.column(textColumn),
+              },
+            }).sql(({ cols, constraints }) => ({
+              table: 'user',
+              indexes: [
+                constraints.index([cols.email], {
+                  name: 'user_email_btree',
+                  type: 'btree',
+                  options: {},
+                }),
+              ],
+            })),
+          },
+        }));
+
+        const result = await runSchemaVerify(getConnectionString(), contract);
+        expect(result.schema.issues).toEqual([]);
+        expect(result.ok).toBe(true);
+      },
+      timeouts.spinUpPpgDev,
+    );
+  });
+
   describe('scenario H — out-of-band storage-parameter change on a managed index', () => {
     it(
       'verifies clean before the ALTER and reports the index not-equal after it',

test/integration/test/fixtures/cli/cli-e2e-test-app/fixtures/cli-journeys/contract-expression-authored-editedbody.prisma

@@ -5,7 +5,7 @@ model User {
   email      String
   archivedAt String? @map("archived_at")
 
-  @@index(expression: "eql_v3.eq_term(lower(email))", name: "users_email_eq_v2")
+  @@index(expression: "eql_v3.eq_term(lower(email))", name: "users_email_eq_v2", type: "btree")
   @@index([email], where: "(archived_at IS NULL)", name: "users_email_active")
   @@index(expression: "lower(email)", unique: true, name: "users_email_lower_key")
   @@index([email], type: "hash", name: "users_email_hash")

test/integration/test/fixtures/cli/cli-e2e-test-app/fixtures/cli-journeys/contract-expression-authored-renamed.prisma

@@ -5,7 +5,7 @@ model User {
   email      String
   archivedAt String? @map("archived_at")
 
-  @@index(expression: "eql_v3.eq_term(email)", name: "users_email_eq_v2")
+  @@index(expression: "eql_v3.eq_term(email)", name: "users_email_eq_v2", type: "btree")
   @@index([email], where: "(archived_at IS NULL)", name: "users_email_active")
   @@index(expression: "lower(email)", unique: true, name: "users_email_lower_key")
   @@index([email], type: "hash", name: "users_email_hash")

test/integration/test/fixtures/cli/cli-e2e-test-app/fixtures/cli-journeys/contract-expression-authored.prisma

@@ -5,7 +5,7 @@ model User {
   email      String
   archivedAt String? @map("archived_at")
 
-  @@index(expression: "eql_v3.eq_term(email)", name: "users_email_eq")
+  @@index(expression: "eql_v3.eq_term(email)", name: "users_email_eq", type: "btree")
   @@index([email], where: "(archived_at IS NULL)", name: "users_email_active")
   @@index(expression: "lower(email)", unique: true, name: "users_email_lower_key")
   @@index([email], type: "hash", name: "users_email_hash")