PrismaClient connects and disconnects from your data source using the following two methods:

In most cases, you do not need to explicitly call these methods. PrismaClient automatically connects when you run your first query, creates a connection pool, and disconnects when the Node.js process ends.

See the connection management guide for information about managing connections for different deployment paradigms (long-running processes and serverless functions).

$connect()

It is not necessary to call $connect() thanks to the lazy connect behavior: The PrismaClient instance connects lazily when the first request is made to the API ($connect() is called for you under the hood).

Calling $connect() explicitly

If you need the first request to respond instantly and cannot wait for a lazy connection to be established, you can explicitly call prisma.$connect() to establish a connection to the data source:

const prisma = new PrismaClient()
// run inside `async` function
await prisma.$connect()

$disconnect()

When you call $disconnect() , Prisma Client:

  1. Runs the beforeExit hook
  2. Ends the Query Engine child process and closes all connections

In a long-running application such as a GraphQL API, which constantly serves requests, it does not make sense to $disconnect() after each request - it takes time to establish a connection, and doing so as part of each request will slow down your application.

Tip: To avoid too many connections in a long-running application, we recommend that you use a single instance of PrismaClient across your application.

Calling $disconnect() explicitly

One scenario where you should call $disconnect() explicitly is where a script:

  1. Runs infrequently (for example, a scheduled job to send emails each night), which means it does not benefit from a long-running connection to the database and
  2. Exists in the context of a long-running application, such as a background service. If the application never shuts down, Prisma Client never disconnects.

The following script creates a new instance of PrismaClient, performs a task, and then disconnects - which closes the connection pool:

import { PrismaClient } from "@prisma/client";
const prisma = new PrismaClient()
const emailService = new EmailService();
async function main() {
const allUsers = await prisma.user.findMany();
const emails = allUsers.map(x => x.email)
await emailService.send(emails, "Hello!");
}
main()
.catch(e => {
throw e
})
.finally(async () => {
await prisma.$disconnect()
})

If the above script runs multiple times in the context of a long-running application without calling $disconnect(), a new connection pool is created with each new instance of PrismaClient.

Exit hooks

The beforeExit hook runs before Prisma ends its child processes and allows you to issue queries before the client disconnects - for example, as part of a graceful shutdown of a service:

const prisma = new PrismaClient();
prisma.$on('beforeExit', async () => {
// PrismaClient still available
await prisma.message.create({
data: {
message: "Shutting down server";
}
})
})
Edit this page on GitHub