prisma/prisma
50.1
Adequate · 14 November 2026
339.6k
lines of production code
TypeScript
primary language
4
measurements over time
What this system is
Features
Add Cloudflare Workers examples for Prisma ORM
New example files (worker.ts and worker-emit.ts) have been added to the postgres-worker location, demonstrating how to use the Prisma ORM serverless client within Cloudflare Workers. These examples show initializing the client with a contract and executing a simple query to fetch notes, providing a reference implementation for this specific runtime environment.
examples/bundle-size/src/postgres-worker · high confidence
Add Next.js API routes for cart and store locations
New API endpoints have been added to the retail-store example to handle cart operations and retrieve store locations. The cart route supports GET (fetching the current user's cart), POST (adding items with validation for productId, name, brand, amount, price, and image), and DELETE (removing a specific item or clearing the entire cart), all secured by cookie-based authentication. A separate locations route provides a GET endpoint to fetch available store locations from the database.
examples/retail-store/app/api/cart · high confidence
Add Order History page to the retail store
The retail store example now includes an Order History page at /orders. Users can view a list of their past orders, with each entry displaying the item count, shipping address, total price, and current status (placed, shipped, delivered, or cancelled) via color-coded badges. The page requires authentication and redirects to login if the user is not signed in.
examples/retail-store/app/orders · high confidence
Add ParadeDB ORM demo with BM25 search capabilities
The ParadeDB demo application now includes an ORM client layer that enables full-text search using BM25 scoring. This change introduces a new \ItemCollection\ class and an \ormClientBm25TopMatches\ function, allowing users to query items via \paradeDbMatch\ and order results by \paradeDbScore\. The demo's main entry point has been updated to support an \orm-top\ command, which executes these ORM-based BM25 queries against the database.
examples/paradedb-demo/src/orm-client · high confidence
Add React Router demo for user management
A new \users.tsx\ route has been added to the React Router demo application, providing a functional example of user listing and creation. This route demonstrates how to use the Prisma SQL builder to construct and execute queries for fetching users and inserting new records, while also highlighting that server-side input validation is intentionally omitted in this proof-of-concept context.
examples/react-router-demo/app/routes · high confidence
Add React Router v7 framework example for Prisma 8 contract auto-emit
This location introduces a new \examples/react-router-demo\ application that demonstrates Prisma 8's Vite plugin auto-emitting contract artifacts (\contract.json\ and \contract.d.ts\) within a React Router v7 Framework Mode setup. The example includes configuration files (\prisma.config.ts\, \vite.config.ts\, \react-router.config.ts\) and source code (\app/root.tsx\, \app/routes.ts\) that exercise the Prisma 8 runtime against Postgres via a loader and action. It supports both PSL and TypeScript contract authoring surfaces, controlled by the \PRISMA\_CONTRACT\_SOURCE\ environment variable, and handles runtime cache invalidation during hot module replacement to ensure the application serves fresh types and data after contract edits.
examples/react-router-demo · high confidence
Add Supabase Prisma integration example
The examples/supabase directory now includes a walking skeleton demonstrating how to integrate Prisma with Supabase. This new db.ts file provides a createDb helper that initializes a Supabase database client using the new @prisma/orm-extension-supabase runtime, leveraging the contractFromJson utility to load the database schema contract from JSON and configuring it with a JWT secret for authentication.
examples/supabase/src/prisma · high confidence
Add audit and feature-flags internal contract-space packages
The example monorepo now includes two new internal contract-space packages: \audit\ and \feature-flags\. Each package defines its own Prisma schema (\contract.prisma\), generates corresponding type declarations (\contract.d.ts\) and JSON contracts (\contract.json\), and provides a control-plane descriptor (\control.ts\) that wires the contract and migration artifacts into the \@prisma/orm-postgres\ framework. The \audit\ package introduces an \AuditEvent\ model stored in the \audit\_event\ table, while the \feature-flags\ package introduces a \FeatureFlag\ model stored in the \feature\_flag\ table; both are configured to use the \public\ PostgreSQL namespace.
examples/multi-extension-monorepo/packages/audit/src, examples/multi-extension-monorepo/packages/feature-flags/src · high confidence
Add bundle-size analysis scripts for Node and Cloudflare Workers
The bundle-size example now includes scripts to measure and analyze bundle sizes for PostgreSQL and MongoDB drivers across Node.js and Cloudflare Workers environments. The new bundle.ts script uses esbuild to generate minified and unminified bundles, outputting size metrics (raw and gzip) and esbuild metafiles for visualization. A companion why.ts script allows tracing specific modules within those bundles to identify their import paths and contribution to bundle size.
examples/bundle-size/scripts · high confidence
Add bundle-size fixture for Postgres, Mongo, and Cloudflare Workers
A new \examples/bundle-size\ fixture has been added to measure and track the runtime footprint of the Prisma client across different targets. It includes configurations for Node.js (Postgres and Mongo) and Cloudflare Workers, supporting both 'no-emit' (runtime contract generation) and 'emit' (pre-generated contract) modes. The fixture uses esbuild and Wrangler to produce minified bundles, with size-limit integration to report gzipped bundle sizes in pull requests, helping users understand the impact of different client shapes on their application's total size.
examples/bundle-size · high confidence
Add checkout page with home delivery and store pickup options
The retail-store example now includes a checkout page that allows users to select between home delivery and store pickup (BOPIS). The page displays an order summary and total, requires authentication, and redirects to the cart if it is empty. The checkout form validates the shipping address for delivery or requires a pickup location selection, then submits the order to the API, invalidates the cart, and redirects to the order confirmation page.
examples/retail-store/app/checkout · high confidence
Add cookie-based signup and logout API routes
The retail-store example now includes API routes for user signup and logout, enabling cookie-based authentication. The new signup route creates a demo user and sets an httpOnly cookie containing the user ID, while the logout route clears this cookie to end the session.
examples/retail-store/app/api/auth · high confidence
Add full-text search index on Post titles
The demo application now supports searching posts by title using a PostgreSQL full-text index. This change adds a GIN index named \post\_title\_search\ on the \title\ column of the \post\ table, using the \english\ text search configuration. Users can now perform efficient full-text searches against post titles in the demo environment.
_examples/prisma-8-demo/migrations/app/20260922T1218\_add\_post\_title\search · high confidence
Add order detail page with status progression
The retail store example now includes a dedicated order detail view that displays shipping address, itemized costs, and a full status history. Users can view their order details and, if they have permission, advance the order status (e.g., from placed to shipped) via a client-side button that updates the state and refreshes the page.
examples/retail-store/app/orders/\[id\] · high confidence
Add post engagement counters to the Post model
The Post model now includes three optional integer columns—viewCount, impressionCount, and reachScore—to track engagement metrics. These columns are added to the database as int8 (bigint) for viewCount and impressionCount, and numeric (unbounded) for reachScore, allowing the analytics pipeline to backfill data as posts are served.
_examples/prisma-8-demo/migrations/app/20260810T1108\_add\_post\_engagement\counters · high confidence
Add product detail page to the retail store example
A new product detail page has been added to the retail store example, allowing users to view specific product information including name, brand, description, price, and category badges. The page fetches product data from the database and provides an 'Add to Cart' button to interact with the shopping cart functionality.
examples/retail-store/app/products · high confidence
Add shopping cart page with remove and clear actions
Users can now view their shopping cart at the /cart route, which displays individual items with names, brands, quantities, and prices, along with a calculated total. The page includes interactive controls to remove specific items or clear the entire cart, with client-side loading states and error handling for API calls. If the cart is empty, users are prompted to browse products, and if items are present, they can proceed to checkout.
examples/retail-store/app/cart · high confidence
Added MongoDB demo scripts for caching and seeding
The mongo-demo example now includes two new scripts: \cache-demo.ts\ demonstrates opt-in caching for MongoDB aggregation plans by annotating query plans with \cacheAnnotation\ and verifying that repeated queries hit the in-process cache store, and \seed.ts\ provides a standalone utility to populate the database using environment variables or a \.env\ file.
examples/mongo-demo/scripts · high confidence
Added ParadeDB BM25 search query demos
The demo application now includes a suite of TypeScript examples in \examples/paradedb-demo/src/queries\ demonstrating various BM25 search capabilities. These new files (\bm25-cast-demo\, \bm25-chain-demo\, \bm25-fuzzy\, \bm25-match\, \bm25-mode-tour\, \bm25-proximity-chain\, \bm25-proximity\, and \bm25-top-by-score\) showcase how to use the \paradeDbScore\, \paradeDbMatch\, \paradeDbMatchAny\, \paradeDbMatchAll\, \paradeDbPhrase\, \paradeDbTerm\, \paradeDbFuzzy\, \paradeDbProximity\, \paradeDbBoost\, and \paradeDbSlop\ functions to perform full-text searches, fuzzy matching, proximity queries, and score-based ranking against the \item\ table.
examples/paradedb-demo/src/queries · high confidence
Added Prisma ORM migration fixtures for branch-merging scenarios
The examples/prisma-8-demo now includes fixture sets (converging-branches, diamond, long-spine) that demonstrate how the @prisma/orm-postgres/migration library handles database schema evolution. These fixtures define migration scripts that create a 'user' table and subsequently add columns (phone, posts, avatar, bio), including complex merge operations where divergent branches are reconciled into a single production state.
(repo-wide) · high confidence
Added Prisma contract definitions for the telemetry backend
The telemetry backend now includes generated Prisma contract files (contract.d.ts, contract.json, and contract.prisma) that define the TelemetryEvent model. This model maps to the public.telemetry\_event table and includes fields for tracking installation metadata (version, OS, arch, runtime), command execution details (command, flags, exitCode), and ingestion timestamps, enabling type-safe ORM access to telemetry data.
apps/telemetry-backend/src/prisma · high confidence
Added agent commands for build, test, coverage, linting, and demo workflows
New command definitions have been added to the agent configuration to streamline common development tasks. Users can now trigger specific workflows directly, including building all packages via Turbo, running package-only tests and coverage, validating package layering and import rules, and executing the Todo example end-to-end demo.
.cursor/commands · high confidence
Added bundle-size fixtures for Postgres and Mongo
New example fixtures have been added to the \examples/bundle-size\ directory to measure the library's bundle size for both Postgres and MongoDB. Each database provider includes a TypeScript contract definition, a configuration file using \definePrismaConfig\, and two entry points (\main.ts\ and \main-emit.ts\) demonstrating runtime usage and code-generation workflows.
examples/bundle-size/src/postgres · high confidence
Added bundle-size fixtures for Postgres and Mongo
New example fixtures have been added to the \examples/bundle-size\ directory to measure the library's bundle size for both Postgres and MongoDB. Each database provider includes a TypeScript contract definition, a configuration file using \definePrismaConfig\, and two entry points (\main.ts\ and \main-emit.ts\) demonstrating runtime usage and code-generation workflows. Also in this area: 1 commit (0 fixes) modifying examples/bundle-size, upgrade-instructions/pending/mongo-type-helpers.
examples/bundle-size/src/mongo · low confidence · unverified
Added cookie-based authentication and utility helpers to the retail store example
The retail-store example now includes a new authentication module that retrieves the current user by reading a 'userId' cookie and fetching the corresponding user record from the database. Additionally, a utility function for merging Tailwind CSS classes has been added to support the UI component system.
examples/retail-store/src/lib · high confidence
Added database reset and seed scripts for the retail store example
The retail store example now includes two new scripts to manage local development data. A \db:reset\ script has been added to drop all collections from the configured MongoDB database, allowing users to start with a clean slate. Additionally, a \db:seed\ script is provided to populate the database with initial data. Both scripts require the \DB\_URL\ environment variable and use the \MONGODB\_DB\ variable (defaulting to 'retail-store') to identify the target database.
examples/retail-store/scripts · high confidence
Added database reset and seeding scripts for the ParadeDB demo
The ParadeDB demo now includes utility scripts to manage the development database state. A new \drop-db.ts\ script allows users to reset the database by dropping and recreating the public schema and removing the prisma\_contract schema. Additionally, a \seed.ts\ script has been added to populate the database with sample product data (such as furniture, electronics, and kitchen items) using the application's SQL builder, enabling quick setup of the demo environment.
examples/paradedb-demo/scripts · high confidence
Added local development scripts for the Prisma 8 Cloudflare Worker example
This change introduces a set of new scripts in the \examples/prisma-8-cloudflare-worker/scripts\ directory to facilitate local setup and data seeding. The \setup-schema.ts\ script initializes the database schema using \prisma db init\ and enables the \pg\_stat\_statements\ extension, while \seed.ts\ and \seed-posts.ts\ populate the database with test users, posts, and bulk-generated data for testing cursor-based pagination. These scripts rely on a new \env.ts\ utility to load environment variables, specifically supporting Cloudflare Hyperdrive connection strings for local development.
examples/prisma-8-cloudflare-worker/scripts · high confidence
Added login page with sign-up functionality
The retail store example now includes a login page that allows users to create an account. This new page features a 'Sign Up' button which triggers a POST request to the /api/auth/signup endpoint, redirecting users to the home page upon successful account creation.
examples/retail-store/app/login · high confidence
Added query execution examples using prepared statements and SQL plans
The demo application now includes specific query implementations in the queries directory that demonstrate how to execute database operations using the new Prisma 8 API. These examples show how to build and run SQL plans for insertions and selections, as well as how to utilize prepared statements for parameterized queries, providing users with concrete patterns for interacting with the database.
examples/prisma-8-demo-sqlite/src/queries · high confidence
Browser-based PSL playground with multi-file scratch projects
The LSP playground now supports a multi-file scratch project environment with tabbed navigation and lazy file opening. This entry introduces the client-side wiring (\main.ts\) that loads runtime configuration, registers a semantic token theme extension for Prisma Schema Language (PSL), and manages file state to ensure documents remain open across tab switches. Users can now edit multiple PSL files in the browser, with the editor automatically handling file persistence and language server communication via WebSocket.
apps/lsp-playground/src/client · high confidence
Establishes the @internal/contract package structure and configuration for Prisma 8
This change introduces the foundational directory structure and configuration files for the \@internal/contract\ package, which serves as the core contract data type layer for Prisma 8. It adds the \README.md\ defining the package's role as an internal implementation detail providing canonical data model types, plan metadata, and JSON schemas, while explicitly warning against direct dependency. The entry includes build and tooling configurations (\tsconfig.json\, \tsdown.config.ts\, \biome.jsonc\, \vitest.config.ts\, \coverage.config.json\) that set up TypeScript compilation, bundling entry points (such as \types.ts\, \hashing.ts\, and validation exports), linting, and testing environments. This establishes the leaf-node foundation layer that other framework domains consume for contract definitions.
packages/1-framework/0-foundation/contract · high confidence
Extracted shared contract descriptor types into a new internal package
A new internal package, \@internal/contract-authoring\, has been created to hold target-neutral descriptor types shared across the authoring ecosystem. This package exports \IndexDef\ and \ForeignKeyDefaultsState\, providing a common vocabulary for index and foreign key configuration without depending on SQL-specific logic. It serves as a foundational layer for other packages like \@internal/sql-contract-ts\, ensuring that shared authoring details are decoupled from target-specific implementations.
packages/1-framework/2-authoring/contract · high confidence
Initial MongoDB migration for the demo app
The mongo-demo application now includes an initial migration that establishes the database schema and indexes. The schema defines a User model with an optional address and a collection of posts, and a Post model that uses inheritance for Article and Tutorial types. As part of the initial setup, the migration creates a unique index on the email field in the users collection to ensure data integrity.
_examples/mongo-demo/migrations/app/20260409T1030\migration · high confidence
Initial database schema for the Prisma 8 demo application
This change introduces the initial migration contract and execution logic for the Prisma 8 demo, establishing the foundational database structure. The schema defines core entities including User, Post, Tag, and a polymorphic Task hierarchy (with Bug and Feature subtypes), along with a many-to-many PostTag join table. It also configures PostgreSQL-specific features such as the pgvector extension for embedding storage, explicit check constraints for enum-like fields (user\_type, Priority), and foreign key relationships with cascade deletion for the task inheritance.
_examples/prisma-8-demo/migrations/app/20260422T0720\initial · high confidence
Initial repository scaffolding and open-source governance setup
The repository is initialized with the foundational structure for Prisma 8, including a contract-first architecture design, agent-accessible documentation (AGENTS.md), and a comprehensive changelog. It establishes open-source governance by adding a Code of Conduct, contributing guidelines, and a security policy, while configuring the development environment with tooling definitions (.tool-versions), CI automation rules (.coderabbit.yml), and artifact handling (.gitattributes).
(repo-wide) · high confidence
Interactive cart with Add to Cart button and badge
The retail store example now supports interactive cart operations. Users can click an 'Add to Cart' button on product cards, which sends a request to the cart API and provides visual feedback (loading/added states). The cart count is tracked via a new CartProvider context, and a badge displaying the item count appears on the Cart link in the navbar. Additionally, a logout button has been added to the navbar for authenticated users.
examples/retail-store/src/components · high confidence
Internal error package structure and documentation
The @internal/errors package now includes a README and build configuration files (tsconfig, vitest, biome, coverage) that define its structure. The package is split into two entry points: ./control for CLI errors (PN-CLI-4xxx) and ./execution for runtime errors (PN-RUN-3xxx). It provides structured error types and factories for creating errors with codes, fix suggestions, and machine-readable metadata.
packages/1-framework/1-core/errors · high confidence
Introduce @internal/config package for Prisma 8 schema authoring
The new @internal/config package provides the core types, validation, and normalization logic for the unified prisma.config.ts file in Prisma 8. It defines the shared config contract used by tooling, including support for declaring database families, targets, adapters, and extensions, as well as a protocol for contract source providers (PSL or TypeScript) and their input metadata. The package exposes defineConfig() for authoring and collectConfigIssues() for structural validation, ensuring that configuration is type-safe and consistent before being processed by the CLI or language server.
packages/1-framework/1-core/config · high confidence
Introduce @internal/ids package for client-side generated columns
This change adds the \@internal/ids\ package, providing ID generator helpers (such as \ulid\, \nanoid\, \uuidv7\, \uuidv4\, \cuid2\, and \ksuid\) for authoring Prisma 8 data contracts. These helpers allow developers to define client-side generated columns (e.g., \field.generated(uuidv4()).id()\) that produce contract-safe, JSON-serializable execution defaults without storing executable code in the contract. At runtime, the package uses the \uniku\ library to generate actual ID values, ensuring that generator options (like \nanoid\ size) align with column descriptor metadata.
packages/1-framework/2-authoring/ids · high confidence
Introduce @internal/mongo-codec package for MongoDB value serialization
A new \@internal/mongo-codec\ package has been added to the MongoDB family foundation layer, providing the \mongoCodec()\ factory, \MongoCodec\ interface, and \MongoCodecRegistry\ for serializing and deserializing values between JavaScript and the BSON wire format. The package enforces that both \toWire\ and \fromWire\ author functions are explicitly provided, supports both synchronous and asynchronous authoring, and threads a per-call \CodecCallContext\ (containing an optional \signal\ for abort support) to every codec dispatch site. This establishes the core codec infrastructure for the Mongo target, ensuring that all data written to or read from MongoDB is processed through typed, context-aware codecs.
packages/2-mongo-family · high confidence
Introduce @internal/psl-parser as a reusable, target-agnostic PSL parsing library
The \psl-parser\ package is now available as a standalone, reusable component for parsing Prisma Schema Language (PSL) source text. It provides a complete pipeline that transforms PSL into a lossless syntax tree, a symbol table of declarations, and a binder that resolves names, while remaining target-agnostic (it does not produce contract IR or know specific database targets). The package exposes distinct subpath entries for the tokenizer, syntax tree, symbol table, binder, attribute/block specifications, formatter, and test helpers, allowing consumers like the CLI and language server to use a shared, consistent parsing foundation.
packages/1-framework/2-authoring/psl-parser · high confidence
Introduce PSL Playground for browser-based language server testing
Added a new private development tool, \lsp-playground\, that launches a browser-based Monaco editor wired to the Prisma 8 language server. This playground allows developers to interactively test PSL language features—including live diagnostics, semantic highlighting, folding, formatting, go-to-definition, and find references—across a multi-file scratch project with lazy file opening, without needing to build or run the full application.
apps/lsp-playground · high confidence
Introduce Prisma Vite plugin for contract emission
A new Vite plugin (\prismaVitePlugin\) is now available to automatically emit Prisma 8 contract artifacts during development. The plugin watches configured source files and triggers contract re-emission on changes, using a debounce mechanism (default 150ms) and serialization to handle rapid saves. It supports custom configuration paths (defaulting to \prisma.config.ts\) and offers log level control (\silent\, \info\, \debug\). On successful emission, it triggers a full browser reload via Vite's WebSocket API, while errors are surfaced through Vite's error overlay. The plugin also manages lifecycle cleanup to prevent state accumulation during long dev sessions.
packages/1-framework/3-tooling/vite-plugin-contract-emit/src · high confidence
Introduce arktype-json extension for typed JSON columns
A new \@internal/extension-arktype-json\ package provides a column-author helper (\arktypeJson(schema)\) that stores values as \jsonb\ on Postgres while enforcing runtime validation via an arktype schema. The extension registers a codec descriptor that serializes the schema's expression and internal IR into \typeParams\, allowing emitted \contract.d.ts\ to render the schema's TypeScript type directly. It includes control and runtime descriptors for framework composition, a codec registry, and comprehensive unit, type, and integration tests covering encode/decode round-trips, schema validation, and wire-format handling.
packages/3-extensions · high confidence
Introduce dedicated telemetry ingestion backend
The telemetry-backend application now provides a standalone HTTP service for collecting telemetry events. It accepts POST requests at /events, validates payloads against a strict schema, and persists them to a PostgreSQL database using the Prisma ORM. The service includes an in-process token-bucket rate limiter (defaulting to 120 requests per minute) and supports trusting the x-forwarded-for header only when explicitly enabled via the TRUST\_FORWARDED\_FOR environment variable. It is available for both Node.js and Bun runtimes, uses evlog for server-lifecycle logging, and ensures a non-zero exit code on shutdown timeouts.
apps/telemetry-backend/src · high confidence
Introduce internal config-loader package for Prisma 8
The new @internal/config-loader package centralizes the discovery and evaluation of prisma.config.ts files. It defines the schema for the orm section and provides loadConfig and requireConfigSections functions that validate configuration, resolve paths, and report diagnostics, ensuring that both the CLI engine and external readers use a consistent, validated configuration model.
packages/1-framework/3-tooling/config-loader · high confidence
Introduce internal emitter package for contract-first architecture
The new \@internal/emitter\ package serves as the core contract emission engine for Prisma 8, transforming authored data models into deterministic \contract.json\ and \contract.d.ts\ artifacts. It implements a target-family-agnostic architecture where the core handles validation, hashing (storage, execution, and profile), and canonicalization, while delegating family-specific type generation to an \EmissionSpi\ interface (e.g., SQL or Mongo hooks). The package is configured for \tsdown\ builds, Vitest testing, and Biome linting, and is explicitly marked as an internal implementation detail not to be depended on directly by end-users.
packages/1-framework/3-tooling/emitter · high confidence
Introduce internal framework-components package for Prisma 8 core abstractions
The new \@internal/framework-components\ package centralizes the core abstractions for Prisma 8, including the \Codec\ interface, component descriptors, control stack assembly, and emission SPI types. It establishes a single-path async codec runtime with a per-query \AbortSignal\ context (\CodecCallContext\) and unified codec registration via \CodecDescriptor\, enabling consistent data type handling and cancellation across SQL and MongoDB families. The package also provides authoring logic for type constructors and field presets, along with utility functions like \canonicalizeJson\ for stable JSON serialization, serving as the foundational layer for family-specific runtimes and emitters.
packages/1-framework/1-core/framework-components · high confidence
Introduce retail-store example with Next.js, MongoDB, and shadcn-style UI
Adds a new interactive e-commerce example application in the \examples/retail-store\ directory that demonstrates Prisma 8's MongoDB capabilities. The app is built on Next.js with a Tailwind CSS v4 frontend and includes shadcn-style UI components (Badge, Button, Card, DropdownMenu, Input, RadioGroup, Select, Separator). It features cookie-based authentication, an interactive shopping cart, and a checkout flow supporting both home delivery and BOPIS (Buy Online, Pick Up In Store). The data layer uses the \@internal/mongo-orm\ for CRUD operations, reference relations, and array updates, while also showcasing advanced MongoDB features like aggregation pipelines, pipeline search, and optional vector search. Configuration files for Next.js, PostCSS, Turborepo, and Vitest are included to support local development and testing with \mongodb-memory-server\.
examples/retail-store · high confidence
Introduce target-neutral operation registry for Prisma 8
The \@internal/operations\ package now provides a generic, target-neutral operation registry that allows contributors to register and iterate operations parameterized by entry type. It exposes \createOperationRegistry\, \OperationEntry\, and \OperationDescriptor\ types, enforcing that each operation specifies a \codecId\, \traits\, or \many\ flag via structured contract errors (\CONTRACT.PACK\_CONTRIBUTION\_INVALID\) when validation fails. This registry serves as the core interface for downstream SQL and relational layers to define operations without coupling to a specific database target.
packages/1-framework/1-core/operations · high confidence
Introduce telemetry-backend service for CLI event collection
Adds a new deployable HTTP service under \apps/telemetry-backend\ that receives, validates, and stores Prisma 8 CLI telemetry events in Postgres. The service exposes a \POST /events\ endpoint, enforces a 32 KiB request cap, and applies per-IP rate limiting (default 120 RPM) with a new \TRUST\_FORWARDED\_FOR\ environment variable to correctly identify clients behind trusted proxies. It is configured via \DATABASE\_URL\ and \PORT\, uses Prisma ORM for database access, and includes a \scripts/deploy.ts\ entry point for deploying to Prisma Compute via \pnpm run deploy\.
apps/telemetry-backend · high confidence
Introduce transient project workspace for specs, plans, and ADRs
A new \projects/\ directory has been added to organize transient, project-specific documentation such as specs, plans, ADR drafts, and reference assets. This workspace supports a structured workflow where work is shaped via \spec.md\ and \plan.md\ files before implementation, with a defined lifecycle that requires migrating long-lived documentation to \docs/\ and deleting the project folder upon close-out. Initial project workspaces have been scaffolded for the AST-bound codec resolution and codec JSON projections initiatives.
projects · high confidence
Introduce typed data access layer for retail-store example
The retail-store example now includes a structured data access layer under \src/data\ that provides typed repository functions for core entities (carts, orders, invoices, products, users, events, and locations). These functions use the ORM to perform CRUD operations, support pagination and regex-based search for products, enable polymorphic event creation and aggregation, and allow vector similarity search for products (on Atlas clusters). This replaces previous ad-hoc database interactions with a consistent, type-safe API.
examples/retail-store/src/data · high confidence
Introduces @prisma-next/ids for client-side generated columns
The new \@prisma-next/ids\ package provides a set of TypeScript spec helpers (\ulid\, \nanoid\, \uuidv7\, \uuidv4\, \cuid2\, \ksuid\) that allow contracts to define client-side generated columns. These helpers automatically configure the correct database storage type (e.g., \CHAR(n)\) and link to the corresponding runtime generator, ensuring that the schema's storage requirements match the ID format. The \nanoid\ helper additionally supports a configurable \size\ parameter, which is validated against defined limits to prevent invalid configurations.
packages/1-framework/2-authoring/ids/src · high confidence
Introduces Prisma 8 runtime database client with HMR-aware connection pooling
The React Router demo now uses the Prisma 8 runtime (\@prisma/orm-postgres\) instead of the previous ORM setup. This change introduces a new database module that loads the database contract from JSON, manages a \pg\ connection pool, and ensures the pool is properly closed during Vite Hot Module Replacement (HMR) to prevent stale connections and uncaught errors. It also adds a guard to throw a clear error if \DATABASE\_URL\ is missing.
examples/react-router-demo/app/lib · high confidence
Introduces a lossless red/green syntax tree and typed AST wrappers for PSL
The PSL parser now constructs a lossless Concrete Syntax Tree (CST) consisting of a 'green' immutable layer (preserving raw source text and structure) and a 'red' mutable layer (providing offset-aware navigation and parent/child links). This change adds helper utilities for extracting documentation comments, navigating siblings while skipping trivia, and building syntax nodes, enabling precise source-level analysis and formatting without losing original formatting details.
packages/1-framework/2-authoring/psl-parser/src/syntax · high confidence
Introduces a typed annotation system for query metadata
The framework now supports attaching typed metadata to database operations via a new annotation API. Users can define custom annotations (e.g., for caching or auditing) using \defineAnnotation\, specifying whether they apply to read or write operations. These annotations are applied at the terminal level (e.g., \find\, \create\) through a \meta\ configurator callback, allowing for structured, type-safe metadata injection that is enforced at both compile time and runtime.
packages/1-framework/1-core/framework-components/src · high confidence
Introduces extensible block specification system for PSL parser
The PSL parser now supports defining custom block types (struct and map modes) via a new specification layer in the \block-spec\ directory. This change adds constructors for struct and map blocks, type definitions for block specs and contexts, and an interpreter that validates block entries against these specs, ensuring parameters are present, types are correct, and diagnostics are generated for errors like duplicates or missing required fields. This enables authoring tools to define and validate custom PSL block structures with strong typing and clear error reporting.
packages/1-framework/2-authoring/psl-parser/src/block-spec · high confidence
Introduction of internal shared utility package
A new internal package, \@internal/utils\, has been added to the framework foundation layer to provide shared, target-agnostic utility functions for the Prisma 8 codebase. This package exposes specific utilities such as \ifDefined\ for handling optional properties with TypeScript's \exactOptionalPropertyTypes\ and a generic \Result\<T, F\>\ type for representing success or failure outcomes without throwing exceptions. It also includes other exports like \array-equal\, \assertions\, \abortable\, \canonical-stringify\, \casts\, \hash-content\, \internal-error\, \json\, \promise\, \redact-db-url\, \simplify-deep\, \structured-error\, \suppress-idle-connection-errors\, \text\, and \types\. The package is marked as an implementation detail and is not intended for direct external dependency.
packages/1-framework/0-foundation/utils · high confidence
Mongo demo now features a Vite React UI with polymorphic post rendering
The MongoDB demo application has been converted to a Vite-based React app, replacing the previous implementation with a new frontend that demonstrates polymorphic type narrowing. The UI includes an App component with tabs for Posts and Authors, a PostList component that renders discriminated union types (Articles vs. Tutorials) with specific fields like summary, difficulty, and duration, and a UserList component displaying author details. This change introduces the frontend wiring for the emitter-generated contract types, allowing users to see how Prisma 8 handles polymorphic models and type-safe narrowing in a browser environment.
examples/mongo-demo/src/app · high confidence
Mongo demo now supports polymorphic models and typed enums
The mongo-demo application has been updated to demonstrate a polymorphic schema where the Post model acts as a base for Article and Tutorial variants, distinguished by a 'kind' discriminator field. This change introduces typed enum support for the UserRole field (admin, author, reader) and includes a new Address value object. The demo also showcases polymorphic type narrowing in the UI and uses ORM writes for seeding instead of raw client calls.
examples/mongo-demo/src · high confidence
Multi-extension monorepo app contract and configuration files
The application source now includes the core contract definition files (\contract.prisma\, \contract.d.ts\, \contract.json\) and a constants file (\constants.ts\) for the \User\ model. The Prisma schema defines the \User\ model mapped to the \app\_user\ table, while the generated TypeScript types and JSON contract metadata expose the storage structure, codec mappings, and available SQL capabilities (such as \forUpdate\ and \scalarList\) for the PostgreSQL target. This setup establishes the typed contract space for the app, which is composed with internal extension packages (\audit\, \feature-flags\) via the project's configuration.
examples/multi-extension-monorepo/app/src · high confidence
New API routes for retrieving, updating, and deleting individual orders
The retail-store example now includes a dedicated API endpoint at /api/orders/\[id\] that allows authenticated users to fetch, modify, or remove their own orders. The GET method returns order details only if the requesting user owns the order, while the DELETE method removes the order after verifying ownership. The PATCH method enables updating the order status, including validation to ensure the status field is present and valid before persisting the change.
examples/retail-store/app/api/orders/\[id\] · high confidence
New CI and release tooling scripts for publishing, auditing, and repository hygiene
The \scripts/\ directory now includes a suite of new tooling scripts to enforce publishing correctness and repository standards. \check-publish-deps\ and \check-conformance\ act as publish-time gates, verifying that \@internal/\*\ dependencies are exact-pinned, that no pnpm-internal protocols leak into tarballs, that declaration files only reference installed types, and that shipped code imports only declared packages. \audit-notice\ scans the dependency graph for Apache-2.0 NOTICE files to ensure OSS compliance. Release management is supported by \bump-version\ and \set-version\ to coordinate version bumps across the workspace. Additional scripts enforce repository hygiene: \check-clean-tree\ ensures CI jobs leave no untracked artifacts, \check-commit-signoff\ enforces DCO sign-offs locally, \check-catalogue-links\ validates internal documentation links, and \architecture-globs\ provides utilities for dependency analysis.
scripts · high confidence
New CLI commands for contract printing and inference
The CLI now includes \contract print\ and \contract infer\ commands to manage Prisma schema contracts. \contract print\ converts the configured contract source into Prisma 8 PSL format, optionally writing it to a file or printing it to stdout, and provides guidance for updating the configuration to use the printed file. \contract infer\ introspects a live database schema and writes the resulting PSL contract to disk, requiring a database connection and driver configuration. Both commands are anchored to the output directory and support structured output via \--json\.
packages/1-framework/3-tooling/cli/src/orm/contract · high confidence
New CLI scripts for golden rendering and scenario recording
The CLI now includes two new internal scripts: \gallery.ts\ renders hand-authored golden fixtures (glyphs and colors) to the terminal for visual verification, and \record.ts\ automates the creation of CLI demo assets (SVGs, asciicasts, and optional MP4s) using VHS, supporting both per-command and multi-step journey recording modes with database state management.
packages/1-framework/3-tooling/cli/scripts · high confidence
New CLI telemetry system with opt-out default
The CLI now collects anonymous usage telemetry by default, sending data to the Prisma Compute backend. Users can opt out by setting the \PRISMA\_DISABLE\_TELEMETRY\ or \DO\_NOT\_TRACK\ environment variables, or by explicitly disabling it in their user config file (\\~/.config/prisma-8/config.json\). The system runs in a detached child process to avoid blocking the CLI, enriches events with runtime and project configuration details (like database target and extensions), and fails silently on errors to ensure a smooth user experience.
packages/1-framework/3-tooling/cli-telemetry/src · high confidence
New Claude Code automation scripts for tool enforcement, formatting, quality gates, and isolated worktrees
Added four new Node.js scripts in .claude/scripts that integrate with Claude Code to improve developer workflow and code quality. The enforce-tools.mjs script blocks disallowed commands (such as using npm/npx directly or running full integration/e2e test suites locally) to ensure consistent tooling usage. The format-ts.mjs script automatically formats TypeScript files using Biome when files are saved. The stop-quality-gate.mjs script runs a suite of checks (package tests, e2e tests, typechecking, and linting) before allowing a session to finish, blocking if any check fails. The worktree-create.mjs script creates isolated Git worktrees based on origin/main, copying local settings and running pnpm install/build to provide a clean, sandboxed environment for agent interactions.
.claude/scripts · high confidence
New Cloudflare Worker example for Prisma 8 serverless client
Added a new end-to-end example demonstrating the Prisma 8 serverless client (\@prisma/orm-postgres/serverless\) running on a Cloudflare Worker with Hyperdrive-backed Postgres. The example showcases the per-request connection lifecycle, SQL DSL, ORM with custom collection classes, transactions, and cursor-based streaming with early break. It includes full local development tooling (Docker Postgres, Wrangler, Vitest integration tests) and configuration files (\prisma.config.ts\, \wrangler.jsonc\, \vitest.config.ts\) to exercise the new serverless API surfaces.
examples/prisma-8-cloudflare-worker · high confidence
New Cloudflare Workers example demonstrating Prisma 8 SQL and ORM capabilities
This location introduces a new example application for Cloudflare Workers that showcases Prisma 8 features. The worker implements routes for SQL queries and ORM operations (users, posts), transaction handling (commit/rollback), and streaming large result sets via server-side cursors. It also includes a temporal global type definition and imports the temporal polyfill, indicating support for temporal data types in this environment.
examples/prisma-8-cloudflare-worker/src · high confidence
New IR types and utilities for namespace-scoped entity coordinates and contract views
The framework introduces a structured way to address and view storage entities using \EntityCoordinate\ tuples (plane, namespace, kind, name) and a \coordinateKey\ for collision-safe lookups. New \elementCoordinates\ and \domainElementCoordinates\ generators allow structural, family-agnostic walks of all named entities across storage and domain namespaces. A new \contract-view\ module provides \SingleNamespaceView\ and \NamespacedEntities\ types, along with \buildSingleNamespaceView\ and \buildNamespacedEntities\ functions, to project storage namespaces into a typed view where built-in kinds (like 'table' or 'collection') are promoted to top-level accessors and pack-contributed kinds remain under an \entries\ map. Supporting types include \IRNode\/\IRNodeBase\ for a common IR class hierarchy with a \freezeNode\ helper, \Namespace\/\NamespaceBase\ with an \UNBOUND\_NAMESPACE\_ID\ sentinel for late-bound slots, and \hydrateNamespaceEntities\ for constructing IR class instances from raw JSON maps using registered \EntityKindDescriptor\s.
packages/1-framework/1-core/framework-components/src/ir · high confidence
New MongoDB blog leaderboard example with typed aggregation pipeline
Added a new \mongo-blog-leaderboard\ example that demonstrates the typed aggregation pipeline DSL end-to-end against a discriminated Post collection. The example uses the canonical \mongo()\ runtime facade and includes a focused pipeline query that ranks authors by post count, attaches the most recent post date, and embeds the author document via \$lookup\. It also provides the necessary project scaffolding, including a PSL schema with discriminator and index declarations, a \prisma.config.ts\ using \definePrismaConfig\, seed data, and integration tests.
examples/mongo-blog-leaderboard · high confidence
New MongoDB demo application with contract-first ORM and caching
Added a new \examples/mongo-demo\ application that demonstrates the Prisma 8 contract-first approach with MongoDB. The demo includes a Vite-based React UI, a PSL schema (\src/contract.prisma\), and a configuration file (\prisma.config.ts\) that wires the MongoDB runtime. It showcases the full pipeline from schema authoring to contract emission and runtime execution, including integration tests against an in-memory MongoDB replica set. The example also highlights specific features like reference resolution via \$lookup\, migration support for indexes, and opt-in caching middleware integration.
examples/mongo-demo · high confidence
New Next.js API routes for listing, retrieving, and fetching random products
The retail-store example now exposes Next.js API routes under /api/products to support product data access. A GET /api/products endpoint returns the full product catalog, while GET /api/products/\[id\] retrieves a single product by ID and returns a 404 if it is not found. Additionally, GET /api/products/random accepts a count query parameter (defaulting to 4, constrained to integers between 1 and 24) and returns that many random products, returning a 400 error for invalid inputs. These routes use the existing data and database helpers to serve product information to the frontend.
examples/retail-store/app/api/products · high confidence
New ORM client examples for SQLite demo
The \examples/prisma-8-demo-sqlite/src/orm-client\ directory now includes a set of new TypeScript modules demonstrating ORM usage patterns. These examples cover basic entity creation (users, posts), relational queries (including posts by user, tags by post, and reverse includes), many-to-many relationship management (connecting, disconnecting, and creating tags alongside posts), and filtering relations using \.some()\, \.none()\, and \.every()\. Additionally, the directory introduces examples for aggregate precision handling, showing how to use \countBigInt\, \sumBigInt\, and guarded integer decoding to handle large numbers and potential overflow errors in SQLite.
examples/prisma-8-demo-sqlite/src/orm-client · high confidence
New PSL formatter with configurable indentation and line endings
The PSL parser package now includes a new formatting module that parses Prisma Schema Language (PSL) source code and re-emits it with consistent styling. Users can configure the output via \FormatOptions\, specifically choosing between space-based indentation (with a configurable integer width, defaulting to 2) or tab indentation, and selecting between LF or CRLF line endings. The formatter validates these options, throwing structured \PSL.FORMAT\_OPTION\_INVALID\ errors for invalid configurations, and will fail with a \PSL.PARSE\_FAILED\ error if the input contains syntax errors, ensuring that only valid, well-formatted schemas are produced.
packages/1-framework/2-authoring/psl-parser/src/format · high confidence
New PSL language server playground with multi-file scratch projects
A new development playground application has been added to allow interactive editing of PSL schemas with live language server feedback. The app serves a Monaco-based editor and bridges WebSocket connections to the local Prisma CLI's language server process. It automatically manages a persistent, multi-file scratch project (including cross-file relations and namespaces) that is seeded on first run and preserved across restarts, enabling users to experiment with schema features without affecting their actual workspace.
apps/lsp-playground/src · high confidence
New PSL printer for declarative contract serialization
The \psl-printer\ package now provides a generic printer that converts the internal PSL AST into a Prisma 8-compatible schema document. It handles top-level declarations and namespaced blocks, resolves cross-namespace foreign key dependencies for stable ordering, and supports extension-contributed blocks via a descriptor map. The output includes a \// use prisma-8\ header and structured error handling for invalid contributions, enabling the authoring plane to serialize contracts that round-trip correctly.
packages/1-framework/2-authoring/psl-printer/src · high confidence
New ParadeDB demo application for end-to-end search testing
Added a new \examples/paradedb-demo\ application that demonstrates the \@internal/extension-paradedb\ against a live ParadeDB server. This demo exercises five match-mode operators (\paradeDbMatch\, \paradeDbMatchAny\, \paradeDbMatchAll\, \paradeDbTerm\, \paradeDbPhrase\), relevance scoring (\paradeDbScore\), and typmod casts (\paradeDbFuzzy\, \paradeDbBoost\, etc.), along with chained proximity queries. It includes a Docker Compose setup for the database, a Prisma configuration using the ParadeDB extension, and scripts to initialize the database, seed data, and run various search queries.
examples/paradedb-demo · high confidence
New PostGIS spatial query examples for location-based searches
The \examples/prisma-8-postgis-demo/src/queries\ directory now includes six new TypeScript modules demonstrating spatial queries using the Prisma ORM with PostGIS. These examples cover finding cafes within a bounding box (\find-cafes-in-bbox\), within a neighborhood polygon (\find-cafes-in-neighborhood\), near a specific point with distance calculation (\find-cafes-near-point\), within a specific radius (\find-cafes-within-radius\), reverse geocoding to find the containing neighborhood (\find-neighborhood-for-point\), and finding routes that intersect a given geometry (\find-routes-intersecting\).
examples/prisma-8-postgis-demo/src/queries · high confidence
New PostgreSQL bundle-size fixture with generated contract and client
Added a new example fixture at \examples/bundle-size/src/postgres\ that demonstrates the Prisma ORM's contract-based code generation for PostgreSQL. The change introduces generated TypeScript types (\contract.d.ts\) and a JSON contract manifest (\contract.json\) defining a \Note\ model in the \public\ namespace, along with a \db.ts\ entry point that instantiates the Postgres client using \contractFromJson\. This fixture serves as a baseline for measuring bundle size with the new typed contract system.
examples/bundle-size/src/postgres/generated · high confidence
New Prisma 8 Cloudflare Worker example with typed contracts and serverless client
The \examples/prisma-8-cloudflare-worker/src/prisma\ directory now contains a complete Prisma 8 setup for Cloudflare Workers, featuring a \contract.prisma\ schema that defines models (User, Post, Task with Bug/Feature inheritance) and enums, alongside generated \contract.d.ts\ and \contract.json\ type definitions. The \db.ts\ file demonstrates a serverless client configuration using \@prisma/orm-postgres/serverless\, integrating the typed contract via \contractFromJson\, custom collection classes, and middleware for row limits and latency budgets.
examples/prisma-8-cloudflare-worker/src/prisma · high confidence
New Prisma 8 PostGIS demo application
The Prisma 8 PostGIS demo application has been added to the examples directory, providing a Next.js-based interface for exploring geospatial queries against a San Francisco dataset. The app features a client-side interactive map (using Leaflet) that visualizes cafes, neighborhoods, and routes, allowing users to run six distinct spatial queries: finding nearby cafes, filtering by radius, reverse geocoding neighborhoods, checking containment within SoMa, detecting route intersections with closures, and bounding-box filtering for map panning. The implementation includes a robust database layer that handles PostGIS version detection and attaches pool-level error handlers to prevent crashes from dropped idle connections, alongside a comprehensive UI with query metadata, code snippets, and responsive styling.
examples/prisma-8-postgis-demo/app · high confidence
New Prisma 8 SQLite demo application with SQL builder and ORM capabilities
The \examples/prisma-8-demo-sqlite\ directory now contains a complete, runnable demo application for Prisma 8 on SQLite. This includes a CLI entry point (\main.ts\) that exposes commands for listing users, creating users via both the ORM and SQL builder, managing many-to-many relationships (posts and tags), and demonstrating integer representation and aggregate precision edge cases. The demo features a seed script (\seed.ts\) to populate the database with sample data, an application configuration loader (\app-config.ts\) using ArkType for environment validation, and dedicated modules for ORM client operations, SQL query building, and transactional logic (such as atomic post creation with quota checks).
examples/prisma-8-demo-sqlite/src · high confidence
New Prisma 8 SQLite demo contract with explicit type handling
The \examples/prisma-8-demo-sqlite/prisma\ directory now includes a \contract.ts\ file that defines the data model for a SQLite-based demo application. This contract explicitly demonstrates how Prisma 8 handles integer representations in SQLite, specifically using \BigIntNumber\ for fields like \viewCount\ which are stored as INTEGERs but read as JavaScript numbers, while \impressionCount\ uses the \bigintColumn\ adapter. It also defines models for Users, Posts, Tags, and a many-to-many join table \PostTag\, including explicit SQL table names and foreign key constraints.
examples/prisma-8-demo-sqlite/prisma · high confidence
New Prisma 8 demo examples for SQLite and PostgreSQL workflows
The \examples/prisma-8-demo\ and \examples/prisma-8-demo-sqlite\ directories now provide runnable reference applications for Prisma 8. The PostgreSQL demo demonstrates both the emitted contract workflow (using \contract.json\ and \contract.d.ts\) and the TypeScript-native no-emit workflow, covering ORM client features like polymorphic includes, full-text search, caching, and many-to-many relations. The new SQLite demo showcases SQLite-specific behaviors, including integer representation codecs (\BigIntNumber\ vs \BigInt\), aggregate precision guards, and atomic check-then-act transactions. Also in this area: 3 commits (0 fixes) modifying examples.
examples/prisma-8-demo/fixtures, examples/prisma-8-demo/src, examples/prisma-8-demo/test · medium confidence · unverified
New Prisma 8 examples for Cloudflare Workers and PostGIS spatial queries
Added two new example projects demonstrating Prisma 8 capabilities: a Cloudflare Worker example using the new \@prisma/orm-postgres/orm-client\ with typed collections, and a PostGIS demo featuring spatial data seeding, database reset scripts, and configuration validation via ArkType. The PostGIS example includes seed data for San Francisco cafes, neighborhoods, and routes, while the Cloudflare Worker example illustrates ORM client usage with a note on a known limitation regarding class-table inheritance.
examples/prisma-8-cloudflare-worker/src/orm-client, examples/prisma-8-postgis-demo/scripts, examples/prisma-8-postgis-demo/src · high confidence
New SQL DSL query examples in the Prisma 8 demo
The \examples/prisma-8-demo/src/queries\ directory now includes a comprehensive set of TypeScript files demonstrating the new SQL DSL capabilities. These examples cover basic CRUD operations, self-joins with non-relation predicates (cross-author similarity), full-text search with relevance ranking and highlighting, and pgvector cosine distance similarity searches. The demo also illustrates advanced features such as whole-query raw SQL execution, embedding raw SQL fragments within the typed builder, prepared statement usage, and caching via annotations. Additionally, it includes guardrail demonstrations for row budget enforcement and linting rules (e.g., blocking DELETE without WHERE).
examples/prisma-8-demo/src/queries · high confidence
New Supabase example with RLS and cross-contract FK support
Added a new \examples/supabase\ walking skeleton that demonstrates Prisma 8 integration with Supabase, including Row Level Security (RLS) policies, cross-contract foreign keys to \auth.users\, and role-bound runtime queries (\asUser\, \asAnon\, \asServiceRole\). The example includes configuration files (\prisma.config.ts\, \vitest.config.ts\, \tsconfig.json\) and an acceptance test suite (\real-supabase.acceptance.test.ts\) that runs against a live Supabase stack to verify RLS flows and JWT verification via JWKS.
examples/supabase · high confidence
New Supabase example with Row Level Security and typed contracts
The \examples/supabase\ directory now includes a complete walking skeleton demonstrating the ORM with Supabase. This includes a \contract.prisma\ schema defining a \Profile\ model with explicit Row Level Security (RLS) policies for authenticated and anonymous users, alongside generated contract artifacts (\contract.d.ts\, \contract.json\) that enforce type safety. The example also provides TypeScript query utilities (\profile-queries.ts\, \session-queries.ts\) showing how to perform role-bound inserts and read Supabase internal session data using the typed SQL builder.
examples/supabase/src · high confidence
New TypeScript contract emitter generates typed .d.ts declarations from contract JSON
The framework now includes a new emitter module that generates TypeScript declaration files (contract.d.ts) alongside the canonical contract JSON. This emitter validates contract structure (e.g., requiring nullability flags on to-one relations), handles multi-namespace models and value objects, and produces strongly-typed interfaces for models, enums, and relations based on codec lookups. It ensures type safety by deriving field types from storage codecs and supports namespace-qualified model references.
packages/1-framework/3-tooling/emitter/src · high confidence
New TypeScript source-rendering utilities in ts-render package
The ts-render package now provides core utilities for generating TypeScript source code, including a JSON-to-TS printer (jsonToTsSource) that safely converts JSON-compatible values into TS literals, and an import renderer (renderImports) that aggregates and deduplicates import requirements into valid TypeScript import statements. The package also exports helpers for rendering string literals (tsStringLiteral, tsQuotedTextSource) and abstracts import requirements via the ImportRequirement interface and TsExpression base class, enabling downstream emitters to declare their module dependencies declaratively.
packages/1-framework/1-core/ts-render/src · high confidence
New Vite plugin for automatic Prisma 8 contract artifact emission
The \@internal/vite-plugin-contract-emit\ package is introduced to automatically generate Prisma 8 contract artifacts (\contract.json\ and \contract.d.ts\) during development. Integrated into the Vite dev server, the plugin emits these artifacts on startup and re-emits them when contract authoring files change, supporting Vite versions 7 and 8. It features configurable debouncing, serialized re-emission to handle rapid edits, and error overlays to surface issues directly in the browser.
packages/1-framework/3-tooling/vite-plugin-contract-emit · high confidence
New \`prisma.config.ts\` schema and validation for the ORM section
The config loader now introduces a dedicated \orm\ section in \prisma.config.ts\, defining subsections for family, target, adapter, driver, extensions, db, contract, migrations, and formatter. It enforces strict validation rules, including ensuring all descriptors share the same \familyId\ and \targetId\, and prevents conflicts where contract source inputs overlap with output artifacts. Relative paths are automatically resolved against the config file location, and diagnostics are scoped to specific sections so commands can fail on relevant errors while ignoring unrelated configuration issues.
packages/1-framework/3-tooling/config-loader/src · high confidence
New contract authoring core types and helpers
The contract authoring package now exposes a new set of core types and runtime helpers that power the authoring surface. This includes strict TypeScript argument typing for data types and object properties, a generic capability-matrix merge helper for cross-pack configuration, and scaffolding to compose authoring namespaces (field presets, types, and entity types) from extension packs. It also introduces structured error handling for contract authoring (e.g., enum validation), enum member encoding and validation against codecs, and logic to derive to-one relation nullability from local field nullability and reference ownership.
packages/1-framework/2-authoring/contract/src · high confidence
New contributor guide and journey tests for Prisma 8 agent skills
The \skills/\ directory now includes \DEVELOPING.md\, a contributor guide that defines authoring rules for Prisma 8 agent skills—such as verifying tool surfaces against the framework source, teaching concepts over rigid procedures, and using façade-only imports—and \journey-tests/\, a suite of Markdown checklists that validate end-to-end agent workflows like onboarding, migration review, and capability-gap handling. This documentation establishes the structural and behavioral standards for maintaining the consolidated \prisma-8\ skill cluster.
skills · high confidence
New contributor-facing agent skills for PR workflows and code review
The \skills-contrib\ directory now includes several new agent skills that guide external contributors and maintainers through the pull request and review process. The \contrib-pr\ skill provides a step-by-step workflow for external contributors to open high-quality PRs, including verifying test suites, ensuring DCO sign-offs, and composing conventional-commit titles. The \create-pr\ skill assists maintainers in creating PRs with Linear-ticket-prefixed titles and decision-led, narrative descriptions. Additionally, the \github-review-iteration\ skill orchestrates an iterative PR review loop, delegating triage and implementation tasks to sub-agents to clear review comments efficiently. These skills encode project contribution standards and review practices into actionable agent workflows.
skills-contrib · high confidence
New control-plane framework components for contract management and migration planning
The framework now exposes a dedicated control-plane layer in \framework-components/src/control\ that standardizes how contracts, migrations, and schema verification are handled. This includes a content-addressed contract snapshot store (using 64-character hex storage hashes for directory names), a unified \ContractSerializer\ SPI for JSON-to-class round-tripping, and capability-based interfaces for migration planning, operation previewing, and schema diffing. Users benefit from consistent, family-agnostic types for migration operations (additive, widening, destructive, data), structured verification results with dotted error codes, and a tree-based schema view for CLI visualization, all wired through a centralized \ControlStack\ that assembles codecs, data types, and authoring contributions.
packages/1-framework/1-core/framework-components/src/control · high confidence
New db init, schema, sign, update, and verify commands
The CLI now includes a new set of ORM database commands: \db init\ bootstraps a database to match the current contract and signs it; \db schema\ inspects the live database schema as a tree; \db sign\ verifies the database schema against the contract and updates the contract reference; \db update\ applies migration plans with support for destructive changes and data-loss flags; and \db verify\ checks for schema drift and contract mismatches. These commands replace the previous migration-focused workflow with a contract-first approach, providing better error handling, structured output, and explicit consent for destructive operations.
packages/1-framework/3-tooling/cli/src/orm/db · high confidence
New e-commerce storefront with product search, pagination, and cart integration
The retail-store example now includes a fully functional Next.js UI for browsing and managing a shopping cart. Users can view a paginated product catalog, search for items by name, and see their cart item count in the navbar badge. The app uses Tailwind CSS for styling and integrates a CartProvider context to manage cart state across the application.
examples/retail-store/app · high confidence
New example demonstrating Prisma 7 to 8 adoption with direct schema reading
The \examples/prisma7-adoption\ directory now provides a complete, runnable guide for upgrading from Prisma 7 to Prisma 8. It demonstrates a phased migration where Prisma 8 reads the existing Prisma 7 \schema.prisma\ directly via \prisma7Schema(...)\ instead of requiring a manual \contract infer\ and edit step. The example includes configuration for both runtimes (\prisma.config.ts\ and \prisma7.config.ts\), source code showing how to instantiate and use both clients side-by-side, and tests that verify the full lifecycle: initial setup, route migration, and the handover of migration ownership to Prisma 8 while Prisma 7 continues to generate its client.
examples/prisma7-adoption · high confidence
New execution-layer infrastructure for activity lifecycle, middleware, and abort handling
The framework-components package introduces a new execution layer that structures runtime operations as hierarchical activities (client, statement, transaction) with a defined lifecycle (start, end, finalize) and middleware hooks. This includes a new \AsyncIterableResult\ class to manage single-consumption async iterators for query results, a \raceAgainstAbort\ helper to ensure cooperative cancellation of in-flight work against \AbortSignal\s, and a \RuntimeCore\ base class that orchestrates the statement execution pipeline (compile, lower, encode, driver). The diff also adds support for mutation default generators with scoped stability (field, row, query) and an execution stack system to assemble target, adapter, driver, and extension instances.
packages/1-framework/1-core/framework-components/src/execution · high confidence
New internal PSL printer package for Prisma 8 schema serialization
The \@internal/psl-printer\ package has been added to convert the Prisma Schema Language AST (\PslDocumentAst\) into deterministic, valid PSL text output. This component preserves mapping attributes (such as \@map\ and \@@map\) and ensures stable snapshot testing by generating consistent output. It is an internal implementation detail of Prisma 8, intended to support the runtime and CLI operations like \prisma contract print\, rather than being a public API for direct consumption.
packages/1-framework/2-authoring/psl-printer · high confidence
New internal migration-tools package for Prisma 8 on-disk persistence and integrity
The \@internal/migration-tools\ package has been introduced as an implementation detail of Prisma 8 to handle on-disk migration persistence, hash verification, and history reconstruction. It manages the storage of migration packages (containing \migration.json\ and \ops.json\) and uses content-addressed SHA-256 hashing to detect tampering or corruption. The package exposes subpaths for metadata, package I/O, graph operations, hashing, and error handling, and is intended to be used via the \@prisma/cli\ and database facades rather than direct dependency.
packages/1-framework/3-tooling/migration · high confidence
New internal package defines the published npm surface and import resolution logic
A new private package, \@internal/publish-surface\, has been added to map internal workspace packages to the published \@prisma/orm-\*\ entrypoints defined in ADR 242. This package provides the canonical mapping table that determines how internal modules are exposed as subpath entrypoints in published shells, and it implements the import-root resolution logic that translates internal specifiers into the correct public names based on whether the application uses \internal\, \facade\, or \platform\ modes. By centralizing this mapping and resolution, the package ensures that generated code imports resolve correctly at runtime without requiring the application to depend on transitive packages, while keeping the core framework code independent of specific family or target naming conventions.
packages/0-shared/publish-surface · high confidence
New internal ts-render package for TypeScript source generation
The \@internal/ts-render\ package has been added to provide shared utilities for generating hand-editable TypeScript source files, primarily supporting the Postgres and Mongo migration-authoring surfaces. It introduces a \TsExpression\ abstract base class for building hierarchical TypeScript AST nodes and a \jsonToTsSource\ function for converting JSON-compatible values into TypeScript source text. This package is an internal implementation detail of Prisma 8 and is not intended for direct external consumption; users should rely on \@prisma/cli\ and database facades instead.
packages/1-framework/1-core/ts-render · high confidence
New migration aggregate layer for contract space planning and integrity
The migration tooling now uses a new \aggregate\ module to manage contract spaces, introducing a tolerant loading phase that reads migration packages, refs, and head refs from disk without throwing on content mismatches or unparseable files. Integrity violations (such as missing head refs, duplicate migration hashes, or unreadable contracts) are collected and surfaced rather than aborting the load. The planner supports three strategies: resolving a recorded migration path, fabricating a plan from a schema diff, or declaring a no-op state for all-external extension spaces, with the app space defaulting to diff-based planning. This centralizes migration planning, integrity checking, and contract resolution within the aggregate.
packages/1-framework/3-tooling/migration/src/aggregate · high confidence
New migration tooling infrastructure for contract-space integrity and pathfinding
The migration tooling package now includes a comprehensive set of new modules to support content-addressed contract snapshots, integrity verification, and graph-based migration planning. This includes a content-addressed snapshot store (\contract-snapshot-store.ts\) that verifies contract JSON integrity against storage hashes, a migration graph implementation (\graph.ts\, \graph-ops.ts\) for BFS traversal and pathfinding, and helpers to compute apply paths (\compute-extension-space-apply-path.ts\) and order cross-space migrations (\concatenate-space-apply-path.ts\). The tooling also introduces structured error handling (\errors.ts\) with specific codes for migration failures, integrity violation definitions (\integrity-violation.ts\), and invariant derivation logic (\invariants.ts\). These changes provide the foundational primitives for verifying migration consistency, planning safe upgrade paths, and managing multi-space contract states.
packages/1-framework/3-tooling/migration/src · high confidence
New programmatic Control API and CLI export surfaces
The CLI package now exposes a comprehensive programmatic Control API and standardized configuration types for external consumers. Users can access the \ControlClient\ factory and associated types (e.g., \ControlStack\, \MigrationPlanSubjects\) to perform control-plane operations like contract emission, migration planning, and database initialization (\db init\, \db update\, \db verify\) without invoking the CLI directly. Additionally, the package re-exports configuration types (\ContractConfig\, \PrismaNextConfig\, \defineConfig\) and testing utilities (\createFixtureControlClient\) to support integration testing and custom tooling that interacts with the Prisma ORM engine.
packages/1-framework/3-tooling/cli/src/exports · high confidence
New programmatic ControlClient API for ORM operations
The CLI now exposes a programmatic \ControlClient\ API (via \createControlClient\) that allows external tooling to manage ORM lifecycle and database operations. This client handles initialization, driver connection management, and delegates to framework components for operations such as \dbInit\, \dbUpdate\, \dbVerify\, \dbSign\, \migrate\, and contract emission. It introduces a structured, span-based progress event model for monitoring operation status and includes contract enrichment logic to merge framework capabilities and extension metadata into the final contract output.
packages/1-framework/3-tooling/cli/src/control-api · high confidence
New public ORM packages and extensions for Prisma 8
This release publishes a new set of public packages and extensions for Prisma 8, including the core \@prisma/orm-framework\, database family packages (\@prisma/orm-family-sql\, \@prisma/orm-family-mongo\), and database-specific facade packages (\@prisma/orm-mongo\, \@prisma/orm-postgres\, \@prisma/orm-sqlite\, \@prisma/orm-mysql\). It also introduces several new extensions: \@prisma/orm-extension-middleware-cache\ for opt-in query caching, \@prisma/orm-extension-arktype-json\ for typed JSON columns, \@prisma/orm-extension-pgvector\ for vector similarity search, \@prisma/orm-extension-postgis\ for geospatial data, \@prisma/orm-extension-paradedb\ for full-text search, and \@prisma/orm-extension-supabase\ for Supabase platform integration. These packages provide the foundational components and specialized capabilities for building applications with Prisma 8.
packages/9-public · high confidence
New transaction utility for enforcing post creation quotas
The \examples/prisma-8-demo-sqlite/src/transactions\ directory now includes \add-posts-within-quota.ts\, which provides a reusable function to atomically check a user's existing post count against a limit (5 posts) before inserting new posts. This utility demonstrates the Prisma 8 pattern of mixing SQL aggregate queries (for the count check) with ORM create operations within a single transaction, ensuring that concurrent requests cannot exceed the quota.
examples/prisma-8-demo-sqlite/src/transactions · high confidence
New typed AST wrappers for PSL schema elements
The PSL parser now exposes a set of typed AST wrapper classes in the \psl-parser\ package, providing structured access to schema components such as models, composite types, namespaces, mixins, attributes, expressions, and type annotations. This allows consumers to programmatically inspect and navigate the parsed schema structure with type safety, supporting features like qualified name resolution, attribute argument parsing, and type annotation analysis (including list and optional element handling).
packages/1-framework/2-authoring/psl-parser/src/syntax/ast · high confidence
New unified reference resolution for contracts and migrations
The migration tooling now supports a unified grammar for resolving references to contracts and migrations. Users can specify targets using reserved aliases like \@contract\ (the current working contract), \@db\ (the live database marker), and \@empty\ (the empty contract state), as well as full or partial hex hashes, migration directory names, and custom ref names. The system distinguishes between contract-accepting and migration-accepting contexts, providing specific error messages and fixes when the wrong grammar is used (e.g., using \^\ syntax for migrations). This enables more flexible and precise targeting of migration steps and contract states in commands.
packages/1-framework/3-tooling/migration/src/refs · high confidence
New upgrade-instructions system for managing Prisma 8 migration guidance
The repository introduces a structured lifecycle for upgrade instructions, allowing feature PRs to contribute independent, unversioned fragments that are assembled into published guides during release preparation. This system replaces ad-hoc documentation with a formal process where pending instructions in \upgrade-instructions/pending/\ are synthesized into audience-specific guides (e.g., \skills/prisma-8/upgrading/...\) and archived in \upgrade-instructions/releases/\. The diff includes the core \README.md\ defining this workflow, along with specific pending instruction fragments for Prisma 8 extensions, such as handling closed client members (which now reject promises instead of throwing), renaming PostgreSQL temporal types (e.g., \Timestamptz\ to \TimestamptzTemporal\), and updating MongoDB contract targets. It also includes archived instructions for the 8.0.0-rc.11 to 8.0.0-rc.12 transition, covering changes like the \@prisma/cli-engine\ version bump, codec descriptor data type requirements, and emit deserialization needs. Also in this area: 4 commits (1 fix) modifying upgrade-instructions.
upgrade-instructions · medium confidence · unverified
New utility functions and types for the foundation utils package
The \packages/1-framework/0-foundation/utils/src\ module now exports a suite of new utility functions and types, including \abortable\ for canceling async operations, \isArrayEqual\ for strict array comparison, \assertDefined\ and \invariant\ for runtime checks, \canonicalStringify\ for deterministic object serialization, \blindCast\ and \castAs\ for type assertions, \ifDefined\ for conditional object spreading, \hashContent\ for SHA-512 hashing, \InternalError\ for framework bugs, \Result\ types for handling success/failure, \structuredError\ for typed error codes, \suppressIdleConnectionErrors\ to prevent crashes from dropped connections, and various text and type helpers.
packages/1-framework/0-foundation/utils/src · high confidence
PSL language server adds comprehensive attribute argument completion and signature help
The language server now provides intelligent completion for PSL attribute arguments, including named keys, positional slots, and values. It resolves the expected argument grammar for any attribute (field, model, or block level) and offers context-aware suggestions for scalars, function calls, field references, and entity references. The server also generates snippet-based completions that automatically insert required arguments and placeholders, and supports parameter hints for function-style attributes, significantly improving the authoring experience for PSL schema definitions.
packages/1-framework/3-tooling/language-server/src · high confidence
ParadeDB demo now uses the new Prisma contract-based ORM with ParadeDB extension support
The ParadeDB demo application has been migrated to use the new Prisma contract-based ORM system. The \contract.d.ts\ and \contract.json\ files are now generated artifacts defining the data model (an \Item\ model in the \public\ namespace with \id\, \category\, \description\, and \rating\ fields) and storage schema, including a ParadeDB BM25 full-text search index. The \db.ts\ file now instantiates the database client using \contractFromJson\ and explicitly registers the \@prisma/orm-extension-paradedb\ extension, enabling ParadeDB-specific query operations alongside standard PostgreSQL capabilities.
examples/paradedb-demo/src/prisma · high confidence
PostGIS demo migration adds spatial models and extension support
The \prisma-8-postgis-demo\ example now includes a migration that installs the PostGIS extension and creates three application tables—\cafe\, \neighborhood\, and \route\—to store geographic data. The schema defines a \WgsGeometry\ type (WGS84, SRID 4326) used for the \location\, \boundary\, and \path\ columns, with primary keys auto-generated via \@onCreate(uuid()))\. The migration logic explicitly creates these tables with \geometry(Geometry,4326)\ columns, and the generated contract snapshots reflect the new PostGIS codec types and capabilities. Also in this area: 3 commits (0 fixes) modifying examples.
examples/prisma-8-postgis-demo/migrations/snapshots/2db551a8a5619d0d97710f29130eaea0eccbdd5238f015ee9d18408d438e0f8a · medium confidence · unverified
Prisma 8 ORM demo introduces typed contracts, full-text search, and middleware
The Prisma 8 demo now uses a new contract-based ORM model where the schema is defined in \contract.prisma\ and generates a typed \contract.d.ts\ and \contract.json\. This enables type-safe ORM queries with support for PostgreSQL full-text search via \@@fullTextIndex\, new integer types (\BigIntNumber\, \UnboundedInt\), and vector embeddings via \pgvector\. The demo also showcases middleware capabilities, including a caching layer, query budgeting/linting, and a custom slow-query warning middleware that logs latency for statements exceeding a threshold.
examples/prisma-8-demo/src/prisma · high confidence
Prisma 8 PostGIS demo introduces typed contract-based ORM with PostGIS geometry support
The Prisma 8 PostGIS demo now uses a new contract-based ORM approach, defining models (Cafe, Route, Neighborhood) with PostGIS geometry fields (WgsGeometry) in a new contract.prisma schema. This generates typed contract files (contract.d.ts, contract.json) that include PostGIS codec types and query operations, and a db.ts client that loads the contract via contractFromJson and registers the PostGIS extension. Users can now work with spatial data using strongly-typed geometry types and PostGIS-specific query operations within the Prisma 8 ORM.
examples/prisma-8-postgis-demo/src/prisma · high confidence
Prisma 8 language server introduces comprehensive PSL editing capabilities
The Prisma 8 language server now provides full Language Server Protocol support for PSL schemas, including diagnostics, formatting, code completion, attribute signature help, hover information, go-to-definition, find references, and rename. The server manages project membership based on configuration globs and the \// use prisma-8\ directive, supporting both pull-based and push-based diagnostic delivery modes. It features lazy document parsing, multi-file schema awareness, and detailed semantic analysis for models, fields, attributes, and functions.
packages/1-framework/3-tooling/language-server · high confidence
Unified codec registry and aggregate descriptor system
The framework introduces a unified codec descriptor system and a declarative aggregate resolution mechanism. A new \CodecDescriptor\ interface and \CodecImpl\ base class centralize codec metadata (traits, parameter schemas, type renderers) and runtime conversion logic, replacing fragmented registration patterns. Concurrently, \AggregateDescriptor\ types and the \settleAggregateOverloads\ function provide a structured way to define and resolve aggregate operations (like count or sum) against specific codecs or traits, ensuring consistent type resolution between the runtime and the emitted contract definitions.
packages/1-framework/1-core/framework-components/src/shared · high confidence
Removals
Remove Zod-based schema validation from relational-ir
The \relational-ir\ package no longer exports schema validation logic or types. The \schema.ts\ module, which previously used Zod to define and validate field types, model definitions, and complete schemas, has been deleted along with its associated tests. This removes the runtime validation capability for schema structures from this package.
packages/relational-ir · high confidence
Removed PSL schema parser and CLI tooling
The \packages/psl\ package has been removed, eliminating the Prisma Schema Language (PSL) parser, its associated CLI (\psl emit\), and the underlying lexer, parser, and AST definitions. Users can no longer parse PSL schema files or generate AST representations from this package.
packages/psl · high confidence
Removed legacy PSL-to-IR prototype demo files
The example application's prototype implementation has been removed, specifically deleting the Prisma Schema Language (PSL) definition, the database connection setup, the TypeScript query builders, and the main entry point that demonstrated parsing PSL to an Intermediate Representation (IR). This cleanup eliminates the old schema and query execution logic in favor of the new migration and contract verification workflow.
examples/todo-app · high confidence
Removed legacy SQL query builder and compiler
The \packages/sql\ module has removed its previous SQL query builder implementation, including the \QueryBuilder\ class, the \compileToSQL\ function, and the associated type definitions (\QueryAST\, \FieldExpression\, etc.). This change eliminates the ability to construct and compile SQL queries using the old fluent API (e.g., \sql().from(...).select(...).where(...)\), effectively removing this feature from the package.
packages/sql · high confidence
Removed legacy runtime package
The legacy runtime package located at packages/runtime has been deleted, removing the DatabaseConnection class, its connection configuration interface, and the associated build configuration (tsconfig.json). This eliminates the previous implementation that handled PostgreSQL connections, schema verification against the IR, and SQL query execution via Prisma's relational IR and SQL packages.
packages/runtime · high confidence
Removed schema-emitter package and its TypeScript configuration
The \packages/schema-emitter\ directory has been completely removed from the repository. This deletion eliminates the functionality that previously generated TypeScript type definitions and runtime schema objects from Prisma schema ASTs, including the removal of the main entry point, IR emitter, types emitter, and the associated \tsconfig.json\ build configuration.
packages/schema-emitter · high confidence
API
Expose config loader internals and ORM section utilities
The config loader package now explicitly exports its core loading functions (such as loadConfig, buildLoadedConfig, and loadConfigForSections) along with the PrismaNextConfig type and contract input expansion utilities. Additionally, it exposes the ORM section schema, validation logic, and constants, allowing consumers to programmatically access, validate, and interact with the ORM configuration section directly rather than relying solely on the black-box loadConfig entry point.
packages/1-framework/3-tooling/config-loader/src/exports · high confidence
New public API surface for migration tooling internals
The migration tooling package now exposes a comprehensive set of internal capabilities through new entry points in the \exports\ directory. Users and internal consumers can now directly access the contract space aggregate loader and integrity verification logic, the migration graph planner and pathfinding algorithms, and helpers for reading/writing migration metadata and contract snapshots. This change centralizes access to core migration infrastructure components such as reference resolution, space layout utilities, and error types, making these previously internal implementation details part of the stable public interface.
packages/1-framework/3-tooling/migration/src/exports · high confidence
Standardized public API exports for the framework emitter
The emitter tooling now exposes a consolidated set of types and functions through its main entry point. Users can import core emission logic via the \emit\ function and \EmitStackInput\ type, access generated artifact paths, and utilize shared domain-level utilities such as \deduplicateImports\, \generateCodecTypeIntersection\, and \generateContractDts\. This change centralizes the public interface for interacting with the emitter's code generation capabilities.
packages/1-framework/3-tooling/emitter/src/exports · high confidence
Architecture
PSL parser package exports reorganized into dedicated modules
The \psl-parser\ package has restructured its public API by moving exports from the root \index.ts\ into specific, named entry points (\format\, \interpret\, \syntax\, \test\, and \tokenizer\). This change allows consumers to import only the functionality they need—such as parsing, formatting, or attribute interpretation—rather than pulling in the entire parser bundle, which can improve build times and reduce bundle size.
packages/1-framework/2-authoring/psl-parser/src/exports · high confidence
Behavioural changes
1 commit (0 fixes) modifying (repo-wide)
A change to existing behaviour in (repo-wide) — 1 commit, 12 files: “TML-3697: The CLI emits, migrates, verifies and signs against MariaDB, through a new mariadb target that extends MySQL (\#30964)” (refs \#30964).
examples/prisma-8-demo-mariadb, examples/prisma-8-demo-mariadb/migrations · low confidence · unverified
10 commits (0 fixes) modifying examples/prisma-8-demo/prisma
A change to existing behaviour in examples/prisma-8-demo/prisma — 10 commits, 1 file: “Remove enum declaration-order SQL rewriting (\#30223)”; “TML-3712: PostgreSQL gets convenience types DateTime, Date, Time and Duration, and the tools write them (\#30847)”; “feat(psl): write raw SQL column defaults as sql\...\ tagged literals (\#30325)”; and 7 more (refs \#30223, \#30847, \#30325, \#30845, \#30376, …).
examples/prisma-8-demo/prisma · medium confidence · unverified
12 commits (0 fixes) modifying examples/prisma-8-postgis-demo
A change to existing behaviour in examples/prisma-8-postgis-demo — 12 commits, 10 files: “TML-3602: A client takes its contract as a typed value from contractFromJson, so later options are inferred (\#30748)”; “docs: rewrite README for Prisma 8, fix orm init dist-tag, sweep "Prisma Next" prose (\#30248)”; “feat(cli)!: stop publishing the prisma-next CLI — the unified prisma-cli replaces it (\#30005)”; and 9 more (refs \#30748, \#30248, \#30005, \#30037, \#30780, …).
examples/prisma-8-postgis-demo · medium confidence · unverified
2 commits (0 fixes) modifying examples/multi-extension-monorepo/app/migrations, examples/prisma-8-postgis-demo/migrations/snapshots/6e985087b60584f70ad4f223d8926dfe553db727cc4d58524fe5c38628fef393, examples/supabase/migrations
A change to existing behaviour in examples/multi-extension-monorepo/app/migrations, examples/prisma-8-postgis-demo/migrations/snapshots/6e985087b60584f70ad4f223d8926dfe553db727cc4d58524fe5c38628fef393, examples/supabase/migrations — 2 commits, 15 files: “TML-3808: Migration snapshots store contract.d.ts on one line instead of about 1,400 (\#30965)”; “feat(postgres): contracts declare Postgres extensions, so db sign adopts databases that use pgvector, PostGIS or ParadeDB (\#30902)” (refs \#30965, \#30902).
examples/multi-extension-monorepo/app/migrations, examples/prisma-8-postgis-demo/migrations/snapshots/6e985087b60584f70ad4f223d8926dfe553db727cc4d58524fe5c38628fef393, examples/supabase/migrations · medium confidence · unverified
2 commits (0 fixes) modifying examples/prisma-8-postgis-demo/migrations/snapshots/eb97f4c11af6a9444c3f8d1e1c2071f8cf7c8643b44ba9ba51752b10c639b8dc
A change to existing behaviour in examples/prisma-8-postgis-demo/migrations/snapshots/eb97f4c11af6a9444c3f8d1e1c2071f8cf7c8643b44ba9ba51752b10c639b8dc — 2 commits, 2 files: “TML-3772: A Supabase database whose pack extensions live in schema extensions adopts with db sign (\#30956)”; “TML-3808: Migration snapshots store contract.d.ts on one line instead of about 1,400 (\#30965)” (refs \#30956, \#30965).
examples/prisma-8-postgis-demo/migrations/snapshots/eb97f4c11af6a9444c3f8d1e1c2071f8cf7c8643b44ba9ba51752b10c639b8dc · medium confidence · unverified
2 commits (0 fixes) modifying examples/retail-store/migrations
A change to existing behaviour in examples/retail-store/migrations — 2 commits, 8 files: “TML-3808: Migration snapshots store contract.d.ts on one line instead of about 1,400 (\#30965)”; “TML-3762: MongoDB migrations create and drop each index by its name, so two indexes on the same fields can exist together (\#30952)” (refs \#30965, \#30952).
examples/retail-store/migrations · medium confidence · unverified
2 commits (0 fixes) modifying upgrade-instructions/releases/8.0.0-rc.19-to-8.0.0-rc.20/sources/expand-type-aliases
A change to existing behaviour in upgrade-instructions/releases/8.0.0-rc.19-to-8.0.0-rc.20/sources/expand-type-aliases — 2 commits, 2 files: “chore(release): bump to 8.0.0-rc.20 (\#30838)”; “TML-3607: Field presets are removed, and each is written with a type constructor or type alias that stores the same contract (\#30845)” (refs \#30838, \#30845).
upgrade-instructions/releases/8.0.0-rc.19-to-8.0.0-rc.20/sources/expand-type-aliases · medium confidence · unverified
27 commits (0 fixes) modifying examples/prisma-8-demo/src/orm-client
A change to existing behaviour in examples/prisma-8-demo/src/orm-client — 27 commits, 46 files: “variant() selects by discriminator value in the SQL and Mongo ORMs (\#30577)”; “TML-3712: PostgreSQL gets convenience types DateTime, Date, Time and Duration, and the tools write them (\#30847)”; “TML-3715: PostgreSQL Int, BigInt, Float, Decimal, String, Boolean and Bytes choose their database type with storage and as, and the explicit types get the database's names (\#30942)”; and 24 more (refs \#30577, \#30847, \#30942, \#30073, \#30564, …).
examples/prisma-8-demo/src/orm-client · medium confidence · unverified
28 commits (1 fix) modifying packages/2-sql-family
A change to existing behaviour in packages/2-sql-family — 28 commits (1 fix), 1282 files: “TML-3537: Changing a value object or a variant is a migration, and Postgres checks value object and discriminator columns (\#30869)”; “TML-3686, TML-3689, TML-3690: The MongoDB query builder, raw lane and ORM take an execution context like the SQL ones, and runtime types say what they hold (\#30865)”; “TML-3712: PostgreSQL gets convenience types DateTime, Date, Time and Duration, and the tools write them (\#30847)”; and 25 more (refs \#30869, \#30865, \#30847, \#30956, \#31012, …).
packages/2-sql-family · medium confidence · unverified
3 commits (0 fixes) modifying examples/mongo-demo/migrations
A change to existing behaviour in examples/mongo-demo/migrations — 3 commits, 12 files: “TML-3808: Migration snapshots store contract.d.ts on one line instead of about 1,400 (\#30965)”; “TML-3814: MongoDB gets the convenience types DateTime, Date, Time and Duration, and Date becomes a calendar date (\#30989)”; “TML-3762: MongoDB migrations create and drop each index by its name, so two indexes on the same fields can exist together (\#30952)” (refs \#30965, \#30989, \#30952).
examples/mongo-demo/migrations · medium confidence · unverified
3 commits (0 fixes) modifying examples/paradedb-demo/migrations
A change to existing behaviour in examples/paradedb-demo/migrations — 3 commits, 15 files: “TML-3772: A Supabase database whose pack extensions live in schema extensions adopts with db sign (\#30956)”; “TML-3808: Migration snapshots store contract.d.ts on one line instead of about 1,400 (\#30965)”; “feat(postgres): contracts declare Postgres extensions, so db sign adopts databases that use pgvector, PostGIS or ParadeDB (\#30902)” (refs \#30956, \#30965, \#30902).
examples/paradedb-demo/migrations · medium confidence · unverified
3 commits (0 fixes) modifying examples/prisma-8-demo-mysql/migrations
A change to existing behaviour in examples/prisma-8-demo-mysql/migrations — 3 commits, 10 files: “TML-3787: MySQL gets the convenience types DateTime, Date, Time and Duration (\#30950)”; “TML-3808: Migration snapshots store contract.d.ts on one line instead of about 1,400 (\#30965)”; “feat(mysql): publish @prisma/orm-mysql and add a MySQL example app that migrates through it (\#30856)” (refs \#30950, \#30965, \#30856).
examples/prisma-8-demo-mysql/migrations · medium confidence · unverified
3 commits (0 fixes) modifying packages/0-shared/extension-author-tools/bin
A change to existing behaviour in packages/0-shared/extension-author-tools/bin — 3 commits, 1 file: “docs: rewrite README for Prisma 8, fix orm init dist-tag, sweep "Prisma Next" prose (\#30248)”; “feat: an application depends on one Prisma package (ADR 242) (\#29864)”; “refactor: rename every user-facing prisma-next identifier to Prisma 8 (\#30262)” (refs \#30248, \#29864, \#30262).
packages/0-shared/extension-author-tools/bin · medium confidence · unverified
31 commits (0 fixes) modifying examples/prisma-8-demo
A change to existing behaviour in examples/prisma-8-demo — 31 commits, 12 files: “variant() selects by discriminator value in the SQL and Mongo ORMs (\#30577)”; “TML-3602: A client takes its contract as a typed value from contractFromJson, so later options are inferred (\#30748)”; “TML-3431: A Postgres full-text index can span several weighted fields, and the contract stores it as data (\#30562)”; and 28 more (refs \#30577, \#30748, \#30562, \#30248, \#30942, …).
examples/prisma-8-demo · medium confidence · unverified
4 commits (0 fixes) modifying examples/prisma-8-demo/src/app
A change to existing behaviour in examples/prisma-8-demo/src/app — 4 commits, 5 files: “docs: rewrite README for Prisma 8, fix orm init dist-tag, sweep "Prisma Next" prose (\#30248)”; “TML-3233: emit Models namespace + models const; Scalars, Shape, and ResultType on ORM queries (\#30231)”; “feat: an application depends on one Prisma package (ADR 242) (\#29864)”; and 1 more (refs \#30248, \#30231, \#29864, \#30576).
examples/prisma-8-demo/src/app · medium confidence · unverified
4 commits (1 fix) modifying apps/telemetry-backend/migrations/app/20260601T1347\_contract\_hash\_advance
A change to existing behaviour in apps/telemetry-backend/migrations/app/20260601T1347\_contract\_hash\_advance — 4 commits (1 fix), 3 files: “feat: an application depends on one Prisma package (ADR 242) (\#29864)”; “TML-3388: Contract columns store their data type id; one script and db sign upgrade a project (\#30576)”; “Drop the sha256: prefix from all content hashes (TML-2756) (\#1033)”; and 1 more (refs \#29864, \#30576, \#1033).
_apps/telemetry-backend/migrations/app/20260601T1347\_contract\_hash\advance · medium confidence · unverified
45 commits (3 fixes) modifying packages/3-targets
A change to existing behaviour in packages/3-targets — 45 commits (3 fixs), 1861 files: “sql-orm-client: update and delete filtered related rows on many-to-many relations in update() (\#31016)”; “feat: connect() on a client is safe to call again (\#30899)”; “TML-3537: Changing a value object or a variant is a migration, and Postgres checks value object and discriminator columns (\#30869)”; and 42 more (refs \#31016, \#30899, \#30869, \#30865, \#30847, …).
packages/3-targets · medium confidence · unverified
6 commits (0 fixes) modifying apps/telemetry-backend/migrations/app/20260520T1317\_migration
A change to existing behaviour in apps/telemetry-backend/migrations/app/20260520T1317\_migration — 6 commits, 3 files: “TML-2889: typed migration verification checks via the contract-free builder (\#825)”; “chore(migration): strip labels/hints from on-disk migration.json and recompute hashes”; “feat: an application depends on one Prisma package (ADR 242) (\#29864)”; and 3 more (refs \#825, \#29864, \#30576, \#1033).
_apps/telemetry-backend/migrations/app/20260520T1317\migration · medium confidence · unverified
6 commits (0 fixes) modifying examples/prisma-8-postgis-demo/migrations
A change to existing behaviour in examples/prisma-8-postgis-demo/migrations — 6 commits, 4 files: “Migration failures name what a check expected and say whether the database changed (\#30814)”; “TML-3607: Client generators are written @onCreate and @onUpdate, and @default means a database default (\#30780)”; “TML-3496: Migrations skip an operation only when its full effect is in place (\#30752)”; and 3 more (refs \#30814, \#30780, \#30752, \#29864, \#30576, …).
examples/prisma-8-postgis-demo/migrations · medium confidence · unverified
6 commits (0 fixes) modifying examples/prisma-8-postgis-demo/migrations/snapshots/28b5e5f98ce0e148f03e345518c9c53cb7a04a82e8e58de74a87c1b4ae08cf65
A change to existing behaviour in examples/prisma-8-postgis-demo/migrations/snapshots/28b5e5f98ce0e148f03e345518c9c53cb7a04a82e8e58de74a87c1b4ae08cf65 — 6 commits, 2 files: “TML-3537: Changing a value object or a variant is a migration, and Postgres checks value object and discriminator columns (\#30869)”; “TML-3808: Migration snapshots store contract.d.ts on one line instead of about 1,400 (\#30965)”; “TML-3696: ORM create, update, upsert and delete work on MySQL and return the written rows, as on Postgres (\#30927)”; and 3 more (refs \#30869, \#30965, \#30927, \#30819, \#30900, …).
examples/prisma-8-postgis-demo/migrations/snapshots/28b5e5f98ce0e148f03e345518c9c53cb7a04a82e8e58de74a87c1b4ae08cf65 · medium confidence · unverified
7 commits (0 fixes) modifying examples/prisma-8-demo-mysql
A change to existing behaviour in examples/prisma-8-demo-mysql — 7 commits, 20 files: “TML-3537: Changing a value object or a variant is a migration, and Postgres checks value object and discriminator columns (\#30869)”; “TML-3697: The CLI emits, migrates, verifies and signs against MariaDB, through a new mariadb target that extends MySQL (\#30964)”; “TML-3787: MySQL gets the convenience types DateTime, Date, Time and Duration (\#30950)”; and 4 more (refs \#30869, \#30964, \#30950, \#30927, \#30856, …).
examples/prisma-8-demo-mysql · medium confidence · unverified
8 commits (0 fixes) modifying examples/prisma-8-demo/migrations/app/20261009T1354\_add\_post\_body\_search
A change to existing behaviour in examples/prisma-8-demo/migrations/app/20261009T1354\_add\_post\_body\_search — 8 commits, 4 files: “TML-3537: Changing a value object or a variant is a migration, and Postgres checks value object and discriminator columns (\#30869)”; “TML-3712: PostgreSQL gets convenience types DateTime, Date, Time and Duration, and the tools write them (\#30847)”; “TML-3715: PostgreSQL Int, BigInt, Float, Decimal, String, Boolean and Bytes choose their database type with storage and as, and the explicit types get the database's names (\#30942)”; and 5 more (refs \#30869, \#30847, \#30942, \#30814, \#30780, …).
_examples/prisma-8-demo/migrations/app/20261009T1354\_add\_post\_body\search · medium confidence · unverified
8 commits (0 fixes) modifying examples/prisma-8-demo/migrations/snapshots
A change to existing behaviour in examples/prisma-8-demo/migrations/snapshots — 8 commits, 16 files: “TML-3537: Changing a value object or a variant is a migration, and Postgres checks value object and discriminator columns (\#30869)”; “TML-3772: A Supabase database whose pack extensions live in schema extensions adopts with db sign (\#30956)”; “TML-3808: Migration snapshots store contract.d.ts on one line instead of about 1,400 (\#30965)”; and 5 more (refs \#30869, \#30956, \#30965, \#30902, \#30927, …).
examples/prisma-8-demo/migrations/snapshots · medium confidence · unverified
8 commits (0 fixes) modifying examples/prisma-8-demo/scripts
A change to existing behaviour in examples/prisma-8-demo/scripts — 8 commits, 2 files: “docs: rewrite README for Prisma 8, fix orm init dist-tag, sweep "Prisma Next" prose (\#30248)”; “TML-3715: PostgreSQL Int, BigInt, Float, Decimal, String, Boolean and Bytes choose their database type with storage and as, and the explicit types get the database's names (\#30942)”; “TML: PostgreSQL temporal codecs — Temporal or raw text, chosen in the contract (\#30073)”; and 5 more (refs \#30248, \#30942, \#30073, \#30231, \#29950, …).
examples/prisma-8-demo/scripts · medium confidence · unverified
8 commits (0 fixes) modifying examples/prisma7-adoption/migrations
A change to existing behaviour in examples/prisma7-adoption/migrations — 8 commits, 15 files: “TML-3712: PostgreSQL gets convenience types DateTime, Date, Time and Duration, and the tools write them (\#30847)”; “TML-3772: A Supabase database whose pack extensions live in schema extensions adopts with db sign (\#30956)”; “tml-3466: Add autoincrement() to an existing column, and keep the constraint names Prisma 7 gave a database after Prisma 8 takes over its migrations (\#30606)”; and 5 more (refs \#30847, \#30956, \#30606, \#30287, \#30965, …).
examples/prisma7-adoption/migrations · medium confidence · unverified
9 commits (0 fixes) modifying examples/multi-extension-monorepo/packages/audit/migrations/snapshots, examples/multi-extension-monorepo/packages/feature-flags/migrations/snapshots
A change to existing behaviour in examples/multi-extension-monorepo/packages/audit/migrations/snapshots, examples/multi-extension-monorepo/packages/feature-flags/migrations/snapshots — 9 commits, 4 files: “TML-3537: Changing a value object or a variant is a migration, and Postgres checks value object and discriminator columns (\#30869)”; “TML-3808: Migration snapshots store contract.d.ts on one line instead of about 1,400 (\#30965)”; “TML-3534: A contract written with defineContract gets the same ORM types as an emitted one, and filters accept plain strings (\#30709)”; and 6 more (refs \#30869, \#30965, \#30709, \#30927, \#30576, …).
examples/multi-extension-monorepo/packages/audit/migrations/snapshots, examples/multi-extension-monorepo/packages/feature-flags/migrations/snapshots · medium confidence · unverified
9 commits (0 fixes) modifying examples/prisma-8-demo-sqlite
A change to existing behaviour in examples/prisma-8-demo-sqlite — 9 commits, 7 files: “docs: rewrite README for Prisma 8, fix orm init dist-tag, sweep "Prisma Next" prose (\#30248)”; “feat(cli)!: stop publishing the prisma-next CLI — the unified prisma-cli replaces it (\#30005)”; “TML-3192: demo the integer representations and aggregate precision (\#29950)”; and 6 more (refs \#30248, \#30005, \#29950, \#30037, \#29940, …).
examples/prisma-8-demo-sqlite · medium confidence · unverified
Add expiresAt column to Post model with 7-day default
The Post model now includes an expiresAt field of type DateTime. This column is added to the database as a non-nullable timestamptz with a default value of the current time plus 7 days, ensuring new posts automatically have an expiration date one week in the future.
_examples/prisma-8-demo/migrations/app/20260917T0818\_add\_post\_expires\at · high confidence
Add indexes to the posts collection in the MongoDB demo
This migration adds two indexes to the \posts\ collection in the MongoDB demo application: a single-field index on \authorId\ and a compound index on \createdAt\ (descending) and \authorId\ (ascending). These indexes are defined in the Prisma contract using \@@index\ directives and are applied via \createIndex\ operations in the migration script, improving query performance for lookups by author and chronological author posts.
_examples/mongo-demo/migrations/app/20260626T1916\_add\_posts\indexes · high confidence
Audit and feature-flags extensions now use contract-driven migrations targeting the public schema
The audit and feature-flags extensions have been updated to use a new contract-driven migration system. Each extension now includes a baseline migration (migration.ts, migration.json, and ops.json) that explicitly targets the 'public' schema, aligning with the default namespace policy. These migrations are tied to specific invariants (audit:create-audit\_event-v1 and feature-flags:create-feature\_flag-v1) and content-addressed snapshots, ensuring that the database schema changes are deterministic and verifiable. For users, this means the initial setup of these extensions will now rely on these new, standardized migration files, which may affect how existing databases are upgraded if they were previously using different migration mechanisms.
_examples/multi-extension-monorepo/packages/audit/migrations/20260601T0000\_create\_audit\_event, examples/multi-extension-monorepo/packages/feature-flags/migrations/20260601T0000\_create\_feature\flag · high confidence
Authenticated order creation with input validation and cart clearing
The orders API route now requires authentication for both retrieving and creating orders, returning a 401 status if the user is not logged in. When creating an order via POST, the endpoint validates that the request body contains an array of items and a shipping address, returning a 400 error if these are missing. Upon successful order creation, the user's cart is automatically cleared server-side.
examples/retail-store/app/api/orders · high confidence
Backfill missing product status and update schema validation
This migration adds a required \status\ field to the \Product\ model and an optional \embedding\ field. It updates the MongoDB collection validation to enforce these new fields and runs a data transform to set \status\ to "active" for any existing products that do not already have a status value.
_examples/retail-store/migrations/app/20260513T0508\_backfill\_product\status · high confidence
CLI introduces on-disk migration planning with explicit data-loss consent
The CLI now supports an on-disk migration planning workflow where the planner identifies operations that would lose data or change data access, and pauses to ask the user for explicit consent before applying them. Users must provide statements using \--delete\ or \--allow\ to consent to data loss, and \--rename\ or \--convert\/\--backfill\ to handle type changes or field migrations. The planner refuses to silently plan from an empty database when migrations already exist, and requires these explicit statements for any lossy type changes or field removals, ensuring that destructive operations are never executed without clear user intent.
packages/1-framework/3-tooling/cli · high confidence
Centralized agent rules with canonical storage and symlinked presentation mirrors
The \.agents/rules/\ directory now serves as the single source of truth for all agent and developer rules, stored as \.mdc\ files. Presentation mirrors in \.cursor/rules/\ and \.claude/rules/\ are no longer the primary location but are instead generated as relative symlinks pointing back to the canonical files. A new \rules:sync\ script consolidates stray rules and rebuilds these symlink trees, while \lint:rules:symlinks\ enforces that the mirrors stay in sync with the canonical source. This change ensures that rules added only to the ignored mirror trees are not lost and that the rule footprint is monitored against defined thresholds.
.agents · high confidence
Contract data type storage and column descriptor format changes
The SQL contract now stores column data types in a \dataType\ field (e.g., \pg/int4\) instead of the previous \nativeType\ field (e.g., \integer\), and hand-written column descriptors no longer require the \nativeType\ property. This release includes a migration script that rewrites all contract files, updates snapshot directories, and adjusts related files like \migration.ts\ and \contract.d.ts\ to reflect these changes. Additionally, PostgreSQL parameter casts in SQL snapshots and tests now use base type names (e.g., \$1::int4\ instead of \$1::integer\), and every database must be signed using \prisma db sign\ after the upgrade to update storage hashes.
upgrade-instructions/releases/8.0.0-rc.14-to-8.0.0-rc.15/sources/data-type-in-contract · high confidence
Contract foundation restructured with canonicalization, control policies, and execution sections
The contract foundation package has been reorganized into a new modular structure, introducing a unified \Contract\ type that explicitly separates the application domain (\domain.namespaces\) from the storage plane. This change adds a new \execution\ section to the contract schema, which includes mutation defaults and a deterministic \executionHash\ computed via canonicalization. A new \ControlPolicy\ system (managed, tolerated, external, observed) is introduced to govern storage lifecycle, with a \defaultControlPolicy\ available at the contract level. Canonicalization logic is now centralized, ensuring deterministic JSON output through UTF-16 code-unit sorting and default-omission rules, while new types for domain enums, value objects, and cross-references provide a more robust type-safe contract representation.
packages/1-framework/0-foundation/contract/src · high confidence
Contract framework exports reorganized and expanded
The contract foundation module has been restructured to expose a broader set of internal utilities and type definitions directly from the \exports\ directory. This change adds new public exports for control policy logic (\apply-specifier-default-control-policy\, \effectiveControlPolicy\), domain model resolution (\resolveDomainModel\), and contract validation (\ContractValidationError\, \validateContractDomain\). It also exposes detailed type definitions for enums (\ContractEnumAccessor\, \EnumMemberCodec\), hashing (\computeExecutionHash\, \canonicalizeContract\), and various domain types (models, relations, value objects), making these lower-level contract components more accessible for downstream framework integration.
packages/1-framework/0-foundation/contract/src/exports · high confidence
Declarative PSL attribute specification system
The Prisma Schema Language (PSL) parser now uses a declarative attribute-spec kit to define and validate attributes. This new system introduces factory functions for block, model, and field attributes, along with a central assembly mechanism that merges built-in specs with authoring contributions while preventing duplicate registrations. It provides a structured way to define argument types (positional, named, optional, and generator functions like @onCreate/@onUpdate) and interprets attribute arguments against these specs, producing precise diagnostics for errors such as unknown arguments, missing required values, or generator functions that do not apply to the field's codec.
packages/1-framework/2-authoring/psl-parser/src/attribute-spec · high confidence
Documented on-disk authoring workflow for audit and feature-flags extension packages
The \audit\ and \feature-flags\ packages in the multi-extension monorepo now include \README.md\ files and \prisma.config.ts\ files that document and implement the new on-disk authoring workflow. Users and maintainers can now author contracts using PSL (\src/contract.prisma\) and generate migrations via the unified CLI commands (\prisma contract emit\, \prisma migration plan\), with configuration handled by importing \definePrismaConfig\ from \@prisma/cli-engine\ and \@prisma/orm-postgres/config\.
examples/multi-extension-monorepo/packages/audit, examples/multi-extension-monorepo/packages/feature-flags · high confidence
Enforce strict validation for product status and order type in MongoDB
This migration updates the retail-store database schema to enforce strict validation rules on the \products\ and \orders\ collections. Specifically, the \Product.status\ field is now restricted to the enum values \active\, \discontinued\, and \out-of-stock\, while the \Order.type\ field is restricted to \delivery\ and \pickup\. The migration applies these constraints via MongoDB collection validators with strict validation levels, ensuring that any new or updated records must conform to these predefined values.
_examples/retail-store/migrations/app/20260628T0931\_add\_product\_status\_order\_type\enums · high confidence
Enforced commit sign-off and pre-commit linting
The development workflow now enforces stricter quality gates. Commits are blocked if they lack a Developer Certificate of Origin (DCO) sign-off, ensuring legal compliance for contributions. Additionally, a pre-commit hook runs lint-staged to automatically format and lint staged files before each commit, preventing unstyled or linting errors from entering the repository.
.husky · high confidence
Generated Prisma 8 contract types and schema for PostgreSQL
The example project now includes auto-generated TypeScript declaration files and a JSON contract schema for Prisma 8 targeting PostgreSQL. This generated output defines the type mappings for aggregate operations (such as avg, count, max, and min) and explicitly maps domain models (Post, Tag, User) to their storage structures, including field types, relations, and table namespaces.
examples/prisma7-adoption/generated · high confidence
Improved init reliability with package-manager detection, pnpm catalog warnings, and idempotent hygiene
The \init\ command now automatically detects the correct package manager (pnpm, npm, yarn, bun, or deno) by walking up the directory tree for lockfiles and falling back to environment variables, ensuring dependencies are installed with the right tool. When running inside a pnpm workspace, it now warns if the workspace's catalog overrides the versions of packages being installed, preventing silent version mismatches. Additionally, the command idempotently merges \.gitignore\ and \.gitattributes\ entries (marking generated artifacts as \lingest-generated\) and \package.json\ scripts, preserving existing user customizations and surfacing structured warnings for conflicts rather than overwriting them.
packages/1-framework/3-tooling/cli/src/commands/init · high confidence
Initial retail-store database schema and category index migration
The retail-store example now includes an initial migration that creates the core database collections (products, users, carts, orders, invoices, locations, and events) with strict JSON schema validation, and a subsequent migration that adds a compound index on the \products\ collection for \primaryCategory\ and \articleType\. This replaces the previous \masterCategory\ field with \primaryCategory\ in the product model and ensures efficient querying for product categorization.
_examples/retail-store/migrations/app/20260513T0505\initial · high confidence
Introduce Prisma ORM contract for ParadeDB demo
The ParadeDB demo now uses a new Prisma ORM contract (contract.ts) to define the 'Item' model schema and its associated BM25 search index. This change replaces previous configuration methods with a structured contract definition that explicitly declares the database extensions (ParadeDB) and column types, ensuring the demo's data model is generated consistently from this single source of truth.
examples/paradedb-demo/prisma · high confidence
Introduce centralized tsdown build configuration and shell packaging tooling
This change replaces the previous build setup with a new \@repo/tsdown\ package that standardizes bundling across the monorepo. It provides a shared base configuration that automatically generates \package.json\ exports from entry points, handles declaration file generation with sourcemaps, and infers the bundling target from the \engines.node\ field. Additionally, it introduces \shell-build.ts\ to automate the creation of publish shells by aggregating internal package exports into single bundles, and \shell-testkit.ts\ to support smoke-testing these shells via packed tarballs in isolated scratch projects.
packages/0-config/tsdown · high confidence
Migrate CLI recording fixtures to new contract builders and config schema
The CLI recording fixtures have been updated to use the new \@internal/postgres/contract-builder\ API (replacing the legacy DSL) and the \definePrismaConfig\ marker for configuration. This change aligns the test fixtures with the unified Prisma CLI engine's current configuration and contract definition standards, ensuring that recorded scenarios reflect the latest internal adapter and driver integrations.
packages/1-framework/3-tooling/cli/recordings/fixtures · high confidence
MongoDB bundle-size example now uses generated contract and typed client
The MongoDB bundle-size fixture has been updated to use the new Prisma ORM contract system. It now includes generated \contract.d.ts\ and \contract.json\ files that define the schema (including a \Note\ model with an \\_id\ field and a strict MongoDB validator requiring an ObjectId). The \db.ts\ entry point has been rewritten to import this contract via \contractFromJson\ and initialize the MongoDB client using \@prisma/orm-mongo/runtime\, replacing the previous direct client setup with a contract-driven, type-safe approach.
examples/bundle-size/src/mongo/generated · high confidence
New Biome lint plugins enforce coding standards for casts, throws, and framework vocabulary
The biome-plugins package introduces three new GritQL-based lint rules that run as part of the repository's linting process. The \no-bare-cast\ rule flags bare TypeScript \as\ type assertions (excluding \as const\ and test files) to encourage safer casting utilities. The \no-bare-throw\ rule flags direct \throw new Error(...)\ statements in production code (excluding test files and typed errors like \TypeError\) to promote structured error handling. The \no-family-vocabulary\ rule prevents database-specific terms (e.g., \table\, \sql\, \postgres\) and older Prisma version references from appearing in the framework-agnostic domain code, ensuring architectural separation. All three rules report at \info\ severity to allow gradual adoption without breaking existing builds, with CI ratchets enforcing the new standards over time.
biome-plugins · high confidence
New Prisma 8 configuration schema and contract source types
The configuration package introduces a new \PrismaNextConfig\ interface and \defineConfig\ marker function, replacing previous configuration patterns with a schema-driven approach for Prisma 8. Users now define contract sources using explicit \ContractSourceProvider\ types (supporting both PSL and TypeScript formats) and benefit from automatic output path resolution via \defaultContractOutputPath\. The config structure enforces a clear separation between family/target descriptors, driver connections, and contract artifacts, with diagnostics reported per-section rather than failing the entire load.
packages/1-framework/1-core/config/src · high confidence
New centralized Prisma configuration for the multi-extension example
The multi-extension-monorepo example now uses a new \prisma.config.ts\ file to aggregate its configuration. This file imports \definePrismaConfig\ from \@prisma/cli-engine\ and composes the application's contract with two internal extension packages (\audit\ and \feature-flags\) using the \@prisma/orm-postgres/config\ module. This single configuration file serves as the entry point for the CLI to handle contract emission, migration planning, and database initialization/update operations for the example.
examples/multi-extension-monorepo/app · high confidence
New control-api operation layer for CLI commands
The CLI now uses a dedicated \control-api/operations\ directory to implement core commands, introducing structured error handling and atomic contract emission. \caught-errors.ts\ centralizes error reporting, ensuring structured codes are preserved and connection strings are sanitized from output. \contract-emit.ts\ provides a single, serialized publication path for contract artifacts, guaranteeing atomic updates to \contract.json\ and \contract.d.ts\. Additional operations include \contract-print\ for PSL output, \db-init\ and \db-run\ for database schema application, and \contract-space-seed-phase\ for managing extension migration packages.
packages/1-framework/3-tooling/cli/src/control-api/operations · high confidence
New declarative attribute-spec combinators for the PSL parser
The PSL parser now uses a new set of declarative combinators in the attribute-spec kit to parse attribute arguments. This adds dedicated parsers for booleans, integers, numbers, strings, JSON, tagged literals, lists, records, function calls, and references to entities and fields, along with utilities for data-type values and enum members. For users, this provides more precise validation and richer error reporting when writing Prisma schema attributes, ensuring that argument values match their expected types and constraints.
packages/1-framework/2-authoring/psl-parser/src/attribute-spec/combinators · high confidence
New modular export entry points for framework-components
The framework-components package now exposes its public API through a set of dedicated, plane-specific entry points (authoring, codec, components, control, emission, execution, ir, psl-ast, runtime, and utils) instead of a single monolithic barrel. This reorganization groups related types and functions—such as the runtime executor and middleware interfaces in the runtime entry, or the migration planner and runner types in the control entry—making it easier for consumers to import only the specific capabilities they need and reducing the surface area of the public API.
packages/1-framework/1-core/framework-components/src/exports · high confidence
PSL parser replaced with a new fault-tolerant, symbol-table-driven architecture
The PSL parser in this package has been completely rewritten to use a new fault-tolerant recursive-descent parser, a CST-based symbol table, and an eager binder. This change introduces new capabilities for the authoring and interpretation layers, including support for PSL mixins, native scalar lists, qualified entity references, and multi-file schema contracts. It also enables richer language-server features like hover, go-to-definition, and find-references by binding AST nodes to symbols, and ensures that attribute arguments are resolved through typed data-type descriptors rather than raw syntax nodes.
packages/1-framework/2-authoring/psl-parser/src · high confidence
Parametrized init templates for database target and authoring style
The \init\ command now scaffolds projects based on the selected database target (PostgreSQL or MongoDB) and authoring style (TypeScript or Prisma Schema Language). This change introduces a modular template system that generates target-specific starter schemas, environment variable placeholders, and documentation. Users will see database-specific connection strings and minimum version requirements (PostgreSQL 15+, MongoDB 8.0+) in the generated \.env\ files, and the quick-reference documentation now includes target-specific details such as MongoDB replica set requirements or PostgreSQL table creation commands. The generated TypeScript schemas use the appropriate field helpers (e.g., \field.id.uuidv7String()\ for Postgres, \field.objectId().mongo()\ for Mongo), and the README templates provide database-specific setup instructions.
packages/1-framework/3-tooling/cli/src/commands/init/templates · high confidence
Ported ORM migration commands to the new CLI engine
The migration subcommands (check, graph, list, log, new, plan, show, status) have been rewritten to use the new CLI engine architecture. This introduces structured output presentations (human, JSON, data-line), typed next actions for follow-up commands, and consistent exit codes (e.g., exit 4 for integrity findings in migration check). The commands now rely on the \defineOrmCommand\ helper and the \@prisma/cli-engine\ framework for argument parsing, configuration loading, and output rendering.
packages/1-framework/3-tooling/cli/src/orm/migration · high confidence
Prisma 8 SQLite demo adopts new ORM contract and client API
The Prisma 8 SQLite demo example has been updated to use the new ORM architecture. The project now generates a typed contract definition (contract.d.ts) and a JSON schema (contract.json) that explicitly define model fields, relations, and aggregate output types (such as count returning bigintnumber). The database client is initialized via a new runtime API (sqlite from @prisma/orm-sqlite/runtime) that consumes the contract through a contractFromJson helper, replacing the previous client generation approach.
examples/prisma-8-demo-sqlite/src/prisma · high confidence
Prisma 8 upgrade guides and codemods for 0.10–0.13
The \skills/prisma-8/upgrading\ area now provides structured upgrade instructions and automated codemods for moving between Prisma 8 minor versions. Upgrading from 0.10 to 0.11 requires wrapping single-row \.insert()\ calls in an array. Moving from 0.11 to 0.12 involves simplifying the SQL runtime's \verify\ configuration to \verifyMarker\, removing the \capabilities\ field from \defineContract\, stripping \labels\ and \hints\ from migration manifests, and re-emitting contracts to enforce closed Mongo validators and a new \public\ default namespace for Postgres. Finally, upgrading from 0.12 to 0.13 requires changing SQLite migrations to use \this.createTable\ instead of a free function, re-emitting contracts to add base-PK link columns for Multi-Table Inheritance variants, and re-emitting to adopt a new storage namespace envelope. Telemetry is also now opt-out by default.
skills/prisma-8/upgrading · high confidence
Prisma 8 upgrade instructions for multifile PSL and verbatim table names
This release adds upgrade guidance and codemods for two Prisma 8 behavioral changes. First, \prisma contract emit\ now requires every PSL schema file to start with \// use prisma-8\; the provided \add-use-prisma-8-directive.mjs\ script adds this directive to matching files. Second, PSL models without \@@map\ now use the model name verbatim for table/collection names instead of lowercasing the first letter; the \add-model-map.mjs\ script adds \@@map\ attributes to preserve existing table names and prevent migration planning failures.
upgrade-instructions/releases/8.0.0-rc.11-to-8.0.0-rc.12/sources/multifile-psl, upgrade-instructions/releases/8.0.0-rc.11-to-8.0.0-rc.12/sources/psl-verbatim-table-names · high confidence
Prisma 8.0.0-rc.19 upgrade instructions and migration scripts
This release adds the upgrade path from Prisma 8.0.0-rc.18 to 8.0.0-rc.19, providing detailed migration instructions and automated scripts to handle breaking changes. Key updates include removing the \@noCheck\ attribute and \.noCheck()\ method in favor of nullable list types, moving client-side ID generators (like \uuid()\ and \cuid()\) from \@default\ to \@onCreate\, and refining SQLite datetime/JSON data types and PostgreSQL default value handling. The included scripts automate the rewriting of contracts, schema files, and migration snapshots to ensure compatibility with the new storage hashes and type systems.
(repo-wide) · high confidence
Prisma ORM CLI is ported to the unified engine
The ORM command family (including \orm init\, \contract\, \db\, \migration\, and \lsp\) is now implemented on the \@prisma/cli-engine\, replacing the previous standalone CLI. This change introduces a unified command structure with consistent output channels, a new \prisma.config.ts\ configuration system, and improved error handling via a shared error boundary. The \orm init\ command now scaffolds projects with typed next actions and handles Prisma 7 side-by-side migrations, while commands like \contract format\ and \db migrate\ are now part of the single \prisma\ binary mount path.
packages/1-framework/3-tooling/cli/src/orm · high confidence
React Router demo updated to Prisma 8 contract syntax and structure
The React Router demo example has been refreshed to align with the Prisma 8 ORM contract definitions. The contract source is now colocated under src/prisma, utilizing the new defineContract API in TypeScript and the updated .prisma schema syntax (including @onCreate and explicit table mapping). The generated contract types and JSON metadata have been regenerated to reflect these structural changes, ensuring the demo's smoke tests and type checks pass against the current main branch.
examples/react-router-demo/src · high confidence
Rebuilt migration-graph renderer with focus-mode path highlighting and multi-space alignment
The \migrate --show\ command now uses a new line/plane/occlusion graph renderer that supports focus mode, where the chosen migration path is highlighted in bright green and off-path migrations are dimmed. The output aligns columns consistently across multiple contract spaces, ensuring that arrows and labels land in the same terminal columns regardless of the number of spaces or the depth of the graph.
packages/1-framework/3-tooling/cli/src/utils/formatters · high confidence
Retail store example migrated to Prisma 8 with MongoDB contract and caching
The retail-store example has been updated to use the Prisma 8 ORM stack with a MongoDB target. The data model is now defined in a new \contract.prisma\ file, which includes expanded indexes (text search, TTL, hashed, collation) and value objects like \Price\ and \Address\. The application now uses generated contract types (\contract.d.ts\) and a static contract instance (\contract-value.ts\) for type safety. A new \db.ts\ module initializes the MongoDB client with a caching middleware, and the seed script has been expanded to populate 24 products across 5 brands.
examples/retail-store/src · high confidence
Structured CLI error reporting with actionable remediation
The CLI now uses a structured error system that provides machine-readable error envelopes alongside human-readable advice. This change introduces the \ActionableCliError\ class, which attaches specific remediation steps (\nextActions\) to failures, ensuring users receive clear instructions on how to resolve issues. New utility functions handle specific failure scenarios, such as \db init\ and \db update\ planning or application errors, by mapping internal migration conflicts to user-friendly fixes (e.g., suggesting \db update\ for additive-only failures). Additionally, the system now validates framework components and contract requirements at the CLI boundary, providing precise error messages for configuration mismatches, missing extensions, or invalid contract structures.
packages/1-framework/3-tooling/cli/src/utils · high confidence
Structured JSON output schemas for CLI migration commands
The CLI now defines strict ArkType schemas for the JSON output of migration commands (list, graph, status, log, show). This introduces a consistent, typed structure for all \--json\ responses, including nested space-based data for graphs, detailed diagnostics for status checks, and structured next-action hints. Users relying on machine-readable output will now receive a stable, validated contract for migration data, ensuring fields like \fromContract\, \toContract\, and \diagnostics\ are consistently shaped across commands.
packages/1-framework/3-tooling/cli/src/commands/json · high confidence
Structured error system with dotted codes and typed next actions
The error module now uses a unified structured error format where every error code follows a dotted NAMESPACE.SUBCODE pattern (e.g., CONFIG.FILE\_NOT\_FOUND, CONTRACT.MARKER\_MISSING, MIGRATION.UNFILLED\_PLACEHOLDER). Errors carry typed next actions with a {bin} placeholder that the CLI substitutes with the running binary name, providing users with precise, actionable remediation steps. The module is split into control, execution, and migration entry points, each exporting specific error constructors and utilities like rethrowMarkerReadError and withMarkerReadErrorHandling for consistent error handling across the framework.
packages/1-framework/1-core/errors/src · high confidence
Support for single-package database facade installations
The publish-surface layer now resolves import specifiers based on the application's dependency structure, enabling generated code to work correctly when an application installs a single \@prisma/orm-\<database\>\ facade package instead of the full decomposed platform. The new \import-roots\ logic detects whether the project uses a facade, a platform install, or the internal workspace, and rewrites internal \@internal/\ imports to the appropriate published \@prisma/orm-\*\ paths, ensuring that emitted contract types and migrations reference packages the application can actually resolve.
packages/0-shared/publish-surface/src · high confidence
Unified CLI entry point with strict contract loading and migration-file CLI
The CLI now uses a new entry point (bin.ts) that invokes the ORM CLI and ensures clean process exit. Contract loading is stricter: it validates that exports are JSON-serializable, free of functions/getters/setters, and only allows imports from a configurable allowlist (defaulting to @internal/\, @prisma/orm-\, and node:crypto). The migration-file CLI surface (MigrationCLI) is introduced, using clipanion for argument parsing and handling config loading, target validation, and artifact serialization for authored migration.ts scripts.
packages/1-framework/3-tooling/cli/src · high confidence
Updated telemetry database contract snapshots to reflect schema changes
The migration snapshots for the telemetry backend have been regenerated to align with the current database schema. The \contract.d.ts\ and \contract.json\ files now define the \TelemetryEvent\ model with its specific column types (such as \pg/int8\, \pg/text\, \pg/jsonb\, and \pg/timestamptz\) and constraints. This ensures that the generated TypeScript types and the internal contract representation accurately mirror the underlying PostgreSQL table structure, including the primary key on \id\ and the index on \ingestedAt\. Also in this area: 1 commit (0 fixes) modifying (repo-wide).
apps/telemetry-backend/migrations/snapshots · medium confidence · unverified
Fixes
1 commit (1 fix) fixing apps/telemetry-backend/migrations/app/20261016T1018\_exit\_code
A fix in apps/telemetry-backend/migrations/app/20261016T1018\_exit\_code — 1 commit (1 fix), 3 files: “fix(telemetry-backend): add the missing exitCode migration and test migrations in CI (\#30728)” (refs \#30728).
_apps/telemetry-backend/migrations/app/20261016T1018\_exit\code · medium confidence · unverified
Test coverage
1 commit adding/updating tests in (repo-wide); 1 commit adding/updating tests in (repo-wide); 1 commit adding/updating tests in examples/prisma-8-demo-sqlite/test; 1 commit adding/updating tests in test/integration/test/upgrade-instructions/mongo-index-names/fixtures/project/after, test/integration/test/upgrade-instructions/mongo-index-names/fixtures/project/before; 11 commits adding/updating tests in examples/prisma-8-demo/test/fixtures; 2 commits adding/updating tests in packages/0-shared/extension-author-tools/test; 3 commits adding/updating tests in examples/prisma-8-demo/test/utils; 6 commits adding/updating tests in examples/prisma-8-demo-mysql/test; Added CLI scenario recordings for database initialization, updates, and drift verification; Added PSL formatter test fixtures for alignment, spacing, and comments; Added Supabase acceptance and type-level tests; Added broken.psl fixture for Prisma 8 language server testing; Added comprehensive test coverage for the contract emitter; Added end-to-end integration tests for multi-extension monorepo migrations; Added end-to-end tests for PostGIS spatial queries in the demo; Added end-to-end tests for the React Router demo example; Added integration test fixtures for SQLite data-type value migration; Added integration test fixtures for data-type-in-contract upgrade instructions; Added integration tests for ParadeDB BM25 search functionality; Added integration tests for Prisma ORM upgrade instructions; Added integration tests for retail-store data access and migration logic; Added integration tests for the MongoDB blog leaderboard example; Added integration tests for the MongoDB demo application; Added migration fixtures for postgres-extension-space upgrade tests; Added snapshot tests for ESLint query validation rules; Added snapshot tests for the PSL tokenizer; Added test coverage for framework-core components; Added test double for ControlClient operations; Added test fixtures for CLI contract validation; Added test fixtures for contract value migration; Added test fixtures for ledger operation count parity; Added test helpers for CLI contract and ORM testing; Added tests for CLI init template generation; Added tests for CLI migration commands and status overlays; Added tests for CLI utility functions; Added tests for ID generator specs and runtime behavior; Added tests for PSL formatter capabilities; Added tests for PSL language server completion and attribute context interpretation; Added tests for PSL parser attribute-spec combinators and helpers; Added tests for Prisma 7 to Prisma 8 migration handover scenarios; Added tests for bundle-size examples; Added tests for contract and migration reference resolution; Added tests for contract canonicalization, execution section building, and enum accessors; Added tests for migration contract snapshot integrity and space application ordering; Added tests for migration planning strategies; Added tests for telemetry backend event handling, rate limiting, and server lifecycle; Added tests for the CLI control-api operations; Added tests for the ORM CLI engine integration and contract commands; Added tests for the PSL parser syntax tree and AST accessors; Added tests for the PSL printer's round-trip, extension blocks, and namespace handling; Added tests for the config-loader package; Added tests for the migration aggregate layer; Added tests for the migration-graph formatter scenario gallery; Added tests for the published package surface and skill packaging; Added tests for ts-render source generation and import rendering; Added type-level and runtime tests for the new configuration system; Added unit tests for CLI error handling, configuration, and migration commands; Added unit tests for contract authoring framework components; Added unit tests for framework utility functions; Added unit tests for the CLI init command; Added unit tests for the Vite contract emission plugin; Integration tests for Prisma serverless client on Cloudflare Workers; New e2e framework test suite for contract emission and runtime verification; New test utilities for contract factories, database management, and type assertions; Test fixtures for typed contract value migration; Tests added for structured error handling and typed next actions; Updated snapshot tests for CLI init templates; Updated test fixtures for type alias and data-type contract changes.
Dependencies
Prisma 8 release candidate 20 workspace manifests
The monorepo workspace has been updated to version 8.0.0-rc.20. All example applications, internal framework packages, and tooling manifests now reference the rc.20 release line, including the new @prisma/orm-mysql target and updated @prisma/cli-engine peer dependency.
(dependencies) · high confidence
Housekeeping
Placeholder added for WIP directory; Slice planning and specification for scorecard and trace inputs.
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 53 → 50 (-3.4)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 56 → 46 (-9.3)
- Architecture 72 → 67 (-5.0)
- Maturity 91 → 92 (+1.3)
- Readiness 57 → 51 (-5.6)
- Security 47 → 47 (-0.1)
- Performance 60 → 60 (+0.0)
Resolved (529)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 278 - Value objects are storage entities, and a discriminator column names a value set.md)
- ADR links a record that does not exist (docs/architecture docs/adrs/ADR 275 - Client generators are field attributes, and a type alias is expanded into each column.md)
- ADR links a record that does not exist (docs/architecture docs/adrs/ADR 275 - Client generators are field attributes, and a type alias is expanded into each column.md)
- ADR not followed: ADR 221 — Contract IR is structured as two planes (domain and storage) with a uniform entity coordinate and a pack-contributed entity-kind mechanism (docs/architecture docs/adrs/ADR 221 - Contract IR two planes with uniform entity coordinate and pack-contributed entity kinds.md)
- ADR not followed: ADR 237 — Supabase-internal access is a service_role-only secondary root (docs/architecture docs/adrs/ADR 237 - Supabase-internal access is a service_role-only secondary root.md)
- ADR not followed: ADR 271 — The runtime middleware observes a tree of activities, each started, ended and finalized (docs/architecture docs/adrs/ADR 271 - The runtime middleware observes a tree of activities, each started, ended and finalized.md)
- Change coupling: build-contract.ts ↔ contract-dsl.ts (packages/2-sql-family/2-authoring/contract-ts/src/build-contract.ts)
- Change coupling: runner.ts ↔ runner.ts (packages/3-targets/postgres/1-target/src/core/migrations/runner.ts)
- Classify ADR enforcement: ADR 001 — Migrations as Edges (docs/architecture docs/adrs/ADR 001 - Migrations as Edges.md)
- Classify ADR enforcement: ADR 002 — Plans are Immutable (docs/architecture docs/adrs/ADR 002 - Plans are Immutable.md)
- Classify ADR enforcement: ADR 003 — One Query → One Statement (docs/architecture docs/adrs/ADR 003 - One Query One Statement.md)
- Classify ADR enforcement: ADR 004 — Storage Hash vs Profile Hash (formerly “core hash”) (docs/architecture docs/adrs/ADR 004 - Storage Hash vs Profile Hash.md)
- Classify ADR enforcement: ADR 005 — Thin Core, Fat Targets (docs/architecture docs/adrs/ADR 005 - Thin Core Fat Targets.md)
- Classify ADR enforcement: ADR 006 — Dual Authoring Modes (PSL-first and TS-first) with a Single Canonical Artifact (docs/architecture docs/adrs/ADR 006 - Dual Authoring Modes.md)
- Classify ADR enforcement: ADR 007 — Types-Only Emission and No Runtime Client Codegen (docs/architecture docs/adrs/ADR 007 - Types Only Emission.md)
- Classify ADR enforcement: ADR 008 — Dev Auto-Emit, CI Explicit Emit (docs/architecture docs/adrs/ADR 008 - Dev Auto Emit CI Explicit Emit.md)
- Classify ADR enforcement: ADR 009 — Deterministic Naming Scheme for Constraints (docs/architecture docs/adrs/ADR 009 - Deterministic Naming Scheme.md)
- Classify ADR enforcement: ADR 010 — Canonicalization Rules for contract.json (docs/architecture docs/adrs/ADR 010 - Canonicalization Rules.md)
- Classify ADR enforcement: ADR 011 — Unified Plan model across lanes (docs/architecture docs/adrs/ADR 011 - Unified Plan Model.md)
- Classify ADR enforcement: ADR 012 — Raw SQL escape hatch with required annotations (docs/architecture docs/adrs/ADR 012 - Raw SQL Escape Hatch.md)
- …and 509 more
New (681)
- ADR has no Context section (docs/architecture docs/adrs/ADR 307 - No recovery resets or drops a database.md)
- ADR has no Context section (docs/architecture docs/adrs/ADR 308 - Community packages are named prisma-orm-name.md)
- ADR has no Context section (docs/architecture docs/adrs/ADR 313 - Postgres extension packs are published by tier.md)
- ADR has no Context section (docs/architecture docs/adrs/ADR 319 - Prisma 8 never derives a back-reference.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 307 - No recovery resets or drops a database.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 308 - Community packages are named prisma-orm-name.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 309 - Value objects are storage entities, and a discriminator column names a value set.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 310 - Each generated identifier has a type alias for its column.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 311 - connect() on a client is safe to call again.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 312 - A Postgres extension is a contract entity, and db sign refuses a space with unmet invariants.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 313 - Postgres extension packs are published by tier.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 314 - Code shared by several targets' type implementations lives in one package.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 315 - Each target declares the convenience date and time types over its own explicit types.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 316 - An extension pack's extension is found through the connection's search_path.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 316 - PostgreSQL scalars get convenience types.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 317 - MongoDB indexes carry their names.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 318 - MongoDB prepared statements.md)
- ADR lacks an enforcement field (docs/architecture docs/adrs/ADR 319 - Prisma 8 never derives a back-reference.md)
- ADR links a record that does not exist (docs/architecture docs/adrs/ADR 154 - Component-owned database dependencies.md)
- ADR not followed: ADR 271 — The runtime middleware observes a tree of activities, each started, ended and finalized (docs/architecture docs/adrs/ADR 271 - The runtime middleware observes a tree of activities, each started, ended and finalized.md)
- …and 661 more
Changes since last survey
- 75 commits — 67 feature/other, 8 fixes
By area
- packages/3-targets — 19 commits
- packages/3-extensions — 10 commits
- test/integration — 10 commits
- packages/2-mongo-family — 6 commits
- docs/architecture docs — 4 commits
- packages/1-framework — 4 commits
- packages/2-sql-family — 3 commits
- apps/telemetry-backend — 2 commits
- packages/9-public — 2 commits
- skills/prisma-8 — 2 commits
- upgrade-instructions/releases — 2 commits
- (root) — 1 commit
- .agents/rules — 1 commit
- .github/actions — 1 commit
- .github/workflows — 1 commit
- docs/reference — 1 commit
- drive/calibration — 1 commit
- examples/prisma-8-demo — 1 commit
- projects/convenience-types-other-targets — 1 commit
- projects/datetime-convenience-types — 1 commit
Notable commits
- fix: TML-3813: A Postgres migration.ts that imports the free createExtension fails with a clear error, and the rc.22 upgrade guide gives the fix (#30988)
- fix: fix(cli): orm init keeps a nodenext tsconfig and scaffolds a db.ts that resolves there (#30360)
- fix: fix(family-mongo): db schema prints a field with several BSON types as a | b (#30476)
- fix: fix(mysql): interrupt a statement before destroying its connection, so a failed KILL is never an unhandled rejection (#30931)
- fix: fix(sql-orm-client): gt, lt, gte and lte accept a nullable column to compare with (#30477)
- fix: fix(sql-orm-client): upsert's update input takes a namespaced model's fields (#30407)
- fix: fix(target-postgres): fullTextHeadline checks its word limits against the Postgres defaults (#30415)
- fix: fix(telemetry-backend): add the missing exitCode migration and test migrations in CI (#30728)
- change: Add callback transaction timeouts (#31012)
- change: CI setup is robust to network failures and downloads mongod once per job (#30891)
- change: Docs: agents never change the framework domain, and stop to tell the operator when a design needs to (#30898)
- change: Docs: community packages for Prisma 8 are named prisma-orm-<name> and carry the prisma-orm-extension keyword (#30860)
- change: Embed SQL builder queries and returning mutations in db.raw.sql (#30991)
- change: Suggest the Prisma 8 constructor a renamed @db.* type maps to (@db.Text → String) (#30909)
- change: TML-3513: An ORM release tells prisma-cli at once, so the CLI follows it within minutes (#30944)
- change: TML-3537: Changing a value object or a variant is a migration, and Postgres checks value object and discriminator columns (#30869)
- change: TML-3537: Migration statements rename, remove and fill value object fields, and convert and delete variants, on Postgres and SQLite (#30929)
- change: TML-3538: MongoDB checks documents before a validator change, and asks about type changes (#30970)
- change: TML-3607: Field presets are removed, and each is written with a type constructor or type alias that stores the same contract (#30845)
- change: TML-3616: Close out the MongoDB authoring project: final retro, decisions moved into ADR 254 and ADR 306, follow-ups filed (#30862)
- …and 55 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
prisma/prisma was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 61ed0daa6f84e92bd04f9c0d4094bb76d75c99a6 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.