Prisma setup in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when querying all users with Prisma in NestJS?

Given a NestJS service using Prisma Client to fetch all users, what will be the output if the database has two users named Alice and Bob?

NestJS

import { Injectable } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class UserService {
  private prisma = new PrismaClient();

  async getAllUsers() {
    return await this.prisma.user.findMany();
  }
}

// Assume the database has two users: { id: 1, name: 'Alice' } and { id: 2, name: 'Bob' }

A [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]

B Throws a runtime error because prisma is not injected

C []

D [{ name: 'Alice' }, { name: 'Bob' }]

💡 Hint

Think about what prisma.user.findMany() returns when users exist in the database.

The prisma.user.findMany() method returns an array of user objects with all fields by default. Since the database has two users, the output is an array with both user objects including their ids and names.

📝 Syntax

intermediate

Which option correctly imports and provides PrismaClient in a NestJS module?

You want to use PrismaClient in your NestJS app. Which code snippet correctly sets up PrismaClient as a provider in a module?

A

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

@Module({
  providers: [PrismaClient],
  exports: [PrismaClient],
})
export class PrismaModule {}

B

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

@Module({
  providers: [{ provide: PrismaClient, useClass: PrismaClient }],
  exports: [PrismaClient],
})
export class PrismaModule {}

C

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

const prisma = new PrismaClient();

@Module({
  providers: [{ provide: PrismaClient, useValue: prisma }],
  exports: [PrismaClient],
})
export class PrismaModule {}

D

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

@Module({
  providers: [{ provide: 'PRISMA', useClass: PrismaClient }],
  exports: ['PRISMA'],
})
export class PrismaModule {}

💡 Hint

Think about how to provide a class instance using useClass in NestJS providers.

Option C correctly uses useValue with an instantiated PrismaClient, which is a common pattern to share a single instance. Option C uses useClass which causes NestJS to instantiate PrismaClient multiple times and can cause issues. Option C tries to provide the class directly without useClass or useValue, which is invalid. Option C uses a string token but does not match typical PrismaClient injection patterns.

❓ lifecycle

advanced

What happens if PrismaClient is not disconnected properly in NestJS?

Consider a NestJS service that creates a PrismaClient instance but never calls prisma.$disconnect(). What is the likely effect when the app shuts down?

A The app shuts down cleanly without any issues.

B The app throws an error during shutdown.

C PrismaClient automatically disconnects, so no effect occurs.

D The app may hang or delay shutdown due to open database connections.

💡 Hint

Think about what happens to open connections if they are not closed.

If PrismaClient is not disconnected, open database connections remain active, which can cause the app to hang or delay shutdown as it waits for connections to close. PrismaClient does not automatically disconnect on app shutdown.

🔧 Debug

advanced

Why does this NestJS Prisma service throw 'Cannot read property findMany of undefined'?

Look at this service code snippet: import { Injectable } from '@nestjs/common'; import { PrismaClient } from '@prisma/client'; @Injectable() export class UserService { constructor(private prisma: PrismaClient) {} async getUsers() { return await this.prisma.user.findMany(); } } What causes the error when calling getUsers()?

A The user model does not exist in Prisma schema.

B PrismaClient is not registered as a provider and so prisma is undefined in constructor.

C findMany is not a method on prisma.user.

D The constructor parameter should be optional.

💡 Hint

Check how PrismaClient is injected into the service.

The error occurs because PrismaClient is not provided in the NestJS dependency injection system, so the prisma parameter is undefined. Without registering PrismaClient as a provider, NestJS cannot inject it.

🧠 Conceptual

expert

What is the best way to share a single PrismaClient instance across multiple NestJS services?

You have multiple services in NestJS that need to use PrismaClient. Which approach ensures a single PrismaClient instance is shared app-wide?

A Create a PrismaModule that provides PrismaClient with useClass and import it in all modules needing Prisma.

B Instantiate PrismaClient separately in each service constructor.

C Use a global variable to store PrismaClient and import it in services.

D Create PrismaClient inside each method call to avoid sharing.

💡 Hint

Think about NestJS modules and providers for sharing instances.

Creating a PrismaModule that provides PrismaClient as a singleton using useClass and importing it where needed ensures one shared instance. Instantiating separately or per method wastes resources and can cause connection issues. Using global variables is not recommended in NestJS architecture.

Practice

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

easy

A. To provide a reusable database client instance for querying the database

B. To handle HTTP requests and responses

C. To define the database schema

D. To manage application configuration settings

Solution

1. Step 1: Understand PrismaService role

   PrismaService wraps the Prisma Client to provide a single database connection instance across the app.

2. Step 2: Differentiate from other roles

   It does not handle HTTP or define schema; those are handled by controllers and Prisma schema files respectively.

3. Final Answer:

   To provide a reusable database client instance for querying the database -> Option A

4. Quick Check:

   PrismaService = database client provider [OK]

Hint: PrismaService is your database helper in NestJS [OK]

Common Mistakes:

• Confusing PrismaService with controllers
• Thinking PrismaService defines schema
• Assuming PrismaService manages config

2. Which of the following is the correct way to import and provide PrismaService in a NestJS module?

easy

A. import { PrismaService } from '@nestjs/common';

@Module({ controllers: [PrismaService] })

B. import { PrismaService } from './prisma.service';

@Module({ providers: [PrismaService], exports: [PrismaService] })

C. import PrismaService from 'prisma';

@Module({ providers: [PrismaService] })

D. import { PrismaService } from './prisma.service';

@Module({ imports: [PrismaService] })

Solution

1. Step 1: Check import source

   PrismaService is a custom service, so it must be imported from its local file, not from '@nestjs/common' or external packages.

2. Step 2: Verify module metadata

   It should be listed under providers and exports to be injectable and reusable in other modules.

3. Final Answer:

   import { PrismaService } from './prisma.service'; @Module({ providers: [PrismaService], exports: [PrismaService] }) -> Option B

4. Quick Check:

   Local import + providers and exports = correct setup [OK]

Hint: PrismaService is a provider, import locally and add to providers [OK]

Common Mistakes:

• Importing PrismaService from wrong package
• Adding PrismaService to controllers instead of providers
• Using imports array instead of providers

3. Given this PrismaService method in NestJS, what will console.log(user) output if the user with ID 1 exists?

async getUserById(id: number) {
  return this.prisma.user.findUnique({ where: { id } });
}

const user = await prismaService.getUserById(1);
console.log(user);

medium

A. A syntax error because findUnique is not a function

B. An array of all users in the database

C. An object containing the user's data with ID 1

D. null, because findUnique returns nothing

Solution

1. Step 1: Understand findUnique behavior

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

2. Step 2: Given user with ID 1 exists

   The method returns the user object with ID 1, so console.log prints that object.

3. Final Answer:

   An object containing the user's data with ID 1 -> Option C

4. Quick Check:

   findUnique returns single object or null [OK]

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

Common Mistakes:

• Thinking findUnique returns an array
• Assuming it always returns null
• Confusing findUnique with findMany

4. You wrote this PrismaService method but get a runtime error: Cannot read property 'user' of undefined. What is the likely cause?

async getAllUsers() {
  return this.prisma.user.findMany();
}

Options:

medium

A. The Prisma Client instance was not initialized in PrismaService

B. The user model is missing in the Prisma schema

C. The method should be static to access prisma

D. findMany() requires parameters and cannot be empty

Solution

1. Step 1: Analyze error message

   'Cannot read property user of undefined' means this.prisma is undefined in the service.

2. Step 2: Check PrismaService initialization

   Prisma Client must be instantiated and assigned to this.prisma in the constructor; missing this causes the error.

3. Final Answer:

   The Prisma Client instance was not initialized in PrismaService -> Option A

4. Quick Check:

   Uninitialized prisma client = undefined error [OK]

Hint: Initialize prisma client in constructor to avoid undefined errors [OK]

Common Mistakes:

• Forgetting to instantiate PrismaClient in PrismaService
• Assuming findMany needs parameters
• Thinking method must be static

5. You want to create a NestJS service method that fetches all posts with their authors using Prisma. Which code snippet correctly uses Prisma to fetch posts including author data?

hard

A. return this.prisma.post.findMany({ where: { author: true } });

B. return this.prisma.post.findMany({ select: { authorId: true } });

C. return this.prisma.post.findUnique({ where: { id: 1 }, include: { author: true } });

D. return this.prisma.post.findMany({ include: { author: true } });

Solution

1. Step 1: Understand fetching related data

   To get posts with their authors, use findMany with include: { author: true } to load related author data.

2. Step 2: Check other options

   return this.prisma.post.findMany({ select: { authorId: true } }); only selects authorId, not author object. return this.prisma.post.findUnique({ where: { id: 1 }, include: { author: true } }); fetches one post, not all. return this.prisma.post.findMany({ where: { author: true } }); uses invalid where clause.

3. Final Answer:

   return this.prisma.post.findMany({ include: { author: true } }); -> Option D

4. Quick Check:

   Include loads related models in findMany [OK]

Hint: Use include to fetch related models in Prisma queries [OK]

Common Mistakes:

• Using select instead of include for relations
• Using findUnique when multiple records needed
• Incorrect where clause for relations