feat(prisma-next): derive stack schema for v3 string columns

Author: tobyhede

packages/prisma-next/src/stack/derive-schemas.ts

@@ -31,7 +31,9 @@ import {
   CIPHERSTASH_JSON_CODEC_ID,
   CIPHERSTASH_STRING_CODEC_ID,
   isCipherstashCodecId,
+  isCipherstashV3CodecId,
 } from '../extension-metadata/constants'
+import { type V3Index, v3CastAs } from '../v3/domain-map'
 
 /**
  * Structural shape of the subset of `contract.json` this derivation
@@ -98,7 +100,19 @@ export function deriveStackSchemas(
     const builders: Record<string, EncryptedColumn> = {}
     for (const [columnName, column] of Object.entries(columns)) {
       const codecId = column.codecId
-      if (codecId == null || !isCipherstashCodecId(codecId)) continue
+      if (codecId == null || !(isCipherstashCodecId(codecId) || isCipherstashV3CodecId(codecId))) continue
+
+      // v3 columns take a SINGLE index (one domain per column), carried as
+      // `typeParams.index`; the v2 boolean-flag walk does not apply.
+      if (isCipherstashV3CodecId(codecId)) {
+        builders[columnName] = applyV3Index(
+          encryptedColumn(columnName).dataType(v3CastAs('text')),
+          column.typeParams,
+          tableName,
+          columnName,
+        )
+        continue
+      }
 
       const dataType = CODEC_ID_TO_DATA_TYPE[codecId]
       builders[columnName] = applyTypeParams(
@@ -140,3 +154,33 @@ function applyTypeParams(
 function isCipherstashFlag(value: string): value is CipherstashFlag {
   return value in FLAG_DISPATCH
 }
+
+const V3_INDEX_VALUES = ['equality', 'freeTextSearch', 'orderAndRange'] as const
+
+function isV3Index(value: unknown): value is V3Index {
+  return typeof value === 'string' && (V3_INDEX_VALUES as readonly string[]).includes(value)
+}
+
+/**
+ * Apply a v3 column's single index. `typeParams.index` is `unknown` (the contract
+ * view types typeParams as `Record<string, unknown> | null`), so narrow with
+ * `isV3Index` before dispatching. A v3 column is exactly one domain ⇒ exactly one
+ * index builder.
+ */
+function applyV3Index(
+  builder: EncryptedColumn,
+  typeParams: Readonly<Record<string, unknown>> | null | undefined,
+  tableName: string,
+  columnName: string,
+): EncryptedColumn {
+  const index = typeParams?.['index']
+  if (!isV3Index(index)) {
+    throw new Error(
+      `deriveStackSchemas: v3 column "${tableName}"."${columnName}" requires a valid 'index' typeParam ` +
+        `(one of ${V3_INDEX_VALUES.join(', ')}), got ${String(index)}.`,
+    )
+  }
+  if (index === 'equality') return builder.equality()
+  if (index === 'freeTextSearch') return builder.freeTextSearch()
+  return builder.orderAndRange()
+}

packages/prisma-next/test/v3/derive-schemas-v3.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+import { deriveStackSchemas } from '../../src/stack/derive-schemas'
+import { CIPHERSTASH_STRING_V3_CODEC_ID } from '../../src/extension-metadata/constants'
+
+function makeContract(tables: Record<string, Record<string, { codecId: string; typeParams?: unknown }>>) {
+  return {
+    storage: {
+      tables: Object.fromEntries(
+        Object.entries(tables).map(([name, cols]) => [name, { columns: cols }]),
+      ),
+    },
+  } as never
+}
+
+describe('deriveStackSchemas (v3)', () => {
+  it('maps each v3 string column to a string-cast column with exactly its one index', () => {
+    const contract = makeContract({
+      user_v3: {
+        email: { codecId: CIPHERSTASH_STRING_V3_CODEC_ID, typeParams: { index: 'equality' } },
+        bio: { codecId: CIPHERSTASH_STRING_V3_CODEC_ID, typeParams: { index: 'freeTextSearch' } },
+        name: { codecId: CIPHERSTASH_STRING_V3_CODEC_ID, typeParams: { index: 'orderAndRange' } },
+      },
+    })
+    const schemas = deriveStackSchemas(contract)
+    expect(schemas).toHaveLength(1)
+    const built = schemas[0]!.build()
+
+    // dataType is the string cast for every v3 text column.
+    expect(built.columns.email?.cast_as).toBe('string')
+
+    // equality → unique only; freeTextSearch → match only; orderAndRange → ore only.
+    expect(Object.keys(built.columns.email?.indexes ?? {})).toEqual(['unique'])
+    expect(Object.keys(built.columns.bio?.indexes ?? {})).toEqual(['match'])
+    expect(Object.keys(built.columns.name?.indexes ?? {})).toEqual(['ore'])
+  })
+
+  it('throws on a v3 column with a missing/invalid index typeParam', () => {
+    const missing = makeContract({ t: { c: { codecId: CIPHERSTASH_STRING_V3_CODEC_ID, typeParams: {} } } })
+    expect(() => deriveStackSchemas(missing)).toThrow(/index/)
+    const bad = makeContract({ t: { c: { codecId: CIPHERSTASH_STRING_V3_CODEC_ID, typeParams: { index: 'nope' } } } })
+    expect(() => deriveStackSchemas(bad)).toThrow(/index/)
+  })
+})