Today, we are issuing the 5.8.1 patch release.

Fix in Prisma Client

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

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

Highlights

Happy New Year from your friends at Prisma! 🎊

In the last 4 weeks, we resolved some bugs on the ORM and made some progress on some exciting features that we’re not yet ready to announce. Stay tuned for the upcoming releases, in which we’ll be announcing new features. 😉

relationJoins improvements: Relation loading strategy per query (Preview)

In version 5.7.0, we released relationJoins into Preview. The relationJoins feature enables support for JOINs for relation queries.

This release adds support for the ability to specify the strategy used to fetch relational data per query when the Preview feature is enabled. This will enable you to choose the most efficient strategy for fetching relation data depending on your use case.

You can now load relation data using either of the following strategies:

• join — uses JOINs to fetch relation data
• query — uses sub-queries to fetch relation data

When the relationJoins Preview feature is enabled, by default, the relation fetching strategy used is join. You can override the default behavior by using the relationLoadStrategy query option.

To get started, enable the Preview feature:

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

… and specify the relation loading strategy for your query as follows:

await prisma.user.findMany({
  relationLoadStrategy: 'query',
  include: {
    posts: true,
  },
})

Try it out and share your feedback and create a bug report if you encounter any issues.

Survey: Edge functions support

We’re working on bringing Edge function support to Prisma ORM and we would appreciate your input by submitting a response to our survey. By filling out the survey, you will be considered for our Early Access cohort as soon as we have something for you to try out.

Fixes and improvements

Prisma Client

• Log output of Node-API library engine is different
• target and timestamp are undefined in info events in Data Proxy client
• Wrong types of timestamp and duration in query events with Data Proxy
• Using citext fields with neon database driver causes conversion error
• Add FreeBSD 14 as a new platform
• PostgresError { code: "54023", message: "cannot pass more than 100 arguments to a function", severity: "ERROR", detail: None, column: None, hint: None }
• Int[] return as null

Prisma Migrate

• Prisma Migrate errors with Environment is non-interactive when VERCEL env var is defined

Language tools (e.g. VS Code)

• Add quickfix for Error validating field 'id' in model 'Post': MongoDB '@default(auto())' fields must have 'ObjectId' native type.
• Append mention of update to "preview feature not known" error message

Credits

Huge thanks to @anuraaga, @onichandame, @LucianBuzzo, @RobertCraigie, @fqazi, @KhooHaoYit, @alencardc, @Oreilles, @tinola, @AikoRamalho, @luxaritas for helping!

Company news

🎉 A billion queries and counting: Prisma Accelerate

Prisma Accelerate, our global database cache has served over 1 billion queries since its General Availability launch.

We’d like to give a shoutout to our team and everyone who’s been with us on this journey. Stay tuned for some exciting products and features in the pipeline for 2024!

🔮 Prisma ORM Ecosystem

Are you building a cool tool, extension, generator, CLI tool or anything else, for Prisma ORM? Let us know.

We would like to learn about it and feature it on our Ecosystem page.

💼 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. Check out our Careers page for open positions.

Today, we are issuing the 5.7.1 patch release.

This patch fixes multiple small problems in our relationJoins preview feature. If you ran into problems when testing relationJoins before, please give it another go with 5.7.1 and share your feedback or create a bug report if you encounter any issues.

Fixes in Prisma Client

• relationJoins: Int[] return as null
• relationJoins: fails when filtering includes by isNot: null
• relationJoins: "The table (not available) does not exist in the current database."
• relationJoins: PostgresError { code: "54023", message: "cannot pass more than 100 arguments to a function", severity: "ERROR", detail: None, column: None, hint: None }
• relationJoins: Inconsistent column data: Unexpected conversion failure from String to datetime. Reason: $trailing input

🌟 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

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

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

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

• Update: InterpretationError("Unable to convert expression result into a set of selection results", None) (starting with 5.2.0)
• Error when inserting record with array enum column after TRUNCATEing the table on CockroachDB: placeholder $1 already has type string, cannot assign Color
• Netlify deployment with Node 20 break Prisma (Prisma Client could not locate the Query Engine for runtime "rhel-openssl-3.0.x")

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

Credits

Huge thanks to @anuraaga, @onichandame, @LucianBuzzo, @RobertCraigie, @fqazi, @KhooHaoYit, @alencardc, @Oreilles, @christianledgard, @skyzh, @alula, @AikoRamalho, @petradonka for helping!

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:

• Manager: Developer Advocacy
• Software Engineer

🌟 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:

• Neon
• PlanetScale
• Turso

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

• Weird error message on db push with invalid connection string: Connection string redacted, weird grammar
• Regression for MongoDB introspection in 5.4.0
• Inconsistent datetime column data importing to Turso
• db pull --url=... logs full connection string on P4001 The introspected database was empty

Prisma Client

• prisma_pool_connections_idle reports misleading number
• Update and read issues with @prisma/adapter-planetscale
• 5.5.0 regression: typescript error when trying to pass PrismaPlanetScale adapter to the constructor
• 5.5.0/1: 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

Prisma CLI

• prisma debug

Credits

Huge thanks to @onichandame, @LucianBuzzo, @RobertCraigie, @fqazi, @KhooHaoYit, @alencardc, @Oreilles, @christianledgard, @skyzh, @alula, @luxaritas, @Nasfame, @lukahartwig, @steebchen, @icanipa for helping!

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.

Today, we are issuing the 5.5.2 patch release.

Fix in Prisma CLI

• 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

Today, we are issuing the 5.5.1 patch release.

Fix in Prisma Client

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

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

Highlights

Serverless database drivers improvements and request for feedback (Preview)

In version 5.4.0, we released driverAdapters into Preview. The driverAdapter feature enables Prisma Client to access your database using other JavaScript or Serverless database drivers such as Neon, PlanetScale, and Turso.

The driver adapters allow Prisma Client to connect to your database using protocols besides TCP, such as HTTP (PlanetScale and Turso) and WebSockets (Neon). You can learn more about the Preview feature from the announcement blog post.

In this release, we focused our efforts on fixing bugs and improving the stability of the Preview feature.

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

• Neon
• PlanetScale
• Turso

New flags for the prisma init command

This release introduces 3 new flags you can provide when initializing Prisma in your project using the prisma init command:

• --generator-provider: Defines the default generator to use
• --preview-features: Specifies the default Preview features to use in your project
• --output: Specifies the default output location for the generated client

Fixes and improvements

Prisma CLI

• Prisma init: allow setting generator provider value

Prisma Client

• prisma.model.count does not type distinct correctly
• Generate fails on 5.2 with unsupported type
• Invalid ….findMany() invocation: The column j1.id does not exist in the current database.
• 5.4.0 subquery has too many columns
• One-to-Many relationship does not join on the specified field
• Planetscale driver: unsupported column type NULL

Credits

Huge thanks to @onichandame, @fqazi, @KhooHaoYit, @alencardc, @Oreilles, @christianledgard, @skyzh, @alula, @michaelpoellath, @lukahartwig, @steebchen, @icanipa, @jiashengguo, @stephenwade for helping!

💼 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:

• Software Engineer
• Senior Software Engineer (Rust)
• Engineering Manager: Prisma Data Platform

Today, we are issuing the 5.4.2 patch release.

Fix in Prisma Client

• 5.4.0 subquery has too many columns
• One-to-Many relationship does not join on the specified field

Today, we are issuing the 5.4.1 patch release.

Fix in Prisma Client

• Invalid ….findMany() invocation: The column j1.id does not exist in the current database.

Fix in @prisma/adapter-planetscale

• Planetscale driver: unsupported column type NULL

🌟 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:[email protected]/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 });

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: "[email protected]" },
  create: { email: "[email protected]", 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

• Unnecessary SELECT may be generated by upsert()
• Inefficient deleteMany query generation
• Prisma can generate an overly complex and inefficient query in some cases
• deleteMany optimisation
• CockroachDB: Highly Variable Query Response Times
• Extremely poor relation where clause query
• Enums loaded as part of transaction after UPDATE, slowing down transaction.
• MongoDB deleteMany seems to send 2 identical read queries first before triggering the actual delete
• Query validation messages reference color output even if colors are not enabled
• Prisma generates unnecessary subquery, which is inefficient
• Unnecessary INNER JOIN when doing nested queries
• Semver checks for yarn and typescript could potentially fail
• Prisma overrides type caching when in PGBouncer mode, causing 9,000 enum queries per second on a production system
• deleteMany generates double WHERE filter
• Prisma generate command crashes with RustPanic: RuntimeError: panicked at 'internal error: entered unreachable code', query-engine/prisma-models/src/field/scalar.rs:93:50
• Duplicated keys in metrics properties
• Prisma Client extension with method override and jest-mock-extended or vitest-mock-extended expects never input

Language tools (e.g. VS Code)

• Auto-completion suggests attributes already present
• Quick Fix: when @@schema is defined in a block without the schemas attribute

Prisma Engines

• CockroachDB: get_columns can hit inefficiency inside pg_class

Credits

Huge thanks to @onichandame, @fqazi, @KhooHaoYit, @alencardc, @Oreilles, @christianledgard, @skyzh, @alula, @michaelpoellath, @RobertCraigie, @icanipa, @jiashengguo, @stephenwade, @darthmaim, @ludralph, @Gerschtli, @andyjy for helping!

💼 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:

• Software Engineer
• Senior Software Engineer (Rust)
• Engineering Manager: Prisma Data Platform

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

Today, we are issuing the 5.3.1 patch release.

Fix in Prisma Client

• Duplicated keys in metrics properties

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

Highlights

In this sprint, we’ve made bug fixes and overall improvements to Prisma Client. We’ve been working on a few projects that will be announced soon. Stay tuned for the upcoming releases for updates!

Improvements and bug fixes

We made the following changes:

Prisma Client improvements

• Validation for undefined values in arrays in Json fields
  We added runtime validation for undefined values in arrays in Json fields. Prisma Client will now return an error when an array contains an undefined value. Therefore, we encourage you to add validation that either removes the value or transforms it to null if you stumble on the runtime validation:

// Query
await prisma.user.findMany({
 where: {
   // JSON field
   preferences: [undefined, '"theme": "dark"', null, ]
 }
})

// Example error message on running the query
Can not use `undefined` value within array. Use `null` or filter out `undefined` values

• Performance improvements for models with many unique fields

This release improves Prisma Client’s memory consumption for models with many @unique constraints. This was a regression from version 4.10.1, where in some cases, if a model had many unique constraints, Prisma Client would use up a lot of available memory.

• Fixed the segmentation fault error that used to occur on ARM64 Linux binary targets
• Metrics Preview feature improvements:
  • We updated the counters and gauge properties
  • We fixed the bug that caused the prisma_pool_connections_open metric to have a negative value in some cases.

Prisma Migrate improvements

• Fixed an introspection bug for MongoDB views. Previously, if a MongoDB database contained a view, prisma db pull would throw an error. We resolved this, and views are now ignored.
• Added the PRISMA_SCHEMA_DISABLE_ADVISORY_LOCK environment variable that enables you to disable advisory locking.

VS Code extension improvements

• Added support for rendering multi-line comments in tooltips when hovering on a block.
• Improved the auto-completion for composite types in other blocks.
• Added a Code Action that allows you to replace SetDefault with NoAction when using MySQL and the default/foreignKeys relation mode.

Fixes and improvements

Prisma Migrate

• Percona-XtraDB-Cluster prohibits use of GET_LOCK with pxc_strict_mode = ENFORCING
• MongoDB views should be ignored introspecting the database
• Error in Connector on MongoDB executing listIndex: "system.views"
• prisma migrate deploy: MariaDB doesn't yet support 'GET_LOCK in cluster (WSREP_ON=ON)'

Prisma Client

• Remove all special cases for Data Proxy in our tests
• Segmentation fault on ARM64 Linux
• In the metrics feature a gauge & counter are swapped
• The prisma metrics prisma_pool_connections_open has a bug where it goes negative
• Prisma crashes with GraphQL queries of nested one-to-many relationship
• P1017 Server has closed the connection on linux_arm64
• Error: socket hang up on Linux/arm64
• Panic in Query Engine with SIGABRT signal (Debian Bookworm, engineType = binary)
• Prisma 5 drops undefined from Arrays when using Json fields with Postgres
• Suspected memory leak in Lambda function after upgrading from 4.10.1
• Error when generating - No unsupported field should reach that path

Language tools (e.g. VS Code)

• Models with multi line comments only show last line in tooltip
• Add VS Code quick fix / code action to replace SetDefault with NoAction when provider = "mysql" and relationMode = "foreignKeys" | default
• Composite Types aren't offered as being auto-completable in other blocks

Credits

Huge thanks to @alencardc, @Oreilles, @christianledgard, @skyzh, @alula, @michaelpoellath, @RobertCraigie, @stephenwade for helping!

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

Highlights

Improved Prisma Client experience for Prisma Accelerate and Data Proxy

In this release, we’ve made the following improvements to Prisma Client when using Prisma Accelerate or Prisma Data Proxy:

• Prisma Client will now automatically determine how it should connect to the database depending on the protocol in the connection string. If the connection string starts with prisma://, Prisma Client will try to connect to your database using Prisma Accelerate or Prisma Data Proxy.

• Prisma Studio now works with Prisma Data Proxy and Prisma Accelerate.

• We’ve introduced a new --no-engine flag which will prevent a Query Engine file from being included in the generated Prisma Client. This flag will also help ensure the bundle size of your application remains small by excluding the Query Engine files from the generated Prisma Client.

  prisma generate --no-engine
  

  The --data-proxy and --accelerate flags have not been removed but are now aliases for the new --no-engine flag.

  We recommend using the --no-engine flag when generating Prisma Client that uses either Accelerate or Data Proxy.

Simplified connection string override in Prisma Client

This release simplifies the API used when programmatically overriding the connection string by introducing the datasourceUrl property in Prisma Client’s constructor. This means you do not have to use the datasource name defined in your Prisma schema.

const prisma = new PrismaClient({
  datasourceUrl: "postgresql://johndoe:randompassword@localhost:5432/mydb",
})

Query performance improvements

Continuing our work from 5.1.0 we made further performance improvements around the queries Prisma executes, targeting one-to-many relation fields and nested updates.

Use LIMIT in one-to-many relations on a single parent

In cases where there is a single parent with a one-to-many relation included (findFirst, findUnique, findMany({ take: 1 })), we now utilize LIMIT at the database level to restrict the number of related items returned instead of retrieving all related items into memory and performing a take in memory.

For situations where you have many related objects but only need a few, you should see a dramatic improvement in speed and memory usage.

Note: we are still working on bringing this improvement to other parts of Prisma Client in upcoming releases. If multiple parent records are returned, the previous behavior is used.

Further improvements for nested writes

Thanks to our introduction of using RETURNING in some cases in 5.1.0, we could now improve performance in nested writes by removing reload nodes. This will now result in one less query per relation traversed in a nested write. For more info, check out the pull request.

Prisma Client query

await prisma.post.update({
  where: { id: 1 },
  data: {
    comment: {
      update: { 
        data: {
          body: "Updated comment body"
        }
      }
    }
  },
  select: {
    id: true,
    title: true,
  }
})

Before v5.2.0

SELECT "Post"."id", "Post"."title" FROM "Post" WHERE ("Post"."id" = $1 AND 1=1) LIMIT $2 OFFSET $3
SELECT "Post"."id", "Post"."userId" FROM "Post" WHERE "Post"."id" = $1 OFFSET $2
SELECT "User"."id" FROM "User" WHERE (1=1 AND "User"."id" IN ($1)) OFFSET $2
SELECT "User"."id" FROM "User" WHERE ("User"."id" = $1 AND 1=1) LIMIT $2 OFFSET $3
SELECT "User"."id", "User"."commentId" FROM "User" WHERE "User"."id" = $1 OFFSET $2
SELECT "Comment"."id" FROM "Comment" WHERE (1=1 AND "Comment"."id" IN ($1)) OFFSET $2
UPDATE "Comment" SET "body" = $1 WHERE ("Comment"."id" = $2 AND 1=1) RETURNING "Comment"."id"
SELECT "Post"."id", "Post"."title" FROM "Post" WHERE "Post"."id" = $1 LIMIT $2 OFFSET $3

5.2.0 and later

SELECT "Post"."id", "Post"."title", "Post"."userId" FROM "Post" WHERE ("Post"."id" = $1 AND 1=1) LIMIT $2 OFFSET $3
SELECT "User"."id" FROM "User" WHERE (1=1 AND "User"."id" IN ($1)) OFFSET $2
SELECT "User"."id", "User"."commentId" FROM "User" WHERE ("User"."id" = $1 AND 1=1) LIMIT $2 OFFSET $3
SELECT "Comment"."id" FROM "Comment" WHERE (1=1 AND "Comment"."id" IN ($1)) OFFSET $2
UPDATE "Comment" SET "body" = $1 WHERE ("Comment"."id" = $2 AND 1=1) RETURNING "Comment"."id"
SELECT "Post"."id", "Post"."title" FROM "Post" WHERE "Post"."id" = $1 LIMIT $2 OFFSET $3

Fixes and improvements

Prisma Client

• CFW: Avoid including Query Engine when data proxy is enabled
• Local Prisma Studio does not work with Data Proxy
• Postinstall hook always generates non Data Proxy Prisma Client
• limit is gone when findUnique with include relation
• Cannot fetch data from service: include is not a function Error while using Next.js with Data Proxy
• take key doesn't work correctly for nested query that returns one item with its nested children
• Prisma Client Edge: environment variables are not working with the "new" Module Worker syntax for Cloudflare Workers
• Add documentation to "PrismaClient is unable to be run in the browser"
• Change how Data Proxy Client deals with unsupported preview features
• Custom Prisma Client output location breaks Prisma Data Proxy in NextJS
• GetPayload type error since 4.16.1 "Two different types with this name exist, but they are unrelated."
• Browser bundle: Unhandled Runtime Error when upgrading to 5.1.0 from 5.0.0
• Prisma Client: disconnect: true does not appear to delete the foreign key in the returned data
• Prisma Client errors with "TypeError: Cannot create proxy with a non-object as target or handler" when using result client extension with no needs and count method
• Upgrading from Prisma 5.0.0 -> 5.1.0 results in "TS2321: Excessive stack depth comparing types" error using mockDeep<PrismaClient>()
• Unnecessary reads for to-one nested updates
• Better error message if @prisma/client/edge can not find environment variable
• 5.1: Alias for old name for <Model>CountOutputTypeDefaultArgs does not exist
• Incorrect pagination for nested m2m chunked reads

Prisma Migrate

• RustPanic on prisma generate when Unsupported field defined in a Composite type
• Use PostgreSQL System Information Functions instead of manually joining fields
• Duplicate expression index comment whenever db pull is run

Credits

Huge thanks to @skyzh, @alula, @michaelpoellath, @RobertCraigie, @darthmaim, @Gerschtli, @andyjy, @mejiaej, @iurylippo, @mrazauskas, @coder246, @RDIL for helping!

Today, we are issuing the 5.1.1 patch release.

Fixes in Prisma Client

• Browser bundle: Unhandled Runtime Error when upgrading to 5.1.0 from 5.0.0
• Prisma Client: disconnect: true does not appear to delete the foreign key in the returned data
• Prisma Client errors with "TypeError: Cannot create proxy with a non-object as target or handler" when using result client extension with no needs and count method

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

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

Highlights

After two big releases where we released Client extensions for production usage (4.16.0) and made Prisma faster by default (5.0.0), we have focused on some smaller issues to make the experience with these new features even better.

Community contributions

Our community has been on the roll! We appreciate everyone who helps us by opening a GitHub issue or proposing a fix via Pull Requests. In this release, we're excited to highlight multiple community contributions:

• Fix IPv6 not working for relational databases: https://github.com/prisma/prisma-engines/pull/4051 by @alula
• Middlewares: Add to PrismaAction type, missing findUniqueOrThrow and findFirstOrThrow https://github.com/prisma/prisma/pull/17471 by @mejiaej and missing groupBy https://github.com/prisma/prisma/pull/19985 by @iurylippo
• Better error message in currently non-supported runtimes like Browser or Vercel Edge Runtime https://github.com/prisma/prisma/pull/20163 by @andyjy
• Remove error messages for valid NixOS setups https://github.com/prisma/prisma/pull/20138 by @Gerschtli

Better performance: Fewer SQL queries on PostgreSQL & CockroachDB

In our continued and ongoing work to make Prisma faster, we identified some Prisma Client queries that led to multiple SQL statements being executed — although in specific databases, that was not necessary.

Hence we optimized our internal SQL generation for PostgreSQL and CockroachDB to generate more efficient SQL queries:

Simple create query

In a simple create query, RETURNING makes the second query and the transaction statements obsolete:

Prisma Client query

prisma.user.create({ 
  data: { name: "Original name" } 
})

Before v5.1.0

BEGIN
INSERT INTO "User" ("name") VALUES ($1) RETURNING "User"."id"
SELECT "User"."id", "User"."name" FROM "User" WHERE "User"."id" = $1;
COMMIT

5.1.0 and later

-- Sends 1 statement (instead of 2) and omits the transaction
INSERT INTO "User" ("name") VALUES ($1) RETURNING "User"."id", "User"."name"

Simple update query

For a simple update query, RETURNING makes both additional queries and the transaction statements obsolete:

Prisma Client query

prisma.user.update({ 
  where: { id: 1 }, 
  data: { name: "updated" } 
})

Before v5.1.0

BEGIN
SELECT id FROM "User" WHERE "User".id = 1;
UPDATE "User" SET name = 'updated' WHERE "User".id = 1;
SELECT id, name FROM "User" WHERE "User".id = 1;
COMMIT

5.1.0 and later

-- Sends 1 statement (instead of 3) and omits the transaction
UPDATE "User" SET name = 'updated' WHERE "User".id = 1 RETURNING "User".id, "User".name;

Simple update query, return with relation value

One SELECT query could easily be dropped in a simple update query that should return a relation value as well:

Prisma Client query

prisma.user.update({ 
  where: { id: 1 }, 
  data: { name: "updated" }, 
  includes: { posts: true }  
})

Before v5.1.0

BEGIN
SELECT id FROM "User" WHERE "User".id = 1;
UPDATE "User" SET name = 'updated' WHERE "User".id = 1;
SELECT id, name FROM "User" WHERE "User".id = 1;
SELECT id, title FROM "Post" WHERE "Post"."userId" = 1;
COMMIT

5.1.0 and later

-- Sends 3 statements (instead of 4)
BEGIN
UPDATE "User" SET name = 'updated' WHERE "User".id = 1 RETURNING "User".id;
SELECT id, name FROM "User" WHERE "User".id = 1;
SELECT id, title FROM "Post" WHERE "Post"."userId" = 1;
COMMIT

Empty update query

An empty update query can be optimized to skip the transaction and the second identical query by creating specific handling for this edge case in our code:

Prisma Client query

prisma.user.update({ 
  where: { id: 1 }, 
  data: {}, 
})

Before v5.1.0

BEGIN
SELECT id, name FROM "User" WHERE "User".id = 1;
SELECT id, name FROM "User" WHERE "User".id = 1;
COMMIT

5.1.0 and later

-- Sends 1 statement (instead of 2) and omits the transaction
SELECT id, name FROM "User" WHERE "User".id = 1;

Simple + relation update query (but do not return relation value)

An update of both the model and its relation, we could drop 2 SELECT queries that we did before without ever using their return values:

Prisma Client query

prisma.user.update({ 
  where: { id: 1 }, 
  data: {
    name: "updated",
    posts: {
      update: {
        where: { id: 1 },
        data: {
          title: "updated"
        }
      }
    }
  }
})

Before v5.1.0

BEGIN
SELECT id, name FROM "User" WHERE "User".id = 1;
UPDATE "User" SET name = 'updated' WHERE "User".id = 1 RETURNING "User".id;
SELECT "id", "postId" FROM "Post" WHERE "Post".id = 1;
UPDATE "Post" SET title = 'updated' WHERE "Post"."userId" = 1 AND "Post".id = 1;
SELECT id, name FROM "User" WHERE "User".id = 1;
COMMIT

5.1.0 and later

-- Sends 3 statements (instead of 5) 
BEGIN
UPDATE "User" SET name = 'updated' WHERE "User".id = 1 RETURNING "User".id, "User".name;
SELECT "id", "postId" FROM "Post" WHERE "Post".id = 1;
UPDATE "Post" SET title = 'updated' WHERE "Post"."userId" = 1 AND "Post".id = 1;
COMMIT

In the next releases, we will continue optimizing Prisma Client queries to only run the minimal amount of SQL queries necessary.

If you notice any Prisma Client queries that are affected right now, please check the issues under our performance/queries label. If you didn’t find one for what you’re seeing, please create a new issue. This will be super useful for us to understand all (edge) cases. Thank you!

Prisma Studio now supports directUrl

Our CLI command prisma studio that opens Prisma Studio now also can use the directUrl property of the datasource block so you can make it talk to a different database than defined in url. This makes it easier to use Studio alongside the Prisma Data Proxy and Accelerate.

Prisma Client: No more type clashes

We fixed (almost) all cases where using a specific term as a model name in your Prisma Schema would lead to a type clash due to Prisma’s generated typings. As a result of a type clash, it was not possible to use that model in your code (this was e.g. the case if you named a model Model or ModelUpdate).

We also deprecated the <ModelName>Args type as part of that fix. Going forward, <ModelName>DefaultArgs should be used instead.

Fixes and improvements

Prisma Client

• Reduce the number of generated SQL statements for Updates/Inserts
• [v2.17.0] Missing client TS types Aggregate*Args
• Reduce transactions for writes
• Incorrect Include typings when having models called X and XUpdate
• Model named "Check" is incorrectly typed
• Models named Query cause an internal GraphQL Parse Error
• Naming an entity "Query" leads to an error
• Type name clash when Model and ModelUpdate is defined in the schema
• Duplicate identifier 'CheckSelect'
• @prisma/internals (previously @prisma/sdk) uses deprecated dependencies [email protected] via temp-write 4.0.0
• naming a model Datasource breaks generated return types
• Certain model names cause clashes in generated types
• Type error on query with select field (although query runs successfully)
• $extends TS error: "Inferred type of this node exceeds the maximum length the compiler will serialize" with "declaration": true in tsconfig
• Update operation includes multiple where statements for the same fields
• Type conflict when naming a table {something} and a second table {something}Result
• Type '"findUniqueOrThrow"' is not assignable to type 'PrismaAction'
• Naming a model Promise breaks types for PrismaPromise
• Prisma can't connect with an IPv6 host (on e.g. Fly.io)
• include not working on models ending with ...Update with unique compound index
• Prisma Client: fixing type name clashes from generated client
• Prisma Client: wrong type when using spread operator to set default values on query args
• The generated updateArgs have no update attribute
• 4.16.1 breaks type check
• LogLevel enum conflicts with built-in Prisma type
• Using Prisma.XyzFindManyArgs breaks findMany typing in v4.16.0+
• this.$on("beforeExit") doesn't work anymore on 5.0.0
• Wrong nullable types with fluent API in Prisma 5.0
• Error: Unknown value type on nested create
• Prisma 5.0 Migration findUnique on @unique columns that are enums
• <Tablename>UpsertArgs select field does not match type for db.<tablename>.upsert(item)
• TypeScript Error TS2322 when assigning JavaScript Date object to Prisma DateTime field
• npm install of Prisma CLI fails on preinstall with no logs when Node.js version is lower than minimum
• Types wrongly accept non-array parameter by in groupBy in 5.0.0
• CLI errors with TypeError [ERR_INVALID_URL]: Invalid URL when HTTP(S)_PROXY en var has is set to a URL without a protocol
• tsc --watch fails with JavaScript heap out of memory error
• Hovering over types (intellisense) shows confusing GetResult
• Internal query batching fails when the table name is 'stores'
• Client extensions result extensions should be applied after query extensions

Prisma Studio

• Use directUrl in prisma studio

Language tools (e.g. VS Code)

• The extension for VS Code ignores the modern telemetry flag
• Prisma VS Code extension with mongodb provider crashes when a relation field/type is not defined
• Editing schema.prisma results in wasm panics

Credits

Huge thanks to @skyzh, @alula, @michaelpoellath, @RobertCraigie, @Gerschtli, @andyjy, @mejiaej, @iurylippo, @mrazauskas for helping!

We’re excited to share the 5.0.0 release today 🎉

Prisma 5.0.0 contains a lot of changes that improve Prisma’s performance, especially in serverless environments. If you want to learn more about the performance improvements, we wrote a blog post that sums up all the changes we made: Prisma 5: Faster by Default.

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

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

Highlights

Here’s a summary of the changes:

• Preview features moved to General Availability
  • jsonProtocol: improves communication between Prisma Client and the query engine, makes Prisma faster by default.
  • fieldReference: adds support for comparing columns of the same table.
  • extendedWhereUnique: adds support for non-unique columns inside where clauses for queries that operate on unique records.
• General improvements and breaking changes
  • Dependency version changes
    • Minimum Node.js version change to 16.13.0
    • Minimum TypeScript version change to 4.7
    • Minimum PostgreSQL version change to 9.6
    • Prisma Client embedded SQLite version upgrade to 3.41.2
  • Main Changes
    • Removal of rejectOnNotFound property
    • Removal of some array shortcuts
    • cockroachdb provider is now required when connecting to a CockroachDB database
    • Removed runtime/index.js from the generated Prisma Client
  • Other Changes
    • Removal of deprecated flags in the Prisma CLI
    • Removal of the beforeExit hook from the library engine
    • Removal of deprecated prisma2 executable
    • Removal of deprecated experimentalFeatures generator property in the Prisma schema
    • Renamed migration-engine to schema-engine

A JSON-based protocol that improves Prisma’s performance

We’re thrilled to announce that the jsonProtocol Preview feature is now Generally Available. You can now remove the Preview feature flag from your schema after upgrading. We made the JSON-based wire protocol the default protocol used for communication between Prisma Client and the query engine.

We introduced this feature in version 4.11.0 to improve Prisma’s performance. Previously, Prisma used a GraphQL-like protocol to communicate between Prisma Client and the query engine. Applications with larger schemas had higher CPU and memory consumption compared to smaller schemas which created a performance bottleneck.

The JSON-based wire protocol improves efficiency when Prisma Client is communicating with the query engine.

Removal of array shortcuts

We took the opportunity to remove some array shortcuts to make our typings more consistent and logical. These shortcuts were a way to add a single element as a value to an array-based operator instead of wrapping a single element in an array. We will now require array values for the following:

• OR operator shortcuts
• in and notIn operator shortcuts
• PostgreSQL JSON path field shortcut
• Scalar list shortcuts
• MongoDB Composite types list shortcuts

Here’s an example query using the OR operator shortcut for a single element;

await prisma.user.findMany({
  where: {
-    OR: { email: '[email protected]' }
+    OR: [{ email: '[email protected]' }]
  }
})

We recommend taking a look at the upgrade guide to learn how you can update your queries to work in Prisma 5.

Support for comparing multiple columns

We’re excited to announce that the fieldReference Preview feature is now stable and Generally Available. This means you can use this feature without the Preview feature flag in your Prisma schema.

We first introduced this feature in 4.5.0 to add the ability to compare columns on the same table. For example, the following query returns records where the quantity value is less than the warnQuantity of a product:

await prisma.product.findMany({
  where: { 
		quantity: { lte: prisma.product.fields.warnQuantity } 
	},
})

To learn more about this feature, refer to our documentation.

Support for filtering non-unique columns in queries for a unique record

We’re excited to announce the extendedWhereUnique Preview feature is now Generally Available. This means you can use the feature without the Preview feature flag in the Prisma schema.

We first introduced this feature in version 4.5.0 to add support for non-unique columns inside where clauses for queries that operate on unique records, such as findUnique, update, and delete, which was previously not possible.

For example, consider the following model:

model Article {
  id      Int    @id @default(autoincrement())
  content String
  version Int
}

You can filter on non-unique columns such as the version field as follows:

await prisma.article.findUnique({
  where: { 
    id: 5, 
    version: 1 // filter on the `version` field was not available before Prisma 4.5.0
  },
});

To learn more about this feature, refer to our documentation.

Minimum Node.js version change to 16.13.0

The minimum version of Node.js Prisma supports is 16.13.0. If you're using an earlier version of Node.js, you will need to upgrade your Node.js version.

Refer to our system requirements for the minimum versions Prisma requires.

Minimum TypeScript version change to 4.7

The minimum version of TypeScript Prisma supports is 4.7. If your project is using an earlier version of TypeScript, you will need to upgrade your TypeScript version.

Refer to our system requirements for the minimum versions Prisma requires.

Minimum PostgreSQL version change to 9.6

The minimum version of PostgreSQL Prisma supports is version 9.6. If you’re either using 9.4 or 9.5, you will need to update your PostgreSQL version to at least 9.6.

Refer to our system requirements for the minimum database versions Prisma requires.

Prisma Client embedded SQLite version upgrade

We upgraded the embedded version of SQLite from 3.35.4 to 3.41.2. We do not anticipate any breaking changes or changes needed in projects using SQLite. However, if you’re using SQLite, especially with raw queries that might go beyond Prisma's functionality, make sure to check the SQLite changelog.

Removal of rejectOnNotFound property

In version 5.0.0, we removed the rejectOnNotFound parameter from Prisma Client that was deprecated in version 4.0.0. We removed this feature to provide better type-safety using the findUniqueOrThrow and findFirstOrThrow methods as well have a consistent API.

If you are using the rejectOnNotFound parameter we recommend either:

• Replacing your queries with the findFirstOrThrow or findUniqueOrThrow methods if enabled at a query-level
• Using a Prisma Client extension to overload the findFirstOrThrow and findUniqueOrThrow model methods with your custom error handling if enabled at the client-level

We recommend taking a look at the upgrade guide for more information on how to adapt your application if you’re using rejectOnNotFound.

cockroachdb provider is now required when connecting to a CockroachDB database

Prior to adding explicit support for CockroachDB with the cockroachdb provider in 3.9.0, it was possible to use the PostgreSQL provider when working with CockroachDB databases.

We’re now making it mandatory to use the CockroachDB connector when working with CockroachDB databases. CockroachDB and PostgreSQL have a few differences such as the available native types which impact the generated migrations.

If you were using the PostgreSQL connector to work with CockroachDB, take a look at the upgrade guide to learn how you can update your connector.

Removal of the generated runtime/index.js file from Prisma Client

With Prisma 5, we removed the runtime/index.js file from Prisma Client. If you were using APIs from runtime/index.js, such as Decimal , PrismaClientKnownRequestError,  NotFoundError,  PrismaClientUnknownRequestError, we recommend updating your imports:

- import { Decimal } from '@prisma/client/runtime'
+ import { Prisma } from '@prisma/client'

// Usage update of Prisma Client's utilities
- Decimal
+ Prisma.Decimal

We recommend taking a look at the upgrade guide to learn how you can migrate to Prisma 5

Removal of the beforeExit hook from the library query engine

We removed the beforeExit hook from the default library Query Engine. We recommend using the built-in Node.js exit events.

-prisma.$on('beforeExit', () => { /* your code */ })

// Replacements
process.on('beforeExit', () => { /* your code */ })
process.on('exit', exitHandler)
process.on('SIGINT', exitHandler)
process.on('SIGTERM', exitHandler)
process.on('SIGUSR2', exitHandler)

We recommend taking a look at the upgrade guide to learn how you can migrate to Prisma 5.

Removal of deprecated prisma2 executable

When we released Prisma 2, the prisma2 executable was used to differentiate it from Prisma 1. In a later release, the prisma2 CLI took over the prisma executable name.

The prisma2 executable has been deprecated for a while and will now be removed. If you’re using prisma2 in your scripts, replace it with prisma.

Removal of deprecated flags in the Prisma CLI

We removed the following deprecated flags in the Prisma CLI:

• --preview-feature: used in the prisma db execute, prisma db seed, and prisma migrate diff commands
• --experimental and --early-access-feature: used in the prisma migrate commands such as prisma migrate dev
• --force: for prisma db push. The --force flag was replaced by --accept-data-loss in version 2.17.0
• --experimental-reintrospection and --clean: for prisma db pull

In the event you’re using one of these flags, we recommend removing the flags.

Removal of deprecated experimentalFeatures generator property

In this release, we removed the experimentalFeatures property that used to be in the generator property in the Prisma schema but has been renamed to previewFeatures for a long time now. If you’re still using this property, you can either manually rename it to previewFeatures or use the VS Code action to rename it if you’re using the latest version of the Prisma VS Code extension.

Renamed migration-engine to schema-engine

In this release, we renamed the migration-engine, responsible for running introspection and migration commands, to schema-engine . For the majority of our users, no changes will be required. However, if you explicitly include or exclude the engine files you will need to update your code references. Refer to the upgrade guide for more information.

Fixes and improvements

Prisma Client

• Getting a string '(array)' in the generator config instead of the expected value when array is used
• Misleading error message from create call
• Client extensions incorrect typings when defined both specific model and all models methods
• UncheckedUpdateManyInput types lead to conflicting names
• <Model>RelationFilterInput does not take nullability into account
• Full text search query with OR broke after opting in to jsonProtocol feature.
• Prisma Client: remove list shorthands (for jsonProtocol)
• Remove outdated preview feature aliases (transactionApi, aggregateApi)
• Prisma Client generator: remove creation of a package.json
• Prisma Client: make jsonProtocol GA
• Only upload engines files to binaries.prisma.sh/all_commits/
• Prisma Client: remove "beforeExit" hook from LibraryEngine/DataProxyEngine
• Prisma Client: remove rejectOnNotFound
• Prisma Client: remove runtime/index.js bundle from client
• Prisma CLI: remove non-existing prisma dev command
• Prisma Client: remove legacy photonResolver and provider=photonjs handling
• Prisma Client: make fieldReference GA
• Prisma Client: make extendedWhereUnique GA
• Remove backward compatibility for Prisma Client < 2.20 and Prisma CLI >= 2.20
• Prisma CLI: remove prisma2 "executable"
• Query in findMany in prisma extends returns a wrong type
• Can't specify $queryRawUnsafe return type after extending prisma client
• FindMany returns wrong type after extending prisma client
• 4.16.x cannot wrap $extend in factory function when compilerOptions.composite is true
• 4.16: (MongoDB) Generated types for list composites are incorrect
• Prisma Client Extensions: $allModels: { $allOperations } sets query type to never
• Prisma Schema Type inside a Type not generating a right Payload
• Field references are not available on extended clients
• Prisma Client fluent API does not work with extends anymore on 4.16.1
• Prisma not generating correct payload for types in models for MongoDB for 4.16.1
• Prisma requires to install bun when generating client library
• Getting wrong types with prisma client extensions
• Prisma Client: updating to 4.16.0 or 4.16.1 breaks Cloudflare worker, it errors with The package "path" wasn't found on the file system but is built into node
• Result types are incorrectly inferred when undefined explicitly passed to select/include
• Migrating to release: 4.16.2 throws typescript error: "TS1005: '?' expected".

Prisma Migrate

• Make connecting to a cockroachdb database with provider = "postgresql" an error
• Remove the deprecated experimentalFeatures generator property
• Remove support for PostgreSQL 9.4 and 9.5
• Upgrade embedded SQLite version
• Drop support for Node.js v14
• db pull: Remove the version checker from introspection
• Prisma CLI: remove undocumented doctor command
• Rename migration-engine to schema-engine
• Prisma CLI: remove deprecated flags, arguments and "old migrate" logic
• Remove obsolete experimentalFeatures generator property
• Remove usage / mention of experimentalFeatures

Language tools (e.g. VS Code)

• Mark experimentalFeatures as obsolete

Credits

Huge thanks to @michaelpoellath, @RobertCraigie, @Coder246, @RDIL, @oohwooh, @rqres, @zhiyan114, @spudly, @hayes, @boennemann, @DongGunYoon for helping!

📺 Join us for another "What's new in Prisma" live stream

Learn about the latest release and other news from the Prisma community by joining us for another "What's new in Prisma" live stream.

The stream takes place on YouTube on Thursday, July 13 at 5 pm Berlin | 8 am San Francisco.

Today, we are issuing the 4.16.2 patch release.

Fixes in Prisma Client

• 4.16: (MongoDB) Generated types for list composites are incorrect
• Getting wrong types with prisma client extensions
• Prisma Client fluent API does not work with extends anymore on 4.16.1
• Prisma Client Extensions: $allModels: { $allOperations } sets query type to never
• Result types are incorrectly inferred when undefined explicitly passed to select/include

Today, we are issuing the 4.16.1 patch release.

Fixes in Prisma Client

• Field references are not available on extended clients
• 4.16.x cannot wrap $extend in factory function when compilerOptions.composite is true
• Prisma Schema Type inside a Type not generating a right Payload
• Query in findMany in prisma extends returns a wrong type
• 4.16.0 Count query is not returning the right type when in a transaction
• FindMany returns wrong type after extending prisma client
• Can't specify $queryRawUnsafe return type after extending prisma client

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

Highlights

This release promotes the following Preview features to General Availability:

• Prisma Client extensions
• Ordering by nulls first and last
• Count by filtered relation

Prisma Client extensions are Generally Available

Today, we’re very excited to announce that Prisma Client extensions are Generally Available and production-ready! This means you can use the feature without the clientExtensions Preview feature flag.🚀

Prisma Client extensions are a powerful new feature for adding functionality on top of your Prisma Client in a type-safe manner. With this feature, you can create simple, but flexible solutions.

Prisma Client extensions have 4 different types of components that can be included in an extension:

• Result extensions components: add custom fields and methods to query result objects, for example, virtual/computed fields.
• Model extensions components: enable you to add new methods to your models alongside existing model methods such as findMany.
• Query extensions components: let you hook into the lifecycle of a query and perform side effects, modify query arguments, or modify the results in a type-safe way. These are an alternative to middleware that provide complete type safety and can be applied in an ad-hoc manner to different extensions.
• Client extensions components: allow you to add new top-level methods to Prisma Client. You can use this to extend Prisma Client with functionality that isn’t tied to specific models.

const prisma = new PrismaClient().$extends({
  name: "extension-name",
  result: { /* ... */ },
  model: { /* ... */ },
  query: { /* ... */ },
  client: { /* ... */ },
});

You can also create and publish extensions for others to use. Learn more about how to share extensions in our documentation.

More features and changes made to Client Extensions

We also made the following improvements to Prisma Client extensions in preparation for General Availability:

• Added a top-level $allOperations method for query component that captures all model operations as well as top-level raw queries. Refer to our documentation for more information.

  const prisma = new PrismaClient().$extends({
    query: {
      $allOperations({ args, query, operation, model }) {
        /* your extension's logic here */
      }
    }
  })
  

• Prisma.validator can now also be used for extended types:

  const prisma = new PrismaClient().$extends({/* ... */})
  const data = Prisma.validator(prisma, 'user', 'findFirst', 'select')({
    id: true,
  })
  

• query callbacks for $queryRaw and $executeRaw will always receive Sql instance as args. This instance can be used to compose a new query using Prisma.sql:

  const prisma = new PrismaClient().$extends({
    query: {
      $queryRaw({ args, query }) {
        return query(Prisma.sql`START TRANSACTION; ${args}; COMMIT;`)
      }
    }
  })
  

• $on cannot be called after extending Prisma Client. Therefore, if you want to use event handlers together with extensions, we recommend using the $on method before $extends.

  const prisma = new PrismaClient()
    .$on(/* ... */)
    .$extends({/* ... */})
  

• We updated the import path for utilities used for authoring extension to @prisma/client/extension rather than @prisma/client

  + import { Prisma } from "@prisma/client/extension"
  - import { Prisma } from "@prisma/client"
  

Deprecating Middleware

We also took this opportunity to deprecate Prisma Client’s middleware. We recommend using to using Prisma Client query extension components which can be used to achieve the same functionality and with better type safety.

🚧 Middleware will still be available in Prisma Client’s API. However, we recommend using Prisma Client extensions over middleware.

Ordering by nulls first and last is now Generally Available

Starting with this release, we’re excited to announce that orderByNulls is now Generally Available! This means you can use the feature without the orderByNulls Preview feature flag.🌟

We introduced this feature in 4.1.0 to enable you to sort records with null fields to either appear at the beginning or end of the result.

The following example query sorts posts by updatedAt, with records having a null value at the end of the list:

await prisma.post.findMany({
  orderBy: {
    updatedAt: { sort: 'asc', nulls: 'last' },
  },
})

To learn more about this feature, refer to our documentation.

We’re excited to see what you will build! Feel free to share with us what you build on Twitter, Slack, or Discord.

Count by filtered relation is now Generally Available

This release moves the filteredRelationCount Preview feature to General Availability! This means you can use the feature without the filteredRelationCount Preview feature flag.

We first introduced this feature in 4.3.0 to add the ability to count by filtered relations.

The following query, for example, counts all posts with the title “Hello!”:

await prisma.user.findMany({
  select: {
    _count: {
      select: {
        posts: { where: { title: 'Hello!' } },
      },
    },
  },
})

To learn more about this feature, refer to our documentation.

Introspection warnings for expression indexes

In the last two releases, 4.13.0 and 4.14.0, we added 9 introspection warnings. These warnings surface features in use in your database that cannot currently be represented in the Prisma schema.

In this release, we’re adding one more introspection warning to the list: expression indexes.

On database introspection, the Prisma CLI will surface the feature with a warning, and a comment in your Prisma schema for sections for each feature in use. The warnings will also contain instructions for workarounds on how to use the feature.

Fixes and improvements

Prisma Client

• Attach comments to enum values
• Extend Prisma Client
• Triple-slash Comments should attach to Composite Types
• Nested disconnect fails on MongoDB with extendedWhereUnique
• [ClientExtensions, TypeScript] Fields of custom type aren't available when using the ClientExtensions preview-feature, unless select'd explicitly.
• Extensions incorrect typings generated (casing)
• Misleading error message of prisma generate when running it directly after installing prisma
• Prisma.validator: with clientExtensions enabled, Typescript can no longer compute types
• enum docstrings do not make it to the prisma client
• VScode behavior is very slow while using clientExtensions
• Client extensions in interactive transactions are bound to the base client
• $runCommandRaw is not passing the expected data to middleware or client extension
• PCE: Improve runtime types in raw query extensions
• Sequential transactions run out of order when using client extensions and middleware
• Client Extension: Make .prismaVersion.client available on "@prisma/client/scripts/default-index"
• Cannot create record with Prisma.DbNull when clientExtensions enabled
• Extended client raw queries fail when using the Prisma.sql helper
• jsonProtocol: array shortcut is missing for distinct field
• Prisma Client Extension: support Prisma.validator
• Prisma Client: make clientExtensions GA
• PCE: Query extensions of $queryRawUnsafe also triggers $allModels.$allOperations
• PCE: $on applied to an extended client is also bound to the parent client
• Type "never" returned from nested properties when using "select" after enabling data proxy + accelerate
• $queryRaw* is broken in interactive transactions together with clientExtensions in 4.16.0-dev.17
• Deploying to an offline environment fails because it tries to download a Prisma engine checksum file
• jsonProtocol: Wrong error message shown for validation error for checked/unchecked types
• Bug: FindXOrThrow don't get batched on the engine

Prisma Migrate

• Allow skipping sha checksum
• Documentation not available in DMMF for MongoDB types
• prisma db pull gets rid of @default(uuid()) on re-introspection

Language tools (e.g. VS Code)

• Go to Definition does not work when target model contains a field with a type name that starts with the same name

Prisma Studio

• Error: spawn xdg-open ENOENT on prisma studio

📺 Join us for another "What's new in Prisma" live stream

Learn about the latest release and other news from the Prisma community by joining us for another "What's new in Prisma" live stream.

The stream takes place on YouTube on Thursday, June 22 at 5 pm Berlin | 8 am San Francisco.