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.

Practice

1. What is the main purpose of Prisma Client in a NestJS application?

easy

A. To interact with the database using simple JavaScript calls

B. To handle HTTP requests and routing

C. To manage application state in the frontend

D. To style components with CSS

Solution

1. Step 1: Understand Prisma Client's role

   Prisma Client is a tool that helps you talk to your database easily using JavaScript.

2. Step 2: Compare with other options

   Handling HTTP requests and routing, managing frontend state, and styling components relate to other parts of an app, not database interaction.

3. Final Answer:

   To interact with the database using simple JavaScript calls -> Option A

4. Quick Check:

   Prisma Client = database interaction [OK]

Hint: Prisma Client is for database queries, not UI or routing [OK]

Common Mistakes:

• Confusing Prisma Client with HTTP routing
• Thinking Prisma Client manages frontend state
• Assuming Prisma Client styles components

2. Which of the following is the correct way to import and instantiate Prisma Client in a NestJS service?

easy

A. import { PrismaClient } from '@prisma/client'; const prisma = new PrismaClient();

B. const prisma = require('prisma-client');

C. import Prisma from 'prisma'; const prisma = Prisma();

D. import { Prisma } from '@nestjs/prisma'; const prisma = new Prisma();

Solution

1. Step 1: Check the official import syntax

   The correct import is from '@prisma/client' and creating a new PrismaClient instance.

2. Step 2: Identify incorrect options

   Using require('prisma-client'), importing from 'prisma', or using '@nestjs/prisma' with incorrect instantiation do not match Prisma Client usage.

3. Final Answer:

   import { PrismaClient } from '@prisma/client'; const prisma = new PrismaClient(); -> Option A

4. Quick Check:

   Correct import and instantiation = import { PrismaClient } from '@prisma/client'; const prisma = new PrismaClient(); [OK]

Hint: Always import PrismaClient from '@prisma/client' and instantiate with new [OK]

Common Mistakes:

• Using require instead of import
• Wrong package names like 'prisma-client'
• Confusing NestJS modules with Prisma Client

3. Given this Prisma Client query in a NestJS service:

const user = await prisma.user.findUnique({ where: { id: 5 } });
console.log(user);

What will be logged if a user with id 5 exists in the database?

medium

A. An array of all users in the database

B. A syntax error

C. null

D. An object containing the user's data with id 5

Solution

1. Step 1: Understand findUnique behavior

   findUnique returns a single record matching the condition or null if none found.

2. Step 2: Given user with id 5 exists

   The query returns the user object with id 5, so console.log prints that object.

3. Final Answer:

   An object containing the user's data with id 5 -> Option D

4. Quick Check:

   findUnique with existing id = user object [OK]

Hint: findUnique returns one object or null, not array [OK]

Common Mistakes:

• Expecting an array instead of an object
• Assuming null even if user exists
• Thinking it causes syntax error

4. Identify the error in this NestJS Prisma Client usage:

import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();

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

medium

A. Function getUsers should not be async

B. Missing await before prisma.user.findMany()

C. findMany() does not exist on prisma.user

D. PrismaClient should not be instantiated directly

Solution

1. Step 1: Check async function usage

   prisma.user.findMany() returns a Promise, so it must be awaited inside async functions.

2. Step 2: Identify missing await

   The code misses 'await' before the call, so it returns a Promise instead of resolved data.

3. Final Answer:

   Missing await before prisma.user.findMany() -> Option B

4. Quick Check:

   Async DB calls need await [OK]

Hint: Await all Prisma async calls inside async functions [OK]

Common Mistakes:

• Forgetting await on async Prisma calls
• Thinking PrismaClient can't be instantiated
• Assuming findMany() is invalid

5. In a NestJS app, you want to ensure Prisma Client connects once on app start and disconnects on shutdown. Which approach is best?

hard

A. Call prisma.$connect() before every query and prisma.$disconnect() after every query

B. Create a new PrismaClient instance inside every controller method

C. Create PrismaClient instance in a service, call prisma.$connect() in onModuleInit(), and prisma.$disconnect() in onModuleDestroy()

D. Use PrismaClient without calling connect or disconnect methods

Solution

1. Step 1: Understand PrismaClient lifecycle

   PrismaClient should connect once when app starts and disconnect on shutdown to manage resources efficiently.

2. Step 2: Evaluate options

   Creating a single PrismaClient instance in a service and using $connect() in onModuleInit() and $disconnect() in onModuleDestroy() leverages NestJS lifecycle hooks properly. Connecting/disconnecting per query, creating new instances per method, or skipping explicit management leads to overhead or resource leaks.

3. Final Answer:

   Create PrismaClient instance in a service, call prisma.$connect() in onModuleInit(), and prisma.$disconnect() in onModuleDestroy() -> Option C

4. Quick Check:

   Use lifecycle hooks for Prisma connection [OK]

Hint: Connect once on start, disconnect on shutdown using lifecycle hooks [OK]

Common Mistakes:

• Creating PrismaClient multiple times
• Connecting/disconnecting on every query
• Ignoring connect/disconnect lifecycle