Prisma Client usage in NestJS - Step-by-Step Execution

Concept Flow - Prisma Client usage

Import PrismaClient

↓

Create PrismaClient instance

↓

Call Prisma methods (e.g., findMany)

↓

Receive data from DB

↓

Use data in app (e.g., return response)

↓

Disconnect PrismaClient when done

This flow shows how to import, create, use, and disconnect Prisma Client in a NestJS app to interact with the database.

Execution Sample

NestJS

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

async function getUsers() {
  const users = await prisma.user.findMany();
  await prisma.$disconnect();
  return users;
}

This code creates a PrismaClient instance, fetches all users from the database asynchronously, disconnects, and returns the data.

Execution Table

Step	Action	Code Line	Result/State
1	Import PrismaClient class	import { PrismaClient } from '@prisma/client';	PrismaClient class available
2	Create PrismaClient instance	const prisma = new PrismaClient();	prisma object created, connected to DB
3	Fetch users from DB	const users = await prisma.user.findMany();	Query sent to DB, waiting for response
4	Receive data from DB	(await completes)	Array of user objects received into users
5	Return data to caller	return users;	Users data ready to use or send in response
6	Disconnect PrismaClient	await prisma.$disconnect();	Connection to DB closed
7	End	Function completes	No open DB connections

💡 Function ends after data is fetched and PrismaClient disconnects to free resources

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
prisma	undefined	PrismaClient instance	PrismaClient instance	Disconnected PrismaClient
users	undefined	undefined	Array of user objects	Array of user objects

Key Moments - 3 Insights

Why do we create a new PrismaClient instance instead of using PrismaClient directly?

Because PrismaClient is a class, we must create an instance to connect to the database and run queries. See Step 2 in execution_table where prisma is created.

What happens if we don't disconnect PrismaClient after queries?

The database connection stays open, which can cause resource leaks. Step 6 shows disconnecting to close the connection properly.

Why is 'await' used before prisma.user.findMany()?

Because database queries are asynchronous, 'await' waits for the data before continuing. Step 3 shows the query sent and waiting for response.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'prisma' after Step 2?

A Undefined

B PrismaClient instance connected to DB

C Disconnected PrismaClient

D Array of user objects

💡 Hint

Check the 'Result/State' column for Step 2 in execution_table

At which step does the app receive the user data from the database?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look for when 'Array of user objects received' appears in execution_table

If we remove 'await' before prisma.user.findMany(), what changes in the execution?

A PrismaClient disconnects earlier

B The database query runs synchronously

C The function returns a Promise instead of user data immediately

D No change in behavior

💡 Hint

Consider the asynchronous nature shown in Step 3 of execution_table

Concept Snapshot

Prisma Client usage in NestJS:
- Import PrismaClient from '@prisma/client'
- Create an instance: const prisma = new PrismaClient();
- Use async calls like prisma.user.findMany() with await
- Disconnect with prisma.$disconnect() to free resources
- Always handle async properly to get DB data

Full Transcript

This visual execution trace shows how to use Prisma Client in a NestJS app. First, we import the PrismaClient class. Then, we create an instance which connects to the database. Next, we call an async method like prisma.user.findMany() to fetch data. We await the result to get the user array. After using the data, we disconnect the PrismaClient to close the database connection. Variables like 'prisma' hold the client instance, and 'users' hold the fetched data. Key points include creating the instance before queries, awaiting async calls, and disconnecting after use to avoid resource leaks.