Prisma Release Notes

Closes the lsp-rename project: deletes projects/lsp-rename/. Stacked on #30721; it will be rebased onto main when that merges.

Project outcome

Slice
PR
State

Rename symbol in the PSL language server, with @map / @@map where a database name would change
#30633
merged

The binder resolves entity names in type-constructor arguments (pg.enum(X)), so rename edits them
#30659
merged

A pg.enum column can name a native_enum of another namespace
#30721
in the merge queue

A named type over pg.enum (types { Status = pg.enum(X) })
—
not delivered; dropped from this project at close-out (see below)

Definition of Done

• Rename for models, composite types, named types, blocks, fields and namespaces, from a declaration and from a reference, across files: met (#30633, language-server tests).
• prepareRename ranges and refusals, refused non-identifier names: met (#30633).
• Map attribute on rename for models, scalar fields and blocks whose descriptor sets nameIsStorageName; none for relation fields, @@base models and the other kinds: met (#30633).
• Rename in apps/lsp-playground across scratch files, including one never selected: met (#30633, checked in a headless browser).
• READMEs state that rename is supported: met (#30633).
• native_enum rename edits its pg.enum(...) usages: met (#30659; QA run over stdio with the Postgres target).
• References across namespaces produce a column: met by #30721 once it merges.
• A named type over pg.enum gives the same column as the constructor on the field: not met. Dropped at close-out on the operator's request; no follow-up ticket exists.
• Manual check in VS Code (F2 on each symbol kind): not recorded in the project. The script for it was in projects/lsp-rename/qa/manual-qa.md, deleted here.

Where the project's decisions live

Decision
Home

Rename applies without a collision check, as TypeScript and Prisma 7 do
the rename provider and its tests

Rename adds @map / @@map with the old name where a database name would change; the rule for models and fields is in the language server; blocks opt in with nameIsStorageName
language-server/src/rename.ts; the doc comment on AuthoringPslBlockDescriptor.nameIsStorageName

An entity name in a type-constructor argument is bound by the binder through entityRefArg
psl-parser/src/binder.ts and its tests

A pg.enum column's type is qualified by the namespace of its value-set reference
contract-ts/src/target-authoring-hooks.ts and the Postgres target tests (#30721)

None is architecturally durable enough for an ADR.

Deferred, with no ticket

• A named type over pg.enum.
• The TypeScript builder cannot express a pg.enum column naming an enum of another namespace; the Prisma 7 interpreter still refuses an enum of another schema.
• After a native_enum rename with @@map, the contract's value-set entry is keyed by the block name, so the storage hash changes.
• No completion or signature help inside type-constructor arguments.

🤖 Generated with Claude Code

Summary by CodeRabbit

New Features

• PostgreSQL enum columns can now reference enum types in other namespaces. Generated column types include the appropriate namespace qualification, while references to the public namespace remain unqualified.
• Cross-namespace enum references are preserved when contracts are printed and read again.

Bug Fixes

• Invalid or unresolved enum references now produce more accurate diagnostics, including when a reference points to an entity of the wrong type.

Signed-off-by: Steven McClankerton [email protected]

Co-authored-by: Steven McClankerton [email protected]

Co-authored-by: Claude Opus 5.5 [email protected]

v8.0.0-rc.18

Raw SQL in a contract is now always a sql literal or value, a full-text index can span several weighted fields and is searched from the ORM by naming it, and middleware observes each statement and transaction as an activity. PSL gains mixins, the SQL ORM gains whereUnique and firstOrThrow, and MongoDB migrations carry out --rename.

The upgrade recipes for this hop: the app recipe and the extension recipe. Each breaking change below names the change ids to look for in them.

Breaking changes

Raw SQL in a contract is a sql literal. In PSL, @@index(where:), @@index(expression:), @@fullTextIndex(where:), @@check(expression:) and a policy's using and withCheck take a sql literal, and a quoted string is refused with PSL_VALUE_TYPE_INCOMPATIBLE. The app recipe ships a script that rewrites every .prisma file. In a TypeScript contract the same fields take a sql value, and a string does not compile; migration files keep strings. A text with shared indentation, blank lines at its ends or CRLF line breaks is stored as its canonical text, which changes the storage hash once. See raw-sql-is-a-sql-literal, builder-raw-sql-is-a-sql-value, psl-storage-hash-may-change-once and ts-storage-hash-may-change-once in the app recipe. (#30550, #30558)

Before:

@@index([email], where: "(archived_at IS NULL)", name: "users_email_active")

After:

@@index([email], where: sql`(archived_at IS NULL)`, name: "users_email_active")

Middleware hooks are activity hooks. The runtime runs every statement and transaction as an activity. beforeQuery and beforeExecute become beforeEncode; interceptQuery and interceptExecute become intercept.onQuery and intercept.onExecute; afterQuery and afterExecute become activityEnded; afterTransaction becomes activityFinalized. RuntimeMiddlewareContext is now ActivityContext, and ctx.planExecutionId is replaced by activity.id. activityEnded also fires for a statement the caller stopped reading and for one that failed before it ran, so a metrics middleware checks result.outcome. See middleware-hooks-are-activity-hooks and every-started-statement-is-ended-and-finalized in the app recipe, and statement-runners-replace-middleware-runners in the extension recipe. (#30703)

Before:

async afterQuery(plan, result, ctx) {
  if (result.latencyMs > 250) ctx.log.warn({ sql: plan.sql, rowCount: result.rowCount });
},

After:

async beforeEncode(plan, ctx) {
  ctx.state(statementSql)['sql'] = plan.sql;
},
async activityEnded(activity, result, ctx) {
  if (result.kind !== 'statement' || result.latencyMs <= 250) return;
  ctx.log.warn({
    sql: ctx.state(statementSql)['sql'],
    ...(result.returns === 'rows' ? { rowCount: result.rowCount } : {}),
  });
},

A full-text index is stored as data. @@fullTextIndex and fullTextIndex store an index of type fullText with its columns, weight groups and language, not a SQL expression. The schema source does not change, but the index's generated name and the storage hash do: re-emit the contract and run prisma migration plan, which renames the index in place. Avoid db update for a large index, because it drops and rebuilds it. See re-emit-contracts-with-a-full-text-index in the app recipe and render-full-text-index-document-takes-a-definition in the extension recipe. (#30562)

Before:

{ "expression": "to_tsvector('english', \"title\")", "name": "post_title_search_724b05e5", "type": "gin" }

After:

{ "columns": ["title"], "name": "post_title_search_e0dd1131", "options": { "language": "english", "weightGroups": [["title"]] }, "type": "fullText" }

A base model lists its variants by discriminator value. In contract.json and contract.d.ts, a polymorphic base's variants is keyed by discriminator value, and each entry names the variant model and its namespace. A contract in the previous form is refused with CONTRACT.VALIDATION_FAILED. Re-emit the contract and rewrite variants in the snapshots under migrations/snapshots/; the storage hash does not change. See re-emit-contracts-with-polymorphic-models and read-variants-by-discriminator-value in the app recipe. (#30696)

Before:

"variants": { "Bug": { "value": "bug" }, "Feature": { "value": "feature" } }

After:

"variants": { "bug": { "model": "Bug", "namespace": "public" }, "feature": { "model": "Feature", "namespace": "public" } }

The SQL ORM client accepts only field names. Every name passed to the SQL ORM client must be a field of the model, or of the variant the collection is narrowed to; any other name, including a column name that differs from its field name, throws ORM.FIELD_UNKNOWN. Rows no longer carry a column no field maps. See orm-refuses-names-that-are-not-fields in the app recipe. (#30667)

Before:

await db.orm.Post.where({ user_id: 1 }).all();

After:

await db.orm.Post.where({ userId: 1 }).all();

The query fragment types are renamed, and a fragment is made from the model's root collection. Fragment is now QueryFragment and FieldFragment is now DeclaredFieldsFragment. collection.fragment(body) throws ORM.ARGUMENT_INVALID on a collection with chained calls, which it used to ignore; chain on the collection directly, or move the calls into the fragment's body. See fragment-types-are-renamed and fragment-is-made-from-the-root-collection in the app recipe. (#30652, #30673)

Before:

const recentSummary = db.orm.public.Post.orderBy((p) => p.id.desc()).fragment((posts) =>
  posts.select('id', 'title'),
);

After:

const recentSummary = db.orm.public.Post.fragment((posts) =>
  posts.orderBy((p) => p.id.desc()).select('id', 'title'),
);

migration plan asks before a lossy type change, and writes placeholders only when asked. On Postgres and SQLite, a type change that can lose values fails with CLI.CONSENT_REQUIRED where nobody can answer, until --convert <Model.field> (write the conversion yourself) or --delete <Model.field> (accept the database's cast) answers it. A new required field gets a temporary value in existing rows; pass --backfill <Model.field> to fill them yourself. In a hand-written Postgres migration.ts, alterColumnType takes type and using directly instead of an options object. See lossy-type-changes-ask, placeholders-only-when-asked and postgres-alter-column-type-plain-options in the app recipe. (#30695)

Removing a field from a MongoDB model asks first. The plan now removes the field from every document that holds it, and migration plan and db update ask about it; add --delete <Model>.<field>, or --rename if the field was renamed, to scripts and CI. A MongoDB plan's preview writes db.getCollection("users") where it wrote db.users, and node migration.ts uses the config that owns the migration. See mongo-removed-field-asks, mongo-preview-get-collection and migration-ts-finds-its-config in the app recipe. (#30691)

A Prisma 7 schema's @ignore and @@ignore objects stay in the contract. prisma7Schema() keeps their columns, tables, keys and indexes in storage, so a schema that uses them gets a new storage hash, and a schema that loaded only because they were dropped can be refused. Emit the contract, then sign each database, or plan a migration first if Prisma 8 already manages your migrations. See prisma7-ignore-keeps-storage in the app recipe. (#30672)

Top-level PSL declarations belong to the default namespace. A top-level declaration and one inside namespace public { … } on Postgres share one set of names, so the same name declared both ways is PSL_DUPLICATE_DECLARATION, and a top-level declaration cannot be named like the default namespace (public, or unbound on SQLite and MongoDB). See psl-default-namespace-duplicate-declaration and psl-default-namespace-name-is-reserved in the app recipe. (#30700)

Stricter types for TypeScript contracts and the SQL ORM. A contract built with defineContract types its namespaces with exactly the keys it has at runtime, and its ORM rows with each field's codec type instead of unknown. A model with no fields has no keys, so reading or writing one fails to compile; generic update code types its data as ScalarUpdateInput. conflictOn, connect and disconnect no longer accept null for a nullable unique column, and prepared.all and prepared.aggregate must be called on the prepared object. See typescript-contract-namespace-keys, model-with-no-fields-has-no-keys, generic-update-data-uses-update-input-type, unique-criterion-rejects-null and prepared-all-and-aggregate-need-their-receiver in the app recipe. (#30663, #30705, #30670)

db.nativeEnums lists native enum types only. A domain enum (enum block or enumType()) is no longer listed there; read it through db.enums, which holds its values as a query returns them. See native-enums-leave-out-domain-enums in the app recipe. (#30661)

A MongoDB enum member must be written as its codec stores it. A member that your own codec stores as a value it reads back differently is refused, with a message that says what to write. The built-in MongoDB codecs are not affected. See mongo-enum-member-written-as-stored in the app recipe. (#30711)

Extension authors: SQL ORM collection state, MongoDB migration operations and the PSL symbol table changed. CollectionState requires tables, built with createCollectionTables, and names a variant by its discriminator value. The MongoDB DDL alphabet gains RenameCollectionCommand, and MongoDataTransformOperation is now MongoDmlOperation. buildSymbolTable requires defaultNamespaceId, and the symbol table places top-level declarations in its default namespace. See collection-state-carries-tables, sql-orm-state-names-a-variant-by-value, mongo-ddl-rename-collection, mongo-dml-operations and symbol-table-has-no-top-level in the extension recipe. (#30646, #30696, #30691, #30700)

Features

• PSL mixins: declare shared fields, attributes or enum members once with model mixin, enum mixin or the mixin form of another block, and include them with +Name. The language server completes, navigates to, hovers, renames and colours them. (#30675, #30694, #30679, #30681)
• A Postgres full-text index can cover several fields in weight groups, strongest first: @@fullTextIndex([[title, subtitle], body], name: "post_search"). (#30562)
• ORM where and orderBy callbacks receive { fns, indexes } as a second argument, so a query can search a weighted full-text index by naming it: fns.fullTextMatches(indexes.post_search, q) and fns.fullTextRank(indexes.post_search, q). (#30676)
• whereUnique on SQL ORM collections addresses at most one record by a unique key; a many-record call after it, such as all() or limit(), is a compile error. (#30670)
• firstOrThrow() on SQL and MongoDB ORM collections and on the SQL prepared view reads one row with LIMIT 1 and rejects with RUNTIME.NO_ROWS when nothing matches. (#30644)
• On MongoDB, migration plan and db update carry out --rename: a model rename renames its collection and keeps its documents, indexes and validator, and a field rename renames the field in every document. (#30691)
• postgres(), postgresServerless(), sqlite() and supabase() take a log option, so lint warnings, contract-marker warnings and errors swallowed from middleware hooks reach your logger. (#30707)
• A polymorphic base can have variants in other namespaces: @@base(a.Task, "chore"). (#30696)
• The sql tag interpolates other sql values, so predicates compose as sql${owner} AND deleted_at IS NULL instead of joined strings. (#30558)
• prisma migration plan writes a contract's raw SQL into migration.ts as sql values, as a TypeScript contract writes it. (#30677)
• The PSL language server renames symbols, and go-to-definition, hover, find references and rename work on the entity name inside a type-constructor argument, such as OrderStatus in pg.enum(OrderStatus). (#30633, #30659)

Fixes

• prisma db verify --strict passes on a database Prisma 7 built, and prisma contract infer no longer prints a model for Prisma 7's _prisma_migrations table. (#30671)
• A repeated db update on a MongoDB database with a time-series collection no longer fails with "Cannot change immutable collection option 'timeseries'". (#30691)
• The budgets() middleware enforces maxRows on the rows a query returns; the check never ran before, so a read over the limit now fails with BUDGET.ROWS_EXCEEDED. (#30703)
• update({}) resolves the first matching row and updateAll({}) yields the matching rows, where they returned null and no rows. (#30680)
• Two enum members are refused as duplicates only when their stored values are equal, so dates a millisecond apart and distinct object members are accepted. (#30661)
• A migration that makes a field required while rows have no value for it fails with a summary that counts those rows and names the fix. (#30695)

8.0.0-rc.17 → 8.0.0-rc.18

Version policy:

docs/oss/versioning.md.

Review surface:

docs/releases/v8.0.0-rc.18.md holds the user-facing notes, mirrored at the top of CHANGELOG.md. It becomes the GitHub Release body verbatim.

Merging this PR ships the release. The push to main carries the bumped root version; the Publish to npm workflow detects the change, publishes 8.0.0-rc.18 under dist-tag latest, and creates a matching GitHub Release marked pre-release.

Docs site: prisma/web#8498 updates the Prisma ORM 8 pages for this release. Merge it only after this release is published.

What the diff contains

Version bump: every workspace package.json, the workspace: specifiers in pnpm-lock.yaml, the library_version stamp in skills/prisma-8/SKILL.md, and the Supabase extension's version stamp in its tracked contract.json / contract.d.ts artefacts.

Upgrade guides: the 25 pending fragments are synthesized into skills/prisma-8/upgrading/app/upgrades/8.0.0-rc.17-to-8.0.0-rc.18/ (41 changes) and .../extension/upgrades/8.0.0-rc.17-to-8.0.0-rc.18/ (46 changes), with the rewrite-sql-strings.mjs script copied under each guide's scripts/sql-expression-literals-psl/. The originals, including 10 no-op declarations, moved unchanged to upgrade-instructions/releases/8.0.0-rc.17-to-8.0.0-rc.18/sources/. The app guide adds the usual contract-artifacts-restamp entry for the extension version stamp.

Release notes: docs/releases/v8.0.0-rc.18.md and the CHANGELOG.md entry.

Synthesis decisions to check

Both SQL expression literal fragments declared a change with the id storage-hash-may-change-once. In the guides they are psl-storage-hash-may-change-once and ts-storage-hash-may-change-once, and the TypeScript entry's pointer to "the PSL instructions in this release" now names the PSL id in the same guide.

The extension fragment for variants keyed by discriminator value said IncludeExpr.localVariantName became localVariantValue. localVariantName never shipped: in 8.0.0-rc.17 the field was localTableName, which the collection-state fragment already covers (include-expr-junction-table). The guide's entry now points there, and the localVariantName example lines and detection pattern are removed.

pnpm check:upgrade-coverage --mode publish --prev v8.0.0-rc.17 --head HEAD and pnpm check:release-notes --mode pr pass.

🤖 Generated with Claude Code

Summary by CodeRabbit

New Features

Added PSL mixins, weighted multi-field full-text search, cross-namespace polymorphic variants, and composable SQL values.

Added SQL ORM whereUnique and firstOrThrow, MongoDB field renames, configurable client logging, and PSL language-server symbol navigation.

Bug Fixes

Improved Prisma 7 verification and inference, MongoDB time-series updates, row-budget enforcement, empty updates, enum validation, and required-field migration errors.

Breaking Changes

Updated SQL, ORM, middleware, migration, MongoDB, enum, TypeScript contract, and extension-author requirements. See the upgrade guide for required changes.

Signed-off-by: Steven McClankerton [email protected]

Co-authored-by: Steven McClankerton [email protected]

Co-authored-by: Claude Opus 5.5 [email protected]

First slice of a restructuring of how the SQL ORM client executes writes. Every write method is to build a mutation graph (database-level nodes joined by edges) and hand it to one runner, replacing the per-method statement code and, later, the nested-write executor. This PR adds the graph and moves the six update and delete methods onto it.

Changes

All under packages/3-extensions/sql-orm-client/src/mutation-graph/ unless noted.

• Nodes (node.ts, find.ts, update.ts, delete.ts): a frozen class per statement kind. A node holds its statement as SQL AST (SelectAst, UpdateAst, DeleteAst) and has execute(inputs, run), which applies its inputs to the AST and runs it. A statement that returns columns runs as a row stream, one that returns nothing as an affected-row count.
• Edges (edge.ts, filter-data.ts, after.ts): FilterData has output(sourceRow), which turns one row of its source into a condition on its target. After is order only.
• Graph (graph.ts): a bidirectional adjacency list with stable positions. add(node, inputs) is typed by the node's input slots and returns a branded NodeId; adding a data edge makes its source return the columns the edge reads; after(from, to) adds an order edge.
• Runner (run-graph.ts): a loop over the nodes in position order: resolve each input edge per source row, call execute, keep the result. It puts the caller's annotations on every statement, opens a transaction when the graph has more than one node, and shapes the result node's rows for the caller with the existing mapping, include-loading and read-consumer code.
• Collection methods (collection.ts, 3,385 → 3,120 lines): update (without relation callbacks), updateAll, updateAndCount, delete, deleteAll, deleteAndCount build a graph (collection-graphs.ts) and call the runner. update() with relation callbacks, the create methods, upsert and mutation-executor.ts are unchanged.
• Shared with existing code: the AST-building parts of the update, delete and select compile functions and the row mapping of dispatchMutationRows are extracted so the graph and the remaining callers use one implementation.

Graphs are asserted in tests as text, through a printer that lives in the test directory:

n1 Find users where name = 'Ada' order by id asc limit 1
n2 Update users set email = '[email protected]' <- FilterData n1 (id->id)
result: n2 first row

Behaviour changes

• update({}) resolves the first matching row and updateAll({}) yields the matching rows. On main they resolve null and no rows. A write with nothing to set is a Find on the same rows, so a call returns what it matches whether or not it sets anything.
• updateAndCount({}) still resolves 0. Two integration tests asserted the old results and were changed; the port of Prisma 7's extended-where › "update with where 1 unique (PK)" now passes and left the failing ledger.
• The matching read of update() / delete(), the read of deleteAll() / delete() with includes, and the reload read of a write with includes carry the caller's annotations.
• delete() with includes issues two statements (main: three).
• update() maps fields and applies update defaults before the matching read, so a default generator runs even when no row matches.
• update() / delete() after limit(0) open no transaction.

Why

The nested-write executor issues statements while it walks the input, once per relation layout, and the plain and nested paths of create() and update() differ in annotations, variant handling and returned selection. A graph between the input and the statements can be tested and reordered by its edges alone, and a new kind of node or edge is a class, not a change to the runner. The design, the reason for each decision and the rejected alternatives are in projects/nested-mutations/mutation-graph.md; this slice's contract is projects/nested-mutations/slices/graph-core/spec.md.

Verification

• Package tests: 1,546 pass; typecheck, lint, lint:deps, check:upgrade-coverage pass.
• Integration, run locally for the directories that reach the ORM's write methods (test/sql-orm-client, test/ports, test/temporal-defaults, test/value-objects, test/cross-package, the namespaced-accessors test): 453 files, 2,524 passed, 86 expected failures, none failed. The whole integration suite was not run locally.

🤖 Generated with Claude Code

Signed-off-by: Steven McClankerton [email protected]
Co-authored-by: Steven McClankerton [email protected]
Co-authored-by: Claude Opus 5.5 [email protected]