fix(deps): update prisma monorepo to v7 (major)

[renovate]

This PR contains the following updates:

Package	Change	Age	Confidence
@prisma/client (source)	4.16.2 -> 7.0.1
prisma (source)	^4.15.0 -> ^7.0.0

---

Release Notes

prisma/prisma (@​prisma/client)

v7.0.1

Compare Source

Today, we are issuing a 7.0.1 patch release focused on quality of life improvements, and bug fixes.

🛠 Fixes

• Prisma Studio:

  • Support Deno >= 1.4 <2.2 and Bun >= 1 (via #​28583)
  • Fix collisions between user and internal Studio columns when querying (via #​28677)
  • Warn when SQLite file doesn't exist (via https://redirect.github.com/prisma/prisma/pull/28711/commits/c33a1ea9e5a94e6a5c876bc4567915cc5f354658)
  • Fix prisma/studio#1363 (via https://redirect.github.com/prisma/prisma/pull/28711/commits/07224d4651d043f4b08735eeaa144aa9d75f9fe3)
  • Sort tables alphabetically (via #​28702)

• Prisma CLI

  • Fix potential vulnerabilities in installed dependencies (via #​28592)
  • Fix #​28240, an exit code regression affecting prisma migrate diff (via prisma/prisma-engines#5699)
  • Show informative message when prisma db seed is run, but no migrations.seed command is specified in the Prisma config file (via #​28711)
  • Relax engines check in package.json, to let Node.js 25+ users adopt Prisma, although Node.js 25+ isn't considered stable yet (via #​28600). Thanks @​Sajito!

• Prisma Client

  • Restore cockroachdb support in prisma-client-js generator, after it was accidentally not shipped in Prisma 7.0.0 (via #​28690)

• @​prisma/better-sqlite3

  • Bump underlying version of better-sqlite3 to ^12.4.5, fixing #​28624 (via #​28625). Thank you @​bhbs!

v7.0.0

Compare Source

Today, we are excited to share the 7.0.0 stable release 🎉

🌟 Star this repo for notifications about new releases, bug fixes & features — and follow us on X!

Highlights

Over the past year we focused on making it simpler and faster to build applications with Prisma, no matter what tools you use or where you deploy, with exceptional developer experience at it’s core. This release makes many features introduced over the past year as the new defaults moving forward.

Prisma ORM

Rust-free Prisma Client as the default

The Rust-free Prisma Client has been in the works for some time now, all the way back to v6.16.0, with early iterations being available for developers to adopt. Now with version 7.0, we’re making this the default for all new projects. With this, developers are able to get:

• ~90% smaller bundle sizes
• Up to 3x faster queries
• ESM-first Prisma Client
• Significantly simpler deployments

Adopting the new Rust-free client is as simple as swapping the prisma-client-js provider for prisma-client in your main schema.prisma :

// schema.prisma
generator client {
-	provider = "prisma-client-js"
+ provider = "prisma-client"
}

Generated Client and types move out of node_modules

When running prisma generate, the generated Client runtime and project types will now require a output path to be set in your project’s main schema.prisma. We recommend that they be generated inside of your project’s src directory to ensure that your existing tools are able to consume them like any other piece of code you might have.

// schema.prisma
generator client {
  provider = "prisma-client"
  // Generate my Client and Project types 
  output   = "../src/generated/prisma"
}

Update your code to import PrismaClient from this generated output:

// Import from the generated prisma client
import { PrismaClient } from './generated/prisma/client';

For developers who still need to stay on the prisma-client-js but are using the new output option, theres’s a new required package, @prisma/client-runtime-utils , which needs to be installed:

# for prisma-client-js users only
npm install @​prisma/client-runtime-utils

prisma generate changes and post-install hook removal

For prisma generate , we’ve removed a few flags that were no longer needed:

• prisma generate --data-proxy
• prisma generate --accelerate
• prisma generate --no-engine
• prisma generate --allow-no-models

In previous releases, there was a post-install hook that we utilized to automatically generate your project’s Client and types. With modern package managers like pnpm, this actually has introduced more problems than it has solved. So we’ve removed this post-install hook and now require developers to explicitly call prisma generate .

As a part of those changes, we’ve also removed the implicit run of prisma db seed in-between migrate commands.

Prisma Client

As part of the move to a Rust-free Prisma Client, we moved away from embedding the drivers of the databases that we support. Now developers explicitly provide the driver adapters they need for their project, right in their source code. For PostgresSQL, simply install the @prisma/adapter-pg to your project, configure the connection string, and pass that the Prisma Client creation:

// Import from the generated prisma client
import { PrismaClient } from './generated/prisma/client';

// Driver Adapter for Postgres
import { PrismaPg } from '@​prisma/adapter-pg';

const adapter = new PrismaPg({
  connectionString: process.env.DATABASE_URL!,
});

export const prisma = new PrismaClient({ adapter });

For other databases:

// If using SQLite
import { PrismaBetterSqlite3 } from '@​prisma/adapter-better-sqlite3';
const adapter = new PrismaBetterSqlite3({
  url: process.env.DATABASE_URL || 'file:./dev.db'
})

// If using MySql
import { PrismaMariaDb } from '@​prisma/adapter-mariadb';
const adapter = new PrismaMariaDb({
  host: "localhost",
  port: 3306,
  connectionLimit: 5
});

We’ve also removed support for additional options when configuring your Prisma Client

• new PrismaClient({ datasources: .. }) support has been removed
• new PrismaClient({datasourceUrl: ..}) support has been removed

Driver Adapter naming updates

We’ve standardized our naming conventions for the various driver adapters internally. The following driver adapters have been updated:

• PrismaBetterSQLite3 ⇒ PrismaBetterSqlite3
• PrismaD1HTTP ⇒ PrismaD1Http
• PrismaLibSQL ⇒ PrismaLibSql
• PrismaNeonHTTP ⇒ PrismaNeonHttp

Schema and config file updates

As part of a larger change in how the Prisma CLI reads your project configuration, we’ve updated what get’s set the schema, and what gets set in the prisma.config.ts . Also as part of this release, prisma.config.ts is now required for projects looking to perform introspection.

Schema changes

• datasource.url is now configured in the config file
• datasource.shadowDatabaseUrl is now configured in the config file
• datasource.directUrl has been made unnecessary and has removed
• generator.runtime=”react-native” has been removed

For early adopters of the config file, a few things have been removed with this release

• engine: 'js'| 'classic' has been removed
• adapter has been removed

A brief before/after:

// schema.prisma
datasource db {
  provider = "postgresql"
  url = ".."
  directUrl = ".."
  shadowDatabaseUrl = ".."
}

// ./prisma.config.ts
export default defineConfig({
  datasource: {
    url: '..',
    shadowDatabaseUrl: '..',
  }
})

Explicit loading of environment variables

As part of the move to Prisma config, we’re no longer automatically loading environment variables when invoking the Prisma CLI. Instead, developers can utilize libraries like dotenv to manage their environment variables and load them as they need. This means you can have dedicated local environment variables or ones set only for production. This removes any accidental loading of environment variables while giving developers full control.

Removed support for prisma keyword in package.json

In previous releases, users could configure their schema entry point and seed script in a prisma block in the package.json of their project. With the move to prisma.config.ts, this no longer makes sense and has been removed. To migrate, use the Prisma config file instead:

{
  "name": "my-project",
  "version": "1.0.0",
  "prisma": {
    "schema": "./custom-path-to-schema/schema.prisma",
    "seed": "tsx ./prisma/seed.ts"
  }
}

import 'dotenv/config'
import { defineConfig, env } from "prisma/config";
export default defineConfig({
  schema: "prisma/schema.prisma",
  migrations: {
      seed: "tsx prisma/seed.ts"
  },
  datasource: {...},
});

Removed Client Engines:

We’ve removed the following client engines:

• LibraryEngine (engineType = "library", the Node-API Client)
• BinaryEngine (engineType = "binary", the long-running executable binary)
• DataProxyEngine and AccelerateEngine (Accelerate uses a new RemoteExecutor now)
• ReactNativeEngine

Deprecated metrics feature has been removed

We deprecated the previewFeature metrics some time ago, and have removed it fully for version 7. If you need metrics related data available, you can use the underlying driver adapter itself, like the Pool metric from the Postgres driver.

Miscellaneous

• #​28493: Stop shimming WeakRef in Cloudflare Workers. This will now avoid any unexpected memory leaks.
• #​28297: Remove hardcoded URL validation. Users are now required to make sure they don’t include sensitive information in their config files.
• #​28273: Removed Prisma v1 detection
• #​28343: Remove undocumented --url flag from prisma db pull
• #​28286: Remove deprecated prisma introspect command.
• #​28480: Rename /wasm to /edge
  • This change only affects prisma-client-js
  • Before:
    • /edge → meant “for Prisma Accelerate”
    • /wasm → meant “for Edge JS runtimes (e.g., Cloudflare, Vercel Edge)”
  • After:
    • /edge → means “for Edge JS runtimes (e.g., Cloudflare, Vercel Edge)”
• The following Prisma-specific environment variables have been removed
  • PRISMA_CLI_QUERY_ENGINE_TYPE
  • PRISMA_CLIENT_ENGINE_TYPE
  • PRISMA_QUERY_ENGINE_BINARY
  • PRISMA_QUERY_ENGINE_LIBRARY
  • PRISMA_GENERATE_SKIP_AUTOINSTALL
  • PRISMA_SKIP_POSTINSTALL_GENERATE
  • PRISMA_GENERATE_IN_POSTINSTALL
  • PRISMA_GENERATE_DATAPROXY
  • PRISMA_GENERATE_NO_ENGINE
  • PRISMA_CLIENT_NO_RETRY
  • PRISMA_MIGRATE_SKIP_GENERATE
  • PRISMA_MIGRATE_SKIP_SEED

Mapped enums

If you followed along on twitter, you will have seen that we teased a highly-request user feature was coming to v7.0. That highly-requested feature is…. mapped emuns! We now support the @map attribute for enum members, which can be used to set their expected runtime values

enum PaymentProvider {
  MixplatSMS    @​map("mixplat/sms")
  InternalToken @​map("internal/token")
  Offline       @​map("offline")

  @​@​map("payment_provider")
}

export const PaymentProvider: {
  MixplatSMS: 'mixplat/sms'
  InternalToken: 'internal/token'
  Offline: 'offline'
}

Prisma Accelerate changes

We’ve changed how to configure Prisma ORM to use Prisma Accelerate. In conjunction with some more Prisma Postgres updates (more on that later), you now use the new accelerateUrl option when instantiating the Prisma Client.

import { PrismaClient } from "./generated/prisma/client"
import { withAccelerate } from "@​prisma/extension-accelerate"

const prisma = new PrismaClient({
  accelerateUrl: process.env.DATABASE_URL,
}).$extends(withAccelerate()) 

New Prisma Studio comes to the CLI

We launched a new version of Prisma Studio to our Console and VS Code extension a while back, but the Prisma CLI still shipped with the older version.

Now, with v7.0, we’ve updated the Prisma CLI to include the new Prisma Studio. Not only are you able to inspect your database, but you get rich visualization to help you understand connected relationships in your database. It’s customizable, much smaller, and can inspect remote database by passing a --url flag. This new version of Prisma Studio is not tied to the Prisma ORM, and establishes a new foundation for what comes next.

Prisma Postgres

Prisma Postgres is our managed Postgres service, designed with the same philosophy of great DX that has guided Prisma for close to a decade. It works great with serverless, it’s fast, and with simple pricing and a generous free tier. Here’s what’s new:

Connection Pooling Changes with Prisma Accelerate

With support for connection pooling being added natively to Prisma Postgres, Prisma Accelerate now serves as a dedicated caching layer. If you were using Accelerate for the connection pooling features, don’t worry! Your existing connection string via Accelerate will continue to work, and you can switch to the new connection pool when you’re ready.

Simplified connection flow

We've made connecting to Prisma Postgres even simpler. Now, when you go to connect to a database, you’ll get new options to enable connection pooling, or to enable Prisma Accelerate for caching. Below, you’ll get code snippets for getting things configured in your project right away.

Serverless driver

For those who want to connect to Prisma Postgres but are deploying to environments like Cloudflare Workers, we have a new version of the serverless client library to support these runtimes.

• Compatible with Cloudflare Workers, Vercel Edge Functions, Deno Deploy, AWS Lambda, and Bun
• Stream results row-by-row to handle large datasets with constant memory usage
• Pipeline multiple queries over a single connection, reducing latency by up to 3x
• SQL template literals with automatic parameterization and full TypeScript support
• Built-in transactions, batch operations, and extensible type system

Check out the serverless driver docs for more details

Open roles at Prisma

Interested in joining Prisma? We’re growing and have several exciting opportunities across the company for developers who are passionate about building with Prisma. Explore our open positions on our Careers page and find the role that’s right for you.

Enterprise support

Thousands of teams use Prisma and many of them already tap into our Enterprise & Agency Support Program for hands-on help with everything from schema integrations and performance tuning to security and compliance.

With this program you also get priority issue triage and bug fixes, expert scalability advice, and custom training so that your Prisma-powered apps stay rock-solid at any scale. Learn more or join: https://prisma.io/enterprise.

v6.19.0

Compare Source

v6.18.0

Compare Source

Today, we are excited to share the 6.18.0 stable release 🎉

🌟 Star this repo for notifications about new releases, bug fixes & features — or follow us on X!

Prisma ORM

Prisma ORM is the most popular ORM in the TypeScript ecosystem. Today’s release brings a bunch of new bug fixes and overall improvements:

• prisma init now creates a prisma.config.ts automatically

When creating a new project with 6.18.0, prisma init will now create a prisma.config.ts file automatically. This prepares new applications for the future of Prisma 7. Some fields that have been historically set in the schema.prisma file are now able to be set in the prisma.config.ts, and we encourage people to migrate over to the new structure before the release of version 7, where this file will become a requirement.

• Support for defining your datasource in prisma.config.ts

If you’re adopting the new prisma.config.ts setup in your projects, version 6.18.0 brings the ability to set your datasource directly in your config file. Once this is in your config file, any datasource set in your schema.prisma will be ignored. To set the datasource, we also must include the new engine key which we can set to "classic" , which will be required for Prisma v7

import { defineConfig, env } from "prisma/config";
export default defineConfig({
    // The Rust-compiled schema engine 
    engine: "classic",
    datasource: {
        url: env('DATABASE_URL'),
    }
});

• #​28291 Support multiple Prisma instances with different providers
• #​28305 Add env helper function
• #​28266 Add support for js or classic as engine types in prisma.config
• #​28139 Map Bytes to Uint8Array depending on Typescript version

Preparing for Prisma v7

While it has been mentioned a few times already, many of the changes in this release are here to prepare folks for the upcoming release of Prisma v7. It’s worth repeating that these changes and the migration to prisma.config.ts will be required for Prisma v7, so we’re releasing this as opt-in features for developers. But come Prisma v7, they will be the new way of configuring your project.

Prisma Postgres

Prisma Postgres is our fully managed Postgres service designed with the same philosophy of great DX that has guided Prisma for close to a decade. With this release we are introducing the following improvements:

Database Metric in Console

Inside of your database console, you can now view metrics on your database usage and interactions. You can get insights into the follow:

• Total egress
• Average response size
• Average query duration

In addition, you can also get insights into how to improve your query caching and gain better performance.

Open roles at Prisma

Interested in joining Prisma? We’re growing and have several exciting opportunities across the company for developers who are passionate about building with Prisma. Explore our open positions on our Careers page and find the role that’s right for you.

Enterprise support

Thousands of teams use Prisma and many of them already tap into our Enterprise & Agency Support Program for hands-on help with everything from schema integrations and performance tuning to security and compliance.

With this program you also get priority issue triage and bug fixes, expert scalability advice, and custom training so that your Prisma-powered apps stay rock-solid at any scale. Learn more or join: https://prisma.io/enterprise.

v6.17.1

Compare Source

Today, we are issuing a patch release to address a regression in v6.17.0 that affected diffing of unsupported types, leading to unnecessary or incorrect changes when creating new migrations or running db pull. This update is recommended for all users who have any fields marked as Unsupported in their schema files.

Changes

• prisma/prisma-engines#5633

v6.17.0

Compare Source

Today, we are excited to share the 6.17.0 stable release 🎉

🌟 Star this repo for notifications about new releases, bug fixes & features — or follow us on X!

Prisma ORM

Prisma ORM is the most popular ORM in the TypeScript ecosystem. Today's release brings a number of bug fixes and improvements to Prisma ORM.

Bug fixes and improvements

• Added support for Entra ID (ActiveDirectory) authentication parameters for the MS SQL Server driver adapter. For example, you can use the config object to configure DefaultAzureCredential:

  import { PrismaMssql } from '@​prisma/adapter-mssql'
  import { PrismaClient } from '@​prisma/client'
  
  const config = {
    server: 'localhost',
    port: 1433,
    database: 'mydb',
    authentication: {
      type: 'azure-active-directory-default',
    },
    options: {
      encrypt: true,
    },
  }
  
  const adapter = new PrismaMssql(config)
  const prisma = new PrismaClient({ adapter })

  Learn more in this PR.
• Relaxed the support package range for @opentelemetry/instrumentation to be compatible with ">=0.52.0 <1". Learn more in this PR.
• Added Codex CLI detection, ensuring dangerous Prisma operations are not executed by Codex without explicit user consent. Learn more in this PR.
• Fixed JSON column handling when using a MariaDB database. Learn more in this PR.
• Restored the original behaviour of group-by aggregations where they would refer to columns with explicit table names which fixes a regression that would result in ambiguous column errors. Learn more in this PR.

Prisma Postgres

Prisma Postgres is our fully managed Postgres service designed with the same philosophy of great DX that has guided Prisma for close to a decade. With this release we are introducing the following improvements:

New usage workspace metrics available in your Console Dashboard

The Dashboard in your Prisma Console account now displays new metrics about your Prisma Postgres usage:

• Key metrics
  • Estimated upcoming invoice
  • Total storage used
  • Total DBs
• Overall usage
  • Cumulative operations
  • Operations per day

Using Prisma Postgres with any tool is ready for production

Previously, the only way to connect to Prisma Postgres was using Prisma ORM. That combination is great because it gives you connection pooling, global caching and overall an amazing DX.

That being said, we understand that preferences vary and some developers prefer to use plain SQL or lower-level query builders in their applications. As of this release, these ways for connecting to Prisma Postgres are now officially generally available and can be used in your production apps!

You can connect using Drizzle, Kysely, TypeORM, psql, or any other Postgres-compatible library, database migration tools like Atlas or interfaces like DBeaver, Postico, and more.

📚 Learn more in the docs.

Enterprise support

Thousands of teams use Prisma and many of them already tap into our Enterprise & Agency Support Program for hands-on help with everything from schema integrations and performance tuning to security and compliance.

With this program you also get priority issue triage and bug fixes, expert scalability advice, and custom training so that your Prisma-powered apps stay rock-solid at any scale. Learn more or join: https://prisma.io/enterprise.

v6.16.3

Compare Source

Today, we are issuing a 6.16.3 patch release focused on bug fixes.

🛠 Fixes

• Prisma Client (prisma-client generator): fixed missing JSON null type definitions (JsonNull, DbNull, AnyNull) in the browser.ts entrypoint. (#​28186)

• Prisma Migrate: don't add the default schema (namespace) to the generated migrations unless it was specified explicitly in the schema file. This restores the pre-6.13.0 behaviour that was inadvertently changed with enabling multi-schema support by default. Users who rely on database schemas for multi-tenancy can now again use the same migration files for all of their schemas. (prisma/prisma-engines#5614)

• Prisma Client: enabled negative take with findFirst again. (prisma/prisma-engines#5616 — contributed by @​jay-l-e-e)

• Prisma Accelerate: aligned the behaviour of the new Rust-free client with Query Engine to handle self-signed certificates consistently and ensure backward compatibility. (#​28134)

• @prisma/adapter-mariadb: fixed error event listeners leak. (#​28177 — contributed by @​Tiaansu)

⚠️ Known Limitation: JSON null types in browser builds

The fix introduces the missing types, but the singleton instances differ between the client and browser entrypoints of the generated client. This means that values like Prisma.JsonNull imported from browser cannot yet be assigned to fields expected from the client entrypoint, and vice versa. This results in confusing TypeScript errors if you mix them. A follow-up improvement is planned to unify these utility types across entrypoints.

v6.16.2

Compare Source

Today, we are issuing a 6.16.2 patch release.

Bug fixes

• In Prisma ORM 6.16.0, we've enabled usage of the new engineType = client with Prisma Postgres, but our validation rules permitted invalid combinations of Prisma Postgres URLs and driver adapters. This now produces a clear error message indicating Prisma Postgres URLs and driver adapters are mutually exclusive.
• In the previous minor release, we've included a change that calls unref() on NodeJS timers to prevent them from keeping the NodeJS event loop active. This change unintentionally affected non-NodeJS runtimes like workerd, where it has resulted in runtime errors. This behavior has been made conditional to prevent these runtime errors.

v6.16.1

Compare Source

Today, we are issuing a 6.16.1 patch release.

Bug fixes

• In Prisma ORM 6.16.0, the driverAdapters and queryCompiler features were stabilized, but leftover code in the prisma-client-ts generator required them to still be specified in edge runtimes. This has now been fixed, runtimes like workerd and vercel-edge no longer require these preview features.

v6.16.0

Compare Source

Today, we are excited to share the 6.16.0 stable release 🎉

🌟 Star this repo for notifications about new releases, bug fixes & features — or follow us on X!

Prisma ORM

This section contains all the updates made in Prisma ORM v6.16.0.

Rust-free ORM and driver adapters are Generally Available

Eight months ago, we published our ORM manifesto with the first hint that we're going to remove the Rust-based query engine from Prisma ORM:

We're addressing this by migrating Prisma's core logic from Rust to TypeScript and redesigning the ORM to make customization and extension easier.

After a lot of hard work and feedback from the community, we're incredibly excited to share that the migration has been completed and you can now use Prisma ORM without its Rust engine in your production apps. 🎉 This is a major milestone in the history of Prisma ORM and comes with a lot of benefits:

• Reduced bundle size by ~90%
• Faster queries (check out our latest benchmarks)
• Lower CPU footprint
• Less deployment complexity
• Easier to make open-source contributions

… and overall a much better DX since you don't need to worry about the extra binary in your generated Prisma Client code any more.

While the Rust-free ORM will become the default in Prisma ORM v7 soon, for now you still need to opt-into using it:

1. Configure the generator block in your Prisma schema:

   generator client {
     provider   = "prisma-client" // (or "prisma-client-js") 
     output     = "../src/generated/prisma"
     engineType = "client"
   }

   Note: If you tried the Rust-free ORM before, you can now also drop the queryCompiler and driverAdapter feature flags from the previewFeatures array. And if you used binaryTargets, you can also get rid of these.
2. Install the driver adapter for your database, e.g. to use pg for PostgreSQL:

   npm install @​prisma/adapter-pg
   

3. Finally, you can instantiate PrismaClient using the PrismaPg driver adapter as follows:

   import { PrismaClient } from './generated/prisma'
   import { PrismaPg } from '@​prisma/adapter-pg'
   
   const adapter = new PrismaPg({ connectionString: env.DATABASE_URL })
   const prisma = new PrismaClient({ adapter })
   
   // ... send queries using `prisma` like before

📚 To learn more and see instructions for all other supported databases, check out the documentation.

The Rust-free version of Prisma ORM has been thoroughly tested with the prisma-client generator (see below), not with prisma-client-js. Use the old generator at your discretion.

New ESM-first prisma-client generator is Generally Available

Another major milestone has been achieved in this release: The new, flexible and ESM-first prisma-client generator is ready for production too. Here's a quick overview of its main benefits:

• No more magic generation into node_modules; generated code is fully under control by the developer
• ESM-compatible by default
• Flexible configuration for specific runtimes (Node.js, Deno, Bun, Cloudflare, …)

generator client {
  // Required
  provider = "prisma-client"
  output   = "../src/generated/prisma"

  // Optional
  engineType             = "client"
  runtime                = "nodejs"
  moduleFormat           = "esm"
  generatedFileExtension = "ts"
  importFileExtension    = "ts"
}

In addition to making it production-ready, we also made some changes to the prisma-client generator:

• removed Prisma.validator; you can use TypeScript native satisfies keyword instead
• created a new ./generared/prisma/browser entrypoint for importing types in browser environments

If you want to try out the new generator with your favorite framework, check out one of our ready-to-run examples (e.g. for Next.js, Nuxt or React Router).

📚 Learn more in the docs.

Type check performance optimizations

Runtime performance is not the only performance category that matters. In fact, when it comes to DX, type checking performance is equally important: if your TypeScript types become too complex and the compiler needs to do too much work (e.g. inferring types), it may slow down your editor, lead to laggy auto-completion or prevent jump-to-definition from working.

We've worked with TypeScript expert David Blass to find ways for improving the type checking performance in Prisma ORM and created benchmarks comparing the type checking performance with Drizzle.

You can read about the results here: Why Prisma ORM Checks Types Faster Than Drizzle

Deprecating the postgresqlExtensions Preview feature

We're deprecating the postgresqlExtensions Preview feature. Note that this doesn't mean that you can't use extensions with Prisma ORM any more. Instead of setting the Preview feature, you can install extensions manually with a customized migration via the --create-only flag:

npx prisma migrate dev --name add-extension --create-only

You can then install an extension with plain SQL in the newly created, empty migration file:

CREATE EXTENSION IF NOT EXISTS "pgcrypto";

Prisma Postgres

Prisma Postgres is our fully managed Postgres service designed with the same philosophy of great DX that has guided Prisma for close to a decade. With this release we are introducing the following improvements:

Manage OAuth apps in Prisma Console

In Prisma Console, you can now manage all of the 3rd party applications that you've granted access to perform actions on behalf of yourself in your Prisma Console account. Find the 🧩 Integrations tab in the sidenav to see which applications currently have access.

Rust-free Prisma ORM with Prisma Accelerate and Prisma Postgres

With this release, the Rust-free Prisma ORM (Query Compiler) can now be used together with Prisma Postgres and also Prisma Accelerate. This means you can take advantage of connection pooling and caching while using the new TypeScript-based ORM architecture.

To enable it, update your Prisma schema:

generator client {
  provider   = "prisma-client"
  output     = "../src/generated/prisma"
  engineType = "client"
}

We'd love for you to try this out and share your feedback as we prepare for General Availability. Please open an issue on GitHub if you encounter any problems or have suggestions.

Enterprise support

Thousands of teams use Prisma and many of them already tap into our Enterprise & Agency Support Program for hands-on help with everything from schema integrations and performance tuning to security and compliance.

With this program you also get priority issue triage and bug fixes, expert scalability advice, and custom training so that your Prisma-powered apps stay rock-solid at any scale. Learn more or join: https://prisma.io/enterprise.

v6.15.0

Compare Source

Today, we are excited to share the 6.15.0 stable release 🎉

🌟 Star this repo for notifications about new releases, bug fixes & features — or follow us on X!

Highlights

AI safety guardrails for destructive commands

Prisma ORM now includes built-in safety checks that protect against destructive commands when triggered by AI coding assistants. The CLI can recognize when it is being executed by popular AI agents such as Claude Code, Gemini CLI, Qwen Code, Cursor, Aider and Replit.

If a command like prisma migrate reset --force is attempted, Prisma ORM will prompt for explicit confirmation before proceeding.

This feature ensures that irreversible operations which drop and recreate the database are not executed automatically by an AI tool. Prisma ORM is the first ORM to provide this level of protection, making it safer to use AI-assisted development while working with your databases.

📚 Learn more in the docs.

prisma-client: runtime improvements and schema flexibility

We simplified Prisma ORM by making the runtime options for the Prisma Client more consistent and easier to understand. Previously there were several overlapping aliases which created confusion. With this release we simplified the inputs while keeping support for all the major environments you might be targeting.

Changes include:

• node has been removed, use runtime = "nodejs" instead
• deno-deploy has been removed, use runtime = "deno" instead
• vercel has been replaced by the new runtime = "vercel-edge"
• edge-light is now just an alias for vercel-edge
• nodejs, deno, and bun now share the same internal code path, while still keeping their separate input values for clarity
• The VS Code extension has been updated to reflect these changes

The updated list of supported runtimes is now:

nodejs, deno, bun, workerd (alias cloudflare), vercel-edge (alias edge-light), and react-native.

In addition, we fixed an issue where running prisma generate would fail if your schema contained no models. This is now supported with the new prisma-client generator, just like it already worked with the older prisma-client-js generator.

For example, the following schema will now generate a client without errors:

generator client {
  provider = "prisma-client"
  output   = "../generated/client"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

Running prisma generate with this schema will succeed and create the client in ./generated/client.

📚 Learn more in the docs.

Using Prisma ORM with Vercel Fluid

Fluid compute is a new compute model from Vercel that combines the flexibility of serverless with the stability of servers, making it ideal for dynamic workloads such as streaming data and AI APIs.

A common challenge in traditional serverless platforms is that when functions are suspended, database connection pools can’t close idle connections. This leads to leaked connections that stay open until the database times them out, which can exhaust the pool.

Vercel provides the attachDatabasePool utility to solve this problem. It ensures idle connections in the pool are properly released before a function is suspended, preventing connection leaks.

You can use this utility together with Prisma’s driver adapters to safely manage database connections in Fluid Compute:

import { Pool } from "pg";
import { attachDatabasePool } from "@​vercel/functions";
import { PrismaPg } from "@​prisma/adapter-pg";
import { PrismaClient } from "./generated/prisma/client";

const pool = new Pool({ connectionString: process.env.POSTGRES_URL });
attachDatabasePool(pool);

const prisma = new PrismaClient({
  adapter: new PrismaPg(pool),
});

📚 Learn more in the docs.

Other news

Prisma Postgres Management API is Generally Available

The Prisma Postgres Management API allows you to programmatically provision and manage Prisma Postgres instances. It’s the perfect way to spin up a database in your CI/CD workflow, see our GitHub Action examples for creating and deleting if you’re curious about this use case.

It also enables developers to offer databases to their own users! For example, did you know that Co.dev (YC23), a popular “low-code AI app builder” is using the Management API to provision Prisma Postgres instances to people building apps with their platform?

We’re excited to share that the Management API is now fully ready for production. With it moving into GA, we also added another piece of functionality where you can now create new projects without a default database.

We’re looking forward to see what you’re going to build with it!

📚 Learn more in the docs.

Prisma Postgres is now available on Pipedream

Prisma Postgres can now be used directly in your Pipedream workflows 🎉

With this integration, you can connect Prisma Postgres to over 2,800+ apps supported on Pipedream, enabling powerful automations and data workflows. For example, you can:

• Automatically spin up a new Prisma Postgres database when a customer signs up in Stripe.
• Connect Prisma Postgres with Slack, Notion, Airtable, or any other app in the Pipedream ecosystem

This makes it easier than ever to use Prisma Postgres in your automation pipelines, without needing to manage custom scripts or infrastructure.

📚 Learn more on the Pipedream integration page.

New --json flag for npx create-db

The npx create-db command lets you spin up a temporary, production-ready Prisma Postgres database that you can later claim for continued use. With this release, you can now add the --json flag to return the database details in JSON format.

This makes it straightforward to programmatically use the connection details, whether you are building custom APIs or integrating database provisioning into your workflows.

📚 Learn more in the docs.

Direct connections to Prisma Postgres are coming close to GA

Direct connections enable you to connect to your database using any ORM library or tool of your choice (e.g. Drizzle ORM, Kysely but also database GUIs like Postico or TablePlus).

In this release, we’ve improved the robustness of direct TCP connections and are close to bringing it to General Availability.

📚 Learn more in the docs.

Enterprise support

Thousands of teams use Prisma and many of them already tap into our Enterprise & Agency Support Program for hands-on help with everything from schema integrations and performance tuning to security and compliance.

With this program you also get priority issue triage and bug fixes, expert scalability advice, and custom training so that your Prisma-powered apps stay rock-solid at any scale. Learn more or join: https://prisma.io/enterprise.

v6.14.0

Compare Source

Today, we are excited to share the 6.14.0 stable release 🎉

🌟 Star this repo for notifications about new releases, bug fixes & features — or follow us on X!

Highlights

@unique attributes for SQL views (Preview)

Last release, we improved the robustness of SQL views defined in the Prisma schema. Views are virtual tables that don't allows for defining unique constraints, indexes or foreign keys in the underlying database.

However, as an application developer, it can be convenient to also define relationships involving views or paginate them using cursors. We've received this feedback from several people who had been using views in that way with Prisma ORM, so in this release we're re-introducing the @unique attribute for views. This attribute enables:

• relationships involving views
• findUnique queries, cursor-based pagination & implicit ordering for views

Here's an example schema using @unique and defining a relationship from a model to a view:

model User {
  id        Int            @​id @​default(autoincrement())
  email     String         @​unique
  posts     Post[]
  stats     UserPostStats? @​relation(fields: [email], references: [userEmail])
}

model Post {
  id        Int      @​id @​default(autoincrement())
  title     String
  published Boolean  @​default(false)
  createdAt DateTime @​default(now())
  authorId  Int?
  author    User?    @​relation(fields: [authorId], references: [id])
}

view UserPostStats {
  userEmail        String    @​unique
  totalPosts       BigInt?
  publishedPosts   BigInt?
  unpublishedPosts BigInt?
  latestPostDate   DateTime? @​db.Timestamp(6)
  user             User?
}

Expand to view the SQL code for this view

CREATE OR REPLACE VIEW "UserPostStats" AS
SELECT 
    u.email AS "userEmail",
    u.name AS "userName",
    COUNT(p.id) AS "totalPosts",
    COUNT(CASE WHEN p.published = true THEN 1 END) AS "publishedPosts",
    COUNT(CASE WHEN p.published = false THEN 1 END) AS "unpublishedPosts",
    MAX(p."createdAt") AS "latestPostDate"
FROM "User" u
LEFT JOIN "Post" p ON u.id = p."authorId"
GROUP BY u.id, u.email, u.name;

You can now query this view and its relationship using include:

const userPostStats = await prisma.userPostStats.findMany({
  include: {
    user: true,
  }
})

📚 Learn more in the docs.

Various fixes & stability improvements

• Fixed several issues related to new prisma-client generator and the queryCompiler Preview feature (aka “Prisma Client without Rust engines”). Both will become the default in the upcoming Prisma 7 release and we're working hard on bringing these features into General Availability. You can try them out with your favorite stack with our ready-to-run examples.
• Fixed several regressions, e.g. related to Prisma Config
• Removed middleware from Prisma Client (i.e. the prisma.$use method), which was deprecated since v4.16.0. Use Prisma Client extensions instead.
• Deprecated metrics Preview feature (which will be removed in Prisma 7)

Improved type performance

In this release, we also addressed some type performance issues that led to slower editors and lagging auto-complete. If you're curious about the details, you can check the description and changes in this PR.

Other news

Increased robustness of Management API (Early Access)

We recently released an API for programmatically managing Prisma Postgres instances that's perfect for CI/CD workflows and scripting.

In this release, we made it more robust and are bringing it closer to its General Availability release.

Revoke OAuth tokens in Prisma Console

If you use OAuth to authorize third-party applications to act on your behalf in the Prisma Console, you can now revoke any app's access at any time. The Prisma Console shows a list of your authorized (connected) apps, and you can easily remove one to immediately block further access.

ICYMI

Last release was huge, so just in case you missed it, here's the TLDR of what we put out last time:

• Prisma ORM
  • Prisma Config file (prisma.config.ts) is Generally Available – Native way to configure schema paths, migrations, seeds, and more; no need for earlyAccess flag anymore.
  • Multi-schema support is Generally Available – Allows assigning models to different database schemas in Postgres and SQL Server using @@​schema.
  • Improved SQL views support (still in Preview) – Adds guardrails for views by disabling unsupported features.
  • Externally managed tables – Lets you exclude specific tables from Prisma Migrate while still querying them via Prisma Client.
• Prisma Postgres
  • Extension support for Prisma Postgres – Prisma Postgres now supports pgvector, pg_search, pg_stat_statements, citext, pg_trgm, fuzzystrmatch, and unaccent. If you don't see the extension you need, you can request it here. Extensions only work on new instances, if you want to use any of them on your existing instance, reach out to us.
  • Management API for Prisma Postgres – REST API to provision, delete, and manage Prisma Postgres instances programmatically, perfect for CI/CD and scripting workflows.
  • GitHub Actions for Prisma Postgres – Actions for creating and deleting databases in CI/CD workflows, available on GitHub Marketplace.
  • New CLI: npx create-db – Instantly spin up a new Postgres database—no authentication required.

v6.13.0

Compare Source

Today, we are excited to share the 6.13.0 stable release 🎉

🌟 Star this repo for notifications about new releases, bug fixes & features — or follow us on X!

Highlights

In this ORM release, we’re moving the Prisma Config file and the multi-schema feature into General Availability. This means these features now are fully production-ready and we’re looking forward to seeing what you are going to build with them!

Additionally, support for SQL views is getting an important update to further stabilize its API.

Configuring Prisma via Prisma Config is now Generally Available

The prisma.config.ts file is Prisma ORM’s native way to provide configuration options for your project. It currently lets you specify:

• the locations for various Prisma-related assets, such as your:
  • Prisma schema file
  • migrations
  • SQL view definitions
  • TypedSQL queries
• a seed command to populate your database based on some executable script
• externally managed tables (see below)
• the driver adapters to be used by the Prisma CLI when interacting with your database

Here’s an example Prisma Config file that specified custom locations for various project assets in and a seed script inside a db directory:

import path from "node:path";
import { defineConfig } from "prisma/config";

export default defineConfig({
  schema: path.join("db", "schema.prisma"),
  migrations: {
    path: path.join("db", "migrations"),
    seed: "tsx db/seed.ts"
  }
});

Note that you’ll also see warning now if you defined a prisma.seed command in package.json.

We’re excited to move the prisma.config.ts file into General Availability. If you used it before in your projects, you can now drop earlyAccess from its options:

import { defineConfig } from "prisma/config";

export default defineConfig({
- earlyAccess: true,
});

There still are and will be fields on the Prisma Config object that are Early Access or Preview features. To opt-into these, you’ll need to explicitly declare them via a new experimental field.

For example, usage of adapters is currently still in Preview:

import { defineConfig } from "prisma/config";

export default defineConfig({
    experimental: {
      adapter: true,
    },
    // requires `experimental.adapter`
    adapter: async () => {
			// ...
    },
});

Finally, the Prisma Config file now also supports various file extensions so it fits neatly into your individual project setups: .js, .ts, .mjs, .cjs, .mts, .cts. It also can be defined as .config/prisma.${extension}, where extension is the same one as file extensions above.

📚 Learn more in the docs.

Using multiple schemas in now Generally Available

Databases like PostgreSQL or SQL Server provide a way to logically organize your tables in dedicated namespaces called schemas. In Prisma ORM, you can assign tables to various schemas via the @@​schema attribute:

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
  schemas  = ["base", "shop"]
}

model User {
  id     Int     @​id
  orders Order[]

  @​@​schema("base")
}

mode

</details>

---

### Configuration

📅 **Schedule**: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about these updates again.

---

 - [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check this box

---

This PR was generated by [Mend Renovate](https://mend.io/renovate/). View the [repository job log](https://developer.mend.io/github/josephgodwinkimani/nestjs-graphql-prisma).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzNy44Ny4yIiwidXBkYXRlZEluVmVyIjoiNDIuMTkuOSIsInRhcmdldEJyYW5jaCI6Im1haW4ifQ==-->

[changeset-bot]

⚠️ No Changeset found

Latest commit: facc05a

Merging this PR will not cause a version bump for any packages. If these changes should not result in a new version, you're good to go. If these changes should result in a version bump, you need to add a changeset.

Click here to learn what changesets are, and how to add one.

Click here if you're a maintainer who wants to add a changeset to this PR