@prisma/orm-mongo 8.0.0-rc.11-dev.37 → 8.0.0-rc.11-dev.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/orm-mongo",
-  "version": "8.0.0-rc.11-dev.37",
+  "version": "8.0.0-rc.11-dev.39",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -10,16 +10,16 @@
     "skills"
   ],
   "dependencies": {
-    "@prisma/orm-family-mongo": "8.0.0-rc.11-dev.37",
-    "@prisma/orm-framework": "8.0.0-rc.11-dev.37",
-    "@prisma/orm-target-mongo": "8.0.0-rc.11-dev.37",
-    "@prisma/orm-toolchain": "8.0.0-rc.11-dev.37",
+    "@prisma/orm-family-mongo": "8.0.0-rc.11-dev.39",
+    "@prisma/orm-framework": "8.0.0-rc.11-dev.39",
+    "@prisma/orm-target-mongo": "8.0.0-rc.11-dev.39",
+    "@prisma/orm-toolchain": "8.0.0-rc.11-dev.39",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@internal/mongo": "8.0.0-rc.11-dev.37",
-    "@repo/tsconfig": "8.0.0-rc.11-dev.37",
-    "@repo/tsdown": "8.0.0-rc.11-dev.37",
+    "@internal/mongo": "8.0.0-rc.11-dev.39",
+    "@repo/tsconfig": "8.0.0-rc.11-dev.39",
+    "@repo/tsdown": "8.0.0-rc.11-dev.39",
     "tsdown": "0.22.14",
     "typescript": "5.9.3"
   },

package/skills/prisma-8/SKILL.md

@@ -15,7 +15,7 @@ description: >-
   ORM 7 or earlier (schema.prisma + @prisma/client).
 metadata:
   library: '@prisma/orm-mongo'
-  library_version: '8.0.0-rc.11-dev.37'
+  library_version: '8.0.0-rc.11-dev.39'
   version: '2026-09-12'
 ---
 

package/skills/prisma-8/references/contract.md

@@ -126,6 +126,16 @@ Then run `pnpm prisma contract emit` (or rely on the Vite plugin — see `refere
 
 `name:` declares a wire-named index (physical name `<name>_<8-hex hash>`, renames plan as `ALTER INDEX … RENAME`); `map:` adopts an exact physical name verbatim (for infer-captured objects — combining it with a SQL body warns, because drift detection byte-compares the authored text against Postgres's reprint). An `expression:` requires `name:` or `map:`. The TS builder mirrors this via `constraints.index([cols.x], {...})` / `constraints.index({ expression, ... })` — see `packages/2-sql/2-authoring/contract-ts/README.md`.
 
+**Full-text search indexes (PostgreSQL).** Do not hand-write the `to_tsvector` expression — Postgres only uses the index when it is the same `to_tsvector` over the same configuration literal and the same column as the query. Declare `@@fullTextIndex`, which renders the same expression `fullTextMatches` / `fullTextRank` / `fullTextHeadline` lower to (see `references/queries-postgres.md`):
+
+```prisma
+@@fullTextIndex([text], name: "message_text_search")
+@@fullTextIndex([summary], language: "german", name: "message_summary_search_de")
+@@fullTextIndex([text], where: "archived_at IS NULL", name: "message_text_search_live")
+```
+
+The TS builder has the same helper: `fullTextIndex(cols.text, { name: 'message_text_search' })`, from `@prisma/orm-postgres/contract-builder`, inside the model's `sql({ indexes: [...] })`. It takes exactly one field, an optional `language` (default `english`, from the same allowlist the operations accept), an optional `where:` for a partial index, and `name:` xor `map:` like any expression index. It is repeatable, so a model may index several columns. Give the index and the operation the same `language` — a mismatch is silent, costing the index and falling back to a sequential scan. It lowers to a GIN index over `to_tsvector('<language>', "<column>")` — the column name resolved through `@map` — so `@@index(expression: …)` remains only for expressions this attribute does not cover.
+
 PSL alias surface for repeated types lives in a top-level `types {}` block:
 
 ```prisma

package/skills/prisma-8/references/queries-postgres.md

@@ -62,6 +62,44 @@ db.orm.public.User.where({ kind: 'admin' });
 
 Operators on the field proxy include `.eq`, `.neq`, `.lt`, `.lte`, `.gt`, `.gte`, `.like`, `.ilike`, `.in([...])`, `.isNull()`, `.isNotNull()`. Extensions add target-specific operators on extension-typed columns (`pgvector`'s `.cosineDistance(...)`, `postgis`'s `.within(...)` / `.intersectsBbox(...)` / `.distanceSphere(...)`).
 
+**Full-text search** is built into the Postgres target, on any text column: `.fullTextMatches(q)` is the predicate, `.fullTextRank(q)` scores a row so you can order by relevance, and `.fullTextHeadline(q)` returns the text with `<b>` around the matches. The search string is a bound parameter lowered to `websearch_to_tsquery`, so `"an exact phrase"` and `-excluded` work the way a user expects from a search box. Each takes an options object as its second argument. `language` defaults to `'english'` and only accepts the configurations a stock PostgreSQL server ships with (`'simple'`, `'german'`, `'french'`, …); `fullTextRank` also takes `normalization` (the `ts_rank` bitmask, 0 to 63) and `coverDensity` (for `ts_rank_cd`); `fullTextHeadline` also takes `startSel`, `stopSel`, `maxWords`, `minWords` and `highlightAll`. Every one of them is written into the SQL as a literal, so anything invalid throws `RUNTIME.ARGUMENT_INVALID` when the query is built.
+
+```typescript
+// ORM: filter by the query, order by relevance.
+const hits = await db.orm.public.Message
+  .select('id', 'text')
+  .where((m) => m.text.fullTextMatches(query))
+  .orderBy((m) => m.text.fullTextRank(query).desc())
+  .limit(20)
+  .all();
+
+// SQL builder: the same predicate, plus a snippet with your own markers.
+const snippets = db.sql.public.message
+  .select('id')
+  .select('snippet', (f, fns) =>
+    fns.fullTextHeadline(f.text, query, { startSel: '<mark>', stopSel: '</mark>', maxWords: 20 }),
+  )
+  .where((f, fns) => fns.fullTextMatches(f.text, query))
+  .build();
+```
+
+Without an index Postgres recomputes `to_tsvector` for every row, and it only uses one whose expression is the same `to_tsvector` over the same configuration literal and the same column. `@@fullTextIndex` renders that expression for you — pass it the field and, if you use one, the same language:
+
+```prisma
+@@fullTextIndex([text], name: "message_text_search")
+@@fullTextIndex([text], where: "archived_at IS NULL", name: "message_text_search_live")
+```
+
+Give the index and the operation the same `language`: a mismatch raises no error, the query silently falls back to a sequential scan.
+
+In a TypeScript contract, the same helper from `@prisma/orm-postgres/contract-builder`:
+
+```typescript
+model('Message', { fields: { id, text } }).sql(({ cols }) => ({
+  indexes: [fullTextIndex(cols.text, { name: 'message_text_search' })],
+}));
+```
+
 **There is no `.between(a, b)` operator.** Express ranges either as two chained `.where(...)` clauses (the idiomatic form — clauses AND-compose) or with the `and(...)` combinator inside one clause:
 
 ```typescript