@prisma/adapter-planetscale releases, page 2

6.0.0

28 Nov 2024

breaking
For Node.js 18 the minimum supported version is 18.18.0
breaking
For Node.js 20 the minimum supported version is 20.9.0
breaking
For Node.js 22 the minimum supported version is 22.11.0

We’re excited to share the Prisma ORM v6 release today 🎉

As this is a major release, it includes a few breaking changes that may affect your application. Before upgrading, we recommend that you check out our upgrade guide to understand the impact on your application.

If you want to have an overview of what we accomplished since v5, check out our announcement blog post: Prisma 6: Better Performance, More Flexibility & Type-Safe SQL.

🌟 Help us spread the word about Prisma by starring the repo ☝️ or posting on X about the release.

Breaking changes

⚠️ This section contains a list of breaking changes. If you upgrade your application to Prisma ORM v6 without addressing these, your application is going to break! For detailed upgrade instructions, check out the upgrade guide. ⚠️

Minimum supported Node.js versions

The new minimum supported Node.js versions for Prisma ORM v6 are:

breaking
For Node.js 18 the minimum supported version is 18.18.0
breaking
For Node.js 20 the minimum supported version is 20.9.0
breaking
For Node.js 22 the minimum supported version is 22.11.0

There is no official support for Node.js <18.18.0, 19, 21, 23.

Minimum supported TypeScript version

The new minimum supported TypeScript version for Prisma ORM v6 is: 5.1.0.

Schema change for implicit m-n relations on PostgreSQL

If you're using PostgreSQL and are defining implicit many-to-many relations in your Prisma schema, Prisma ORM maintains the relation table for you under the hood. This relation table has A and B columns to represent the tables of the models that are part of this relation.

Previous versions of Prisma ORM used to create a unique index on these two columns. In Prisma v6, this unique index is changing to a primary key in order to simplify for the default replica identity behaviour.

If you're defining implicit m-n relations in your Prisma schema, the next migration you'll create will contain ALTER TABLE statements for all the relation tables that belong to these relations.

Full-text search on PostgreSQL

The fullTextSearch Preview feature is promoted to General Availability only for MySQL. This means that if you're using PostgreSQL and currently make use of this Preview feature, you now need to use the new fullTextSearchPostgres Preview feature.

Usage of Buffer

Prisma v6 replaces the usage of Buffer with Uint8Array to represent fields of type Bytes. Make sure to replace all your occurrences of the Buffer type with the new Uint8Array.

Removed NotFoundError

In Prisma v6, we removed the NotFoundError in favor of PrismaClientKnownRequestError with error code P2025 in findUniqueOrThrow() and findFirstOrThrow(). If you've relied on catching NotFoundError instances in your code, you need to adjust the code accordingly.

New keywords that can't be used as model names: async, await, using

With this release, you can't use async, await and using as model names any more.

⚠️ For detailed upgrade instructions, check out the upgrade guide. ⚠️

Preview features promoted to General Availability

In this release, we are promoting a number of Preview features to General Availability.

fullTextIndex

If you use the full-text index feature in your app, you can now remove fullTextIndex from the previewFeatures in your Prisma schema:

generator client {
  provider        = "prisma-client-js"
- previewFeatures = ["fullTextIndex"]
}

fullTextSearch

If you use the full-text search feature with MySQL in your app, you can now remove fullTextSearch from the previewFeatures in your Prisma schema:

generator client {
  provider        = "prisma-client-js"
- previewFeatures = ["fullTextSearch"]
}

If you are using it with PostgreSQL, you need to update the name of the feature flag to fullTextSearchPostgres:

generator client {  
  provider        = "prisma-client-js"
- previewFeatures = ["fullTextSearch"]  
+ previewFeatures = ["fullTextSearchPostgres"]
}

New features

We are also releasing new features with this release:

Company news

Prisma Postgres is free during Early Access

In case you missed it: We recently launched Prisma Postgres, a serverless database with zero cold starts, a generous free tier, connection pooling, real-time events, and a lot more! It’s entirely free during the Early Access phase, try it now!

Let us know what you think of Prisma ORM

We're always trying to improve! If you've recently used Prisma ORM, we'd appreciate hearing your thoughts about your experience via this 2min survey.

5.22.0

5 Nov 2024

5.21.1

17 Oct 2024

Fixed a bug where migrations were not using shadow database correctly in some edge cases

5.21.0

15 Oct 2024

Avoid regex crate for wasm bundle size (to keep cloudflare free plan)

5.20.0

24 Sep 2024

🌟 Help us spread the word about Prisma by starring the repo or posting on X about the release. 🌟

Highlights

strictUndefinedChecks in Preview

With Prisma ORM 5.20.0, the Preview feature strictUndefinedChecks will disallow any value that is explicitly undefined and will be a runtime error. This change is direct feedback from this GitHub issue and follows our latest proposal on the same issue.

To demonstrate the change, take the following code snippet:

prisma.table.deleteMany({
  where: {
    // If `nullableThing` is nullish, this query will remove all data.
    email: nullableThing?.property,
  }
})

In Prisma ORM 5.19.0 and below, this could result in unintended behavior. In Prisma ORM 5.20.0, if the strictUndefinedChecks Preview feature is enabled, you will get a runtime error instead:

Invalid \`prisma.user.findMany()\` invocation in
/client/tests/functional/strictUndefinedChecks/test.ts:0:0
  XX })
  XX 
  XX test('throws on undefined input field', async () => {
→ XX   const result = prisma.user.deleteMany({
         where: {
           email: undefined
                  ~~~~~~~~~
         }
       })
Invalid value for argument \`where\`: explicitly \`undefined\` values are not allowed."

We have also introduced the Prisma.skip symbol, which will allow you to get the previous behavior if desired.

prisma.table.findMany({
  where: {
    // Use Prisma.skip to skip parts of the query
    email: nullableEmail ?? Prisma.skip
  }
})

From Prisma ORM 5.20.0 onward, we recommend enabling strictUndefinedChecks, along with the TypeScript compiler option exactOptionalPropertyTypes, which will help catch cases of undefined values at compile time. Together, these two changes will help protect your Prisma queries from potentially destructive behavior.

strictUndefinedChecks will be a valid Preview feature for the remainder of Prisma ORM 5. With our next major version, this behavior will become the default and the Preview feature will be “graduated” to Generally Available.

If you have any questions or feedback about strictUndefinedChecks, please ask/comment in our dedicated Preview feature GitHub discussion.

typedSql bug fix

Thank you to everyone who has tried out our typedSql Preview feature and provided feedback! This release has a quick fix for typescript files generated when Prisma Schema enums had hyphens.

Fixes and improvements

Prisma

Prisma Engines

5.19.1

2 Sep 2024

Today, we are issuing the 5.19.1 patch release.

5.19.0

27 Aug 2024

Make sure that you have the latest version of prisma and @prisma/client installed:
```
npm install -D prisma@latest
npm install @prisma/client@latest
```

Enable the typedSql Preview feature in your Prisma Schema.

   generator client {
     provider = "prisma-client-js"
     previewFeatures = ["typedSql"]
   }

Create a sql subdirectory of your prisma directory.
```
mkdir -p prisma/sql
```

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

🌟 Help us spread the word about Prisma by starring the repo or posting on X about the release. 🌟

Highlights

Introducing TypedSQL

TypedSQL is a brand new way to interact with your database from Prisma Client. After enabling the typedSql Preview feature, you’re able to write SQL queries in a new sql subdirectory of your prisma directory. These queries are then checked by Prisma during using the new --sql flag of prisma generate and added to your client for use in your code.

To get started with TypedSQL:

Make sure that you have the latest version of prisma and @prisma/client installed:
```
npm install -D prisma@latest
npm install @prisma/client@latest
```

Enable the typedSql Preview feature in your Prisma Schema.

   generator client {
     provider = "prisma-client-js"
     previewFeatures = ["typedSql"]
   }

Create a sql subdirectory of your prisma directory.
```
mkdir -p prisma/sql
```
You can now add .sql files to the sql directory! Each file can contain one sql query and the name must be a valid JS identifier. For this example, say you had the file getUsersWithPosts.sql with the following contents:
```
SELECT u.id, u.name, COUNT(p.id) as "postCount"
FROM "User" u
LEFT JOIN "Post" p ON u.id = p."authorId"
GROUP BY u.id, u.name
```

Import your SQL query into your code with the @prisma/client/sql import:

   import { PrismaClient } from '@prisma/client'
   import { getUsersWithPosts } from '@prisma/client/sql'

   const prisma = new PrismaClient()

   const usersWithPostCounts = await prisma.$queryRawTyped(getUsersWithPosts)
   console.log(usersWithPostCounts)

There’s a lot more to talk about with TypedSQL. We think that the combination of the high-level Prisma Client API and the low-level TypedSQL will make for a great developer experience for all of our users.

To learn more about behind the “why” of TypedSQL be sure to check out our announcement blog post.

For docs, check out our new TypedSQL section.

Bug fixes

Driver adapters and D1

A few issues with our driverAdapters Preview feature and Cloudflare D1 support were resolved via #4970 and #24922

Mathematic operations such as max, min, eq, etc in queries when using Cloudflare D1.
Resolved issues when comparing BigInt IDs when relationMode="prisma" was enabled and Cloudflare D1 was being used.

Joins

#23742 fixes Prisma Client not supporting deeply nested some clauses when the relationJoins Preview feature was enabled.

MongoDB

The MongoDB driver for Rust (that our query engine users under the hood) had behavior that prioritized IPv4 connections over IPv6 connections. In IPv6-only environments, this could lead to significant "cold starts" where the query engine had to wait for IPv4 to fail before the driver would try IPv6.

With help from the MongoDB team, this has been resolved. The driver will now try IPv4 and IPv6 connections in parallel and then move forward with the first response. This should prevent cold start issues that have been seen with MongoDB in Prisma Accelerate.

Thank you to the MongoDB team!

Join us

Looking to make an impact on Prisma in a big way? We're now hiring engineers for the ORM team!

Senior Engineer (TypeScript): This person will be primarily working on the TypeScript side and evolving our Prisma client. Rust knowledge (or desire to learn Rust) is a plus.
Senior Engineer (Rust): This person will be focused on the prisma-engines Rust codebase. TypeScript knowledge (or, again, a desire to learn) is a plus.

5.18.0

6 Aug 2024

SQLite db will now be created and read from the correct location when using prismaSchemaFolder.
[Empty Json fields will now return `` instead of null when accessed through a join using the relationJoins Preview feature.](#22923)
Support UUID v7

5.17.0

16 Jul 2024

5.16.2

9 Jul 2024

nextjs app deployed to vercel edge can't import prisma WASM module

5.16.1

27 Jun 2024

5.16.0

25 Jun 2024

When using relative paths in Prisma Schema files with the prismaSchemaFolder feature, a path is now relative to the file it is defined in rather than relative to the prisma/schema folder. This means that if you have a generator block in /project/prisma/schema/config/generator.prisma with an output of ./foo the output will be resolved to /project/prisma/schema/config/foo rather than /project/prisma/foo. The path to a SQLite file will be resolved in the same manner.
We realized that during migration many people would have prisma/schema as well as prisma/schema.prisma. Our initial implementation looked for a .prisma file first and would ignore the schema folder if it exists. This is now an error.
Wrong Parameterized Types Sent for SQL Server Queries

🌟 Help us spread the word about Prisma by starring the repo or tweeting about the release. 🌟

Highlights

Omit model fields globally

With Prisma ORM 5.16.0 we’re more than happy to announce that we’re expanding the omitApi Preview feature to also include the ability to omit fields globally.

When the Preview feature is enabled, you’re able to define fields to omit when instantiating Prisma Client.

const prisma = new PrismaClient({
  omit: {
    user: {
      // make sure that password is never queried.
      password: true,
    },
  },
});

You’re also able to omit fields from multiple models and multiple fields from the same model

const prisma = new PrismaClient({
  omit: {
    user: { 
      // make sure that password and internalId are never queried.
      password: true,
      internalId: true,
    },
    post: {
      secretkey: true,
    },
  },
});

With both local and global omit, you now have the flexibility to completely remove sensitive fields while also tailoring individual queries. If you need the ability to generally omit a field except in a specific query, you can also overwrite a global omit locally

const prisma = new PrismaClient({
  omit: {
    user: { 
      // password is omitted globally.
      password: true,
    },
  },
});

const userWithPassword = await prisma.user.findUnique({
  omit: { password: false }, // omit now false, so password is returned
  where: { id: 1 },
});

Changes to prismaSchemaFolder

In 5.15.0 we released the prismaSchemaFolder Preview feature, allowing you to create multiple Prisma Schema files in a prisma/schema directory. We’ve gotten a lot of great feedback and are really excited with how the community has been using the feature.

To continue improving our multi-file schema support, we have a few breaking changes to the prismaSchemaFolder feature:

When using relative paths in Prisma Schema files with the prismaSchemaFolder feature, a path is now relative to the file it is defined in rather than relative to the prisma/schema folder. This means that if you have a generator block in /project/prisma/schema/config/generator.prisma with an output of ./foo the output will be resolved to /project/prisma/schema/config/foo rather than /project/prisma/foo. The path to a SQLite file will be resolved in the same manner.
We realized that during migration many people would have prisma/schema as well as prisma/schema.prisma. Our initial implementation looked for a .prisma file first and would ignore the schema folder if it exists. This is now an error.

Changes to fullTextSearch

In order to improve our full-text search implementation we have made a breaking change to the fullTextSearch Preview feature.

Previously, when the feature was enabled we updated the <Model>OrderByWithRelationInput TypeScript type with the <Model>OrderByWithRelationAndSearchRelevanceInput type. However, we have noted that there are no cases where relational ordering is needed but search relevance is not. Thus, we have decided to remove the <Model>OrderByWithRelationAndSearchRelevanceInput naming and only use the <Model>OrderByWithRelationInput naming.

Fixes and improvements

Prisma

Language tools (e.g. VS Code)

Prisma Engines

5.15.1

18 Jun 2024

5.15.0

4 Jun 2024

breaking
Breaking change? Int switched to being Int32 for MongoDB

Enable the prismaSchemaFolder Preview feature by including it in the previewFeatures field of your generator.

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

generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["prismaSchemaFolder"]
}

Create a schema subdirectory under your prisma directory.

5.14.0

14 May 2024

5.13.0

23 Apr 2024

5.12.1

4 Apr 2024

5.12.0

2 Apr 2024

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

🌟 Help us spread the word about Prisma by starring the repo or posting on X about the release.

Highlights

Cloudflare D1 (Preview)

This release brings Preview support for Cloudflare D1 with Prisma ORM 🥳

D1 is Cloudflare’s SQLite database that can be used when deploying applications with Cloudflare.

When using Prisma ORM with D1, you can continue to: model your database with Prisma schema language, specify sqlite as your database provider in your Prisma schema, and interact with your database using Prisma Client.

To use Prisma ORM and D1 on Cloudflare Workers or Cloudflare Pages, you need to set sqlite as your database provider and use the @prisma/adapter-d1 database adapter via the driverAdapters Preview feature, released back in version 5.4.0.

Here is an example of sending a query to your D1 database using Prisma Client in your Worker:

// src/index.ts file
import { PrismaClient } from '@prisma/client'
import { PrismaD1 } from '@prisma/adapter-d1'

// Add the D1Database to the Env interface
export interface Env {
// This must match the binding name defined in your wrangler.toml configuration
  DB: D1Database
}

export default {
  async fetch(
    request: Request,
    env: Env,
    ctx: ExecutionContext
  ): Promise<Response> {
    // Make sure the database name matches the binding name in wrangler.toml and Env interface
    const adapter = new PrismaD1(env.DB)
    // Instantiate PrismaClient using the PrismaD1 driver adapter
    const prisma = new PrismaClient({ adapter })

    const users = await prisma.user.findMany()
    const result = JSON.stringify(users)
    return new Response(result)
  },
}

📚 Documentation: D1 Documentation

✍️ Blog post: Build Applications at the Edge with Prisma ORM & Cloudflare D1 (Preview)

📣 Share your feedback: D1 Driver Adapter

🚀 Example project: Deploy a Cloudflare Worker with D1

createMany() for SQLite

Bringing support for createMany() in SQLite has been a long-awaited feature ⭐

createMany() is a method on Prisma Client, released back in version 2.16.0, that lets you insert multiple records into your database at once. This can be really useful when seeding your database or inserting bulk data.

Here is an example of using createMany() to create new users:

const users = await prisma.user.createMany({
  data: [
    { name: 'Sonali', email: 'sonali@prisma.io' },
    { name: 'Alex', email: 'alex@prisma.io' },
    { name: 'Yewande', email: 'yewande@prisma.io' },
    { name: 'Angelina', email: 'angelina@prisma.io' },
  ],
})

Before this release, if you wanted to perform bulk inserts with SQLite, you would have most likely used $queryRawUnsafe to execute raw SQL queries. But now you don’t have to go through all that trouble 🙂

With SQLite, createMany() works exactly the same way from an API standpoint as it does with other databases except it does not support the skipDuplicates option. At the behavior level, SQLite will split createMany() entries into multiple INSERT queries when the model in your schema contains fields with attributes like @default(dbgenerated()) or @default(autoincrement()) and when the fields are not consistently provided with values across the entries.

📚Documentation: createMany() - Prisma Client API Reference

Fixes and Improvements

Prisma Client

5.11.0

12 Mar 2024

Vercel Edge Functions and Vercel Edge Middleware
Cloudflare Workers and Cloudflare Pages
Neon Serverless Driver (for PostgreSQL databases hosted via Neon)

5.10.2

21 Feb 2024

Invalid character error persists on 5.10.1 in Prisma Studio

5.10.1

20 Feb 2024

Error: Invalid character when schema.prisma includes Chinese/Non-ASCII characters in a comment

5.10.0

20 Feb 2024

join (default): Sends a single query to the database and joins the data on the database-level.
query: Sends multiple queries to the database and joins the data on the application-level.
relationLoadStrategy is supported for MySQL v8.0.14 and higher. MariaDB is not supported.

5.9.1

1 Feb 2024

5.9.0

30 Jan 2024

Improve the performance of relation queries by introducing JOINs (see last release).
Support deployment to edge functions (already available in Early Access, you can apply for trying it out by taking our survey).
feat(qe): avoid extra select on delete queries

5.8.1

15 Jan 2024

Parallel execution with Promise.all causes P2024 error in version 5.8.0 due to connection limit.

5.8.0

9 Jan 2024

join — uses JOINs to fetch relation data
query — uses separate queries to fetch relation data
Log output of Node-API library engine is different

5.7.1

18 Dec 2023

5.7.0

6 Dec 2023

🌟 Help us spread the word about Prisma by starring the repo or posting on X (formerly Twitter) about the release.

Highlights

✨ In this release, we improved the SQL queries Prisma Client generates for you with two new Preview features, the driver adapters, and support for the database drivers we currently support. 5.7.0 will be the last release of the year. Stay tuned for the next one in January! ✨

Preview support for JOINs for relation queries for PostgreSQL and CockroachDB

We’re excited to announce Preview support for JOINs in Prisma Client when querying relations. Support for JOINs has been a long-standing feature request, and this release adds support for PostgreSQL and CockroachDB. The upcoming releases will expand support for other databases Prisma supports.

To get started using JOINs, enable the Preview feature in your Prisma schema:

// schema.prisma
generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["relationJoins"]
}

Run prisma generate to regenerate Prisma Client and enable the Preview feature.

Prisma Client will use a JOIN in your query to fetch relation data for a majority of the cases.

Example queries

1-1 relation queries example

Prisma Client query

await prisma.user.findUnique({
	where: {
		id: 1
	},
	include: {
		profile: true
	}
})

SQL

SELECT
	"t1"."id",
	"t1"."name",
	"User_profile"."__prisma_data__" AS "profile"
FROM
	"public"."User" AS "t1"
	LEFT JOIN LATERAL (
		SELECT
			COALESCE(JSON_AGG("__prisma_data__"), '[]') AS "__prisma_data__"
		FROM
			(
				SELECT
					"t4"."__prisma_data__"
				FROM
					(
						SELECT
							JSON_BUILD_OBJECT(
								'id',
								"t3"."id",
								'bio',
								"t3"."bio",
								'userId',
								"t3"."userId"
							) AS "__prisma_data__"
						FROM
							(
								SELECT
									"t2".*
								FROM
									"public"."Profile" AS "t2"
								WHERE
									"t1"."id" = "t2"."userId"
							) AS "t3"
					) AS "t4"
			) AS "t5"
	) AS "User_profile" ON TRUE
WHERE "t1"."id" = $1
LIMIT $2

1-m relation queries example

Prisma Client query

await prisma.user.findUnique({
	where: {
		id: 1
	},
	include: {
		posts: true
	}
})

SQL

SELECT
	"t1"."id",
	"t1"."name",
	"User_posts"."__prisma_data__" AS "posts"
FROM
	"public"."User" AS "t1"
	LEFT JOIN LATERAL (
		SELECT
			COALESCE(JSON_AGG("__prisma_data__"), '[]') AS "__prisma_data__"
		FROM
			(
				SELECT
					"t4"."__prisma_data__"
				FROM
					(
						SELECT
							JSON_BUILD_OBJECT(
								'id',
								"t3"."id",
								'title',
								"t3"."title",
								'content',
								"t3"."content",
								'published',
								"t3"."published",
								'authorId',
								"t3"."authorId"
							) AS "__prisma_data__"
						FROM
							(
								SELECT
									"t2".*
								FROM
									"public"."Post" AS "t2"
								WHERE
									"t1"."id" = "t2"."authorId"
									/* root select */
							) AS "t3"
							/* inner select */
					) AS "t4"
					/* middle select */
			) AS "t5"
			/* outer select */
	) AS "User_posts" ON TRUE
WHERE "t1"."id" = $1
LIMIT $2

m-n relation queries example

Prisma Client query

await prisma.post.findUnique({
	where: {
		id: 1
	},
	include: {
		tags: true
	}
})

SQL

SELECT
	"t1"."id",
	"t1"."title",
	"t1"."content",
	"t1"."published",
	"t1"."authorId",
	"Post_tags_m2m"."__prisma_data__" AS "tags"
FROM
	"public"."Post" AS "t1"
	LEFT JOIN LATERAL (
		SELECT
			COALESCE(JSON_AGG("__prisma_data__"), '[]') AS "__prisma_data__"
		FROM
			(
				SELECT
					"Post_tags"."__prisma_data__"
				FROM
					"public"."_PostToTag" AS "t2"
					LEFT JOIN LATERAL (
						SELECT
							JSON_BUILD_OBJECT('id', "t4"."id", 'name', "t4"."name") AS "__prisma_data__",
							"t4"."id"
						FROM
							(
								SELECT
									"t3".*
								FROM
									"public"."Tag" AS "t3"
								WHERE
									"t2"."B" = "t3"."id"
									/* root select */
							) AS "t4"
					) AS "Post_tags" ON TRUE
				WHERE
					"t2"."A" = "t1"."id"
			) AS "Post_tags_m2m_1"
	) AS "Post_tags_m2m" ON TRUE
WHERE "t1"."id" = $1
LIMIT $2

Share your feedback and create a bug report if you encounter any issues.

Prisma’s distinct option now uses SQL queries (Preview)

From this release, Prisma Client’s distinct option now uses the native SQL DISTINCT ON for unordered queries with PostgreSQL and CockroachDB. The upcoming releases will expand support for the other databases that Prisma supports.

Prisma Client already supports querying for distinct records. However, Prisma Client took care of the post-processing for distinct records in memory.

To get started, enable the Preview feature in your Prisma schema:

// schema.prisma
generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["nativeDistinct"]
}

Regenerate your Prisma Client to get started using the Preview feature.

Given the following Prisma Client query:

await prisma.user.findMany({
    distinct: ['role'],
    select: {
      role: true,
    },
})

Before 5.7.0

Previously, Prisma Client handled the post-processing to select distinct records in-memory. Therefore, the following query was generated and executed against your database:

SELECT
	"public"."User"."id",
	"public"."User"."role"::text
FROM
	"public"."User"
WHERE
	1 = 1 OFFSET $1

After 5.7.0

SELECT DISTINCT ON ("public"."User"."role")
	"public"."User"."id",
	"public"."User"."role"::text
FROM
	"public"."User"
WHERE
	1 = 1 OFFSET $1

Share your feedback and create a bug report if you encounter any issues.

Improved support for Netlify using Node.js v20

In this release, we improved Prisma support when deploying to Netlify on Node.js v20. Previously, the Prisma Client could not resolve the location of the Query Engine after deploying to Netlify when using Node.js v20. If you run into this issue, we recommend updating to Prisma v5.7.0.

We recommend giving this comment on GitHub a read if you are not yet able to upgrade Prisma, to learn how to get around the error.

Fixes and improvements

Prisma Client

Prisma

Planetscale Driver doesn't work anymore after updating to 5.6.0

Prisma Migrate

prisma debug command does not show env variables declared in .env file

Company news

We’re hiring!

If you're interested in joining our growing team to help empower developers to build data-intensive applications, Prisma is the place for you.

We're hiring for the following roles:

5.6.0

14 Nov 2023

🌟 Help us spread the word about Prisma by starring the repo or tweeting about the release. 🌟

🚀 Prisma Accelerate, our connection pool and global edge cache, is now Generally Available! Sign up to give it a try. 🚀

Highlights

Driver adapters improvements (Preview)

In version 5.4.0, we released driverAdapters into Preview. The driverAdapters feature enables Prisma Client to access your database using JavaScript or Serverless database drivers.

In this release, we fixed many bugs for the existing driver adapters. We appreciate all the community feedback that has helped us improve this feature!

PlanetScale serverless driver adapter improvements

This release also introduces a small breaking change to the @prisma/adapter-planetscale package to improve its stability and performance. The serverless driver adapter will now use a connection pool instead of a single connection from PlanetScale’s serverless driver.

In case you’re using the @prisma/adapter-planetscale, update your Prisma Client instance with the following:

-import { connect } from '@planetscale/database'
+import { Client } from '@planetscale/database'
import { PrismaPlanetScale } from '@prisma/adapter-planetscale'
import { PrismaClient } from '@prisma/client'
import { fetch as undiciFetch } from 'undici';

-const connection = connect({ url: connectionString, fetch: undiciFetch })
+const client = new Client({ url: connectionString, fetch: undiciFetch })

-const adapter = new PrismaPlanetScale(connection)
+const adapter = new PrismaPlanetScale(client)

const prisma = new PrismaClient({ adapter })

If you run into the following error: [TypeError]: PrismaPlanetScale must be initialized with an instance of Client., you can use the following snippet when defining your Prisma Client instance:

import { createRequire } from "node:module";
import { PrismaPlanetScale } from "@prisma/adapter-planetscale";
import { fetch as undiciFetch } from 'undici';

const require = createRequire(import.meta.url);
const { Client } = require("@planetscale/database");

const client = new Client({ url:  process.env.DATABASE_URL , fetch: undiciFetch })
const adapter = new PrismaPlanetScale(client);

Request for feedback

We encourage you to try out the driver adapters and share your feedback to help us move it to General Availability in either of the following GitHub discussions:

Refer to our docs to learn more about driver adapters.

New prisma debug command

This release introduces a new command: prisma debug. The command provides debugging information such as environment variables that Prisma Client, Prisma Migrate, Prisma CLI, and Prisma Studio use. The command is also useful when creating a bug report as the information complements the output of the prisma -v command.

You can learn more about the command in our docs.

Read replicas extension improvements

We also released version 0.3.0 of the @prisma/extension-read-replicas package that contains the following improvements:

A new $replica() method that explicitly enables you to use a replica for your query.
For example, by default, the queryRaw and executeRaw methods are forwarded to the primary database, as they could try to write to the database. You can use the $replica() method with either of the *Raw methods to explicitly execute your query against a replica instead of your primary database.
Validation for when there’s an empty list of replicas.
Webpack bundling fixes

We want to thank you, our community members, for your contributions! 🙏

You can find additional information on the changes in the extension’s release. You can learn more about the extension in the announcement blog post.

Package provenance

npm has introduced provenance statements to improve supply-chain security and transparency of packages. This allows developers to verify where and how packages are built.

Starting with the 5.6.0 release, all npm packages for Prisma ORM will be published with provenance statements. If you maintain a Prisma Client extension or generator, we encourage you to enable provenance statements when publishing to npm.

Fixes and improvements

Prisma Migrate

Prisma Client

Prisma CLI

prisma debug

Company news

Prisma Accelerate is now Generally Available

We're excited to share that Prisma Accelerate is now Generally Available. Prisma Accelerate is a global database cache that's available in over 280 locations and provides scalable connection pooling for serverless and edge applications.

Learn more in the announcement blog post. Sign up and try out Prisma Accelerate here.

We’re hiring!

If you're interested in joining our growing team to help empower developers to build data-intensive applications, Prisma is the place for you.

We're hiring for an Engineering Manager: Prisma Data Platform.

5.5.2

25 Oct 2023

Error: sha256 checksum of https://binaries.prisma.sh/all_commits/475c616176945d72f4330c92801f0c5e6398dc0f/windows/query_en gine.dll.node.gz (zipped) should be 748d039badd0919d022fff7d554b66b6937b79035861a6ae9a80c5a95eee76f5 but is b867ad335ee6f58c6a38f665dd641c95e6adff3061f92b7613c62cae1c3362bb

5.5.1

25 Oct 2023

5.5.0 regression: typescript error when trying to pass PrismaPlanetScale adapter to the constructor

5.5.0

24 Oct 2023

5.4.3

13 Oct 2023

5.4.2

9 Oct 2023

5.4.1

6 Oct 2023

5.4.0

4 Oct 2023

Removed an unnecessary INNER JOIN used in relation filter queries (Big thank you to @KhooHaoYit for helping out)
Use of LEFT JOIN's for to-one relations. Previously, Prisma made use of sub-queries to fetch data.
Removing all SELECT queries used to fetch data that would be used as input for the DELETE operation. In some cases, this also improves index usage.

🌟 Help us spread the word about Prisma by starring the repo or tweeting about the release. 🌟

Highlights

Preview support for PlanetScale and Neon serverless database drivers

We’re excited to announce Preview support for the Neon and PlanetScale serverless database drivers. The PlanetScale and Neon serverless database drivers allow Prisma to connect to your database using protocols besides TCP — HTTP (PlanetScale) or WebSockets (Neon).

To get started with the serverless database drivers, first enable the driverAdapters Preview feature flag in your Prisma schema:

// schema.prisma
generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["driverAdapters"]
}

Next, to set up Prisma Client to use the serverless database drivers:

PlanetScale

Install the Prisma adapter for PlanetScale and PlanetScale serverless database driver, and undici:

npm install @prisma/adapter-planetscale @planetscale/database undici

Prisma ORM supports Node 16 and up. In Node 18 and up, undici is not needed.

Ensure you update the host value in your connection string to aws.connect.psdb.cloud. You can learn more about this here.

DATABASE_URL='mysql://johndoe:strongpassword@aws.connect.psdb.cloud/clear_nightsky?sslaccept=strict'

Update your Prisma Client instance to use the PlanetScale database driver:

// Import required dependencies
import { connect } from '@planetscale/database';
import { PrismaPlanetScale } from '@prisma/adapter-planetscale';
import { PrismaClient } from '@prisma/client';
import { fetch as undiciFetch } from 'undici';

// Initialize Prisma Client with the PlanetScale serverless database driver
const connection = connect({ url: connectionString, fetch: undiciFetch });
const adapter = new PrismaPlanetScale(connection);
const prisma = new PrismaClient({ adapter });

PlanetScale Driver in 5.7.0 and later

In Prisma 5.7.0, usage of the PlanetScale driver adapter changed to the following:

// For Prisma 5.7.0 and later
// Import required dependencies
import { Client } from '@planetscale/database';
import { PrismaPlanetScale } from '@prisma/adapter-planetscale';
import { PrismaClient } from '@prisma/client';

// Initialize Prisma Client with the PlanetScale serverless database driver
const client = new Client({ url: process.env.DATABASE_URL });
const adapter = new PrismaPlanetScale(client);
const prisma = new PrismaClient({ adapter });

Neon

Install the Prisma adapter for Neon, Neon serverless database driver and undici (WebSockets):

npm install @prisma/adapter-neon @neondatabase/serverless undici

Update your Prisma Client instance to use the Neon serverless database driver:

// Import required dependencies
import { Pool, neonConfig } from '@neondatabase/serverless';
import { PrismaNeon } from '@prisma/adapter-neon';
import { PrismaClient } from '@prisma/client';
import { WebSocket } from 'undici'

neonConfig.webSocketConstructor = WebSocket;

// Initialize Prisma Client with the Neon serverless database driver
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const adapter = new PrismaNeon(pool);
const prisma = new PrismaClient({ adapter });

Let us know your feedback about the Neon or Planetscale serverless database drivers in the linked GitHub discussions. Create a bug report if you run into any issues.

Early Access support for Turso

Turso is an edge-hosted, distributed database that's based on libSQL, an open-source and open-contribution fork of SQLite, enabling you to bring data closer to your application and minimize query latency.

Since support for Turso is in Early Access, there may be some rough edges which we’re still working on it to improve the API and overall support. Additionally, it is behind the driverAdapters Preview feature flag. Enable it to get started using Turso in your project:

// schema.prisma
generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["driverAdapters"]
}

Next, install the Prisma Client adapter for Turso and the libSQL database client

npm install @prisma/adapter-libsql @libsql/client

Update your Prisma Client instance:

// Import required dependencies
import { PrismaClient } from '@prisma/client'
import { PrismaLibSQL } from '@prisma/adapter-libsql'
import { createClient } from '@libsql/client'

// Create a new instance of the libSQL database client
const libsql = createClient({
  // @ts-expect-error
  url: process.env.TURSO_DATABASE_URL,
  authToken: process.env.TURSO_AUTH_TOKEN 
})

// Create a Prisma "adapter" for libSQL
const adapter = new PrismaLibSQL(libsql)
// Pass the adapter option to the Prisma Client instance
const prisma = new PrismaClient({ adapter })

You can learn more on how to use Prisma together with Turso in the announcement blog post.

Try it out! Let us know what you think and create a bug report if you run into any issues.

Query performance improvements

In our continued efforts to make Prisma Client faster, we identified and improved the performance of different types of queries.

Relation filters improvements

We made the following improvements to relation filters:

Removed an unnecessary INNER JOIN used in relation filter queries (Big thank you to @KhooHaoYit for helping out)
Use of LEFT JOIN's for to-one relations. Previously, Prisma made use of sub-queries to fetch data.

Example Prisma Client query

prisma.comment.findMany({
  where: {
    post: {
      author: {
        name: "John"
      }
    }
  }
})

Before 5.4.0

SELECT
  "Comment"."id"
FROM
  "Comment"
WHERE
  ("Comment"."id") IN (
    SELECT
      "t0"."id"
    FROM
      "Comment" AS "t0"
      INNER JOIN "Post" AS "j0" ON ("j0"."id") = ("t0"."postId")
    WHERE
      (
        ("j0"."id") IN (
          SELECT
            "t1"."id"
          FROM
            "Post" AS "t1"
            INNER JOIN "User" AS "j1" ON ("j1"."id") = ("t1"."userId")
          WHERE
            (
              "j1"."name" = $ 1
              AND "t1"."id" IS NOT NULL
            )
        )
        AND "t0"."id" IS NOT NULL
      )
  );

After 5.4.0

SELECT
  "Comment"."id"
FROM
  "Comment"
  LEFT JOIN "Post" AS "j1" ON ("j1"."id") = ("Comment"."postId")
  LEFT JOIN "User" AS "j2" ON ("j2"."id") = ("j1"."userId")
WHERE
  (
    "j2"."name" = $ 1
    AND ("j2"."id" IS NOT NULL)
    AND ("j1"."id" IS NOT NULL)
  );

If you’re interested in more details on the relation query filter improvements, you can take a look at this pull request.

Enum improvements on PostgreSQL and CockroachDB

Previously, when an enum value was used in a query, our Postgres driver would make additional queries to resolve the enum types that were used.

In this release, we’re making improvements by casting enums to TEXT to avoid the additional roundtrips when resolving the types.

This change should have the most impact if you’re using pgBouncer or if you’re running Prisma in a serverless environment, where our Postgres driver can’t cache enum types information.

Prisma schema

model User {
  id   Int  @id @default(cuid())
  role Role
}

enum Role {
  User
  Admin
}

Prisma Client query

await prisma.user.findMany({ 
  where: {
    role: "Admin"
  }
})

Before 5.4.0

-- Internal driver query
SELECT t.typname, t.typtype, t.typelem, r.rngsubtype, t.typbasetype, n.nspname, t.typrelid FROM pg_catalog.pg_type t LEFT OUTER JOIN pg_catalog.pg_range r ON r.rngtypid = t.oid INNER JOIN pg_catalog.pg_namespace n ON t.typnamespace = n.oid WHERE t.oid = $1;

-- Internal driver query
SELECT enumlabel FROM pg_catalog.pg_enum WHERE enumtypid = $1 ORDER BY enumsortorder;

-- Prisma Client query
SELECT id, role FROM "User" WHERE role = $1;

After 5.4.0

-- Prisma Client query
SELECT id, role::text FROM "User" WHERE role = CAST($1::text AS "Role);

Bulk delete improvements

We optimized the deleteMany operation by:

Removing all SELECT queries used to fetch data that would be used as input for the DELETE operation. In some cases, this also improves index usage.
Removing the transaction previously used as it’s now a single atomic operation.

Prisma Client query


await prisma.post.deleteMany({
  where: {
    id: {
      gt: 1,
      lt: 10,
    }
  }
})

Before 5.4.0

BEGIN
SELECT id FROM "Post" WHERE id > 1 AND id < 10;
SELECT id FROM "Post" WHERE id > 1 AND id < 10 AND id IN (<...select ids>);
DELETE FROM "Post" WHERE id IN (<...select ids>) AND id > 1 AND id < 10;
COMMIT

After 5.4.0

DELETE FROM "Post" WHERE id > 1 AND id < 10;

Upsert improvements

We improved the upsert operation (non-native database upsert) by removing a redundant SELECT query:

Prisma Client query

await prisma.user.upsert({
  where: { email: "john@doe.com" },
  create: { email: "john@doe.com", firstName: "John" },
  update: { firstName: "Johnny" },
})

Before 5.4.0

SELECT `User`.`id` FROM `User` WHERE `User`.`email` = ?;
SELECT `User`.`id` FROM `User` WHERE `User`.`email` = ?;
UPDATE `prisma`.`User` SET `firstName` = ? WHERE `prisma`.`User`.`id` IN (?) AND `prisma`.`User`.`email` = ?;
SELECT `User`.`id` FROM `User` WHERE `User`.`id` = ?;

After 5.4.0

SELECT `User`.`id` FROM `User` WHERE `User`.`email` = ?;
UPDATE `prisma`.`User` SET `firstName` = ? WHERE `prisma`.`User`.`id` IN (?) AND `prisma`.`User`.`email` = ?;
SELECT `User`.`id` FROM `User` WHERE `User`.`id` = ?;

Fixes and improvements

Prisma Client

Language tools (e.g. VS Code)

Prisma Engines

CockroachDB: get_columns can hit inefficiency inside pg_class

We're hiring!

If you're interested in joining our growing team to help empower developers to build data-intensive applications, Prisma is the place for you.

We're currently hiring for the following roles:

Feel free to read the job descriptions and apply using the links provided.

0.5.0

3 Oct 2023

0.4.0

27 Sep 2023