Prisma ORM with GraphQL - Step-by-Step Execution

Concept Flow - Prisma ORM with GraphQL

Define Prisma schema

↓

Generate Prisma Client

↓

Set up GraphQL schema

↓

Create resolvers using Prisma Client

↓

GraphQL server handles queries/mutations

↓

Resolvers call Prisma Client to access DB

↓

Return data to GraphQL client

This flow shows how Prisma schema leads to a client used in GraphQL resolvers, which handle queries and mutations to access the database.

Execution Sample

GraphQL

model Post {
  id    Int     @id @default(autoincrement())
  title String
  body  String
}

query {
  posts {
    id
    title
  }
}

Defines a Post model in Prisma and a GraphQL query to fetch all posts with id and title.

Execution Table

Step	Action	Prisma Client Call	Database Query	GraphQL Response
1	GraphQL query received	None	None	None
2	Resolver calls prisma.post.findMany()	prisma.post.findMany()	SELECT id, title, body FROM Post;	None
3	Database returns rows	None	[{id:1, title:'Hello', body:'World'}, {id:2, title:'Hi', body:'GraphQL'}]	None
4	Resolver returns filtered data	None	None	[{id:1, title:'Hello'}, {id:2, title:'Hi'}]
5	GraphQL server sends response	None	None	[{id:1, title:'Hello'}, {id:2, title:'Hi'}]

💡 Query completed and response sent to client.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
GraphQL Query	None	{ posts { id title } }	{ posts { id title } }	{ posts { id title } }	None
Prisma Client Call	None	prisma.post.findMany()	prisma.post.findMany()	prisma.post.findMany()	None
Database Result	None	None	[{id:1, title:'Hello', body:'World'}, {id:2, title:'Hi', body:'GraphQL'}]	[{id:1, title:'Hello', body:'World'}, {id:2, title:'Hi', body:'GraphQL'}]	None
GraphQL Response	None	None	None	[{id:1, title:'Hello'}, {id:2, title:'Hi'}]	[{id:1, title:'Hello'}, {id:2, title:'Hi'}]

Key Moments - 3 Insights

Why does the resolver call prisma.post.findMany() instead of directly querying the database?

The resolver uses Prisma Client to abstract database queries, making code simpler and safer. See execution_table step 2 where the Prisma Client call happens instead of raw SQL.

Why does the GraphQL response only include id and title, not the body?

GraphQL returns only requested fields. The query asks for id and title, so the resolver filters out body before sending response (execution_table step 4).

What happens if the database returns no posts?

Prisma Client returns an empty array, so the resolver returns an empty list in GraphQL response, ending the query gracefully.

Visual Quiz - 3 Questions

Look at the execution_table, what is the database query Prisma Client sends at step 2?

A SELECT id, title FROM Post;

B SELECT id, title, body FROM Post;

C prisma.post.findMany()

D GraphQL query posts { id title }

💡 Hint

Check the 'Database Query' column at step 2 in execution_table.

At which step does the resolver filter the database result to only include requested fields?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'GraphQL Response' column in execution_table where filtered data appears.

If the GraphQL query requested the 'body' field too, how would the GraphQL response at step 5 change?

A It would include id, title, and body fields for each post.

B It would only include id and title as before.

C It would cause an error because body is not in Prisma schema.

D It would return an empty list.

💡 Hint

Refer to variable_tracker and execution_table steps showing how requested fields affect response.

Concept Snapshot

Prisma ORM with GraphQL:
- Define data models in Prisma schema.
- Generate Prisma Client to access DB.
- Create GraphQL schema with types and queries.
- Write resolvers calling Prisma Client methods.
- GraphQL queries invoke resolvers, which fetch data via Prisma.
- Responses include only requested fields, ensuring efficient data fetching.

Full Transcript

This visual execution trace shows how Prisma ORM integrates with GraphQL. First, you define your data model in the Prisma schema. Then, Prisma Client is generated to provide easy database access. In GraphQL, you define your schema and resolvers. When a GraphQL query arrives, the resolver calls Prisma Client methods like findMany to fetch data from the database. The database returns full records, but the resolver filters the data to include only the fields requested by the GraphQL query. Finally, the filtered data is sent back as the GraphQL response. This flow helps keep database access safe, simple, and efficient by using Prisma as an abstraction layer and GraphQL to control data shape.

Practice

1. What is the main role of Prisma ORM when used with GraphQL?

easy

A. To define GraphQL schema types

B. To style the frontend user interface

C. To handle HTTP requests from clients

D. To manage database access and queries easily

Solution

1. Step 1: Understand Prisma ORM's purpose

   Prisma ORM acts as a tool to simplify database operations by providing an easy way to query and manage data.

2. Step 2: Differentiate Prisma from GraphQL schema and frontend roles

   GraphQL schema defines data types and operations, while frontend styling is unrelated to Prisma's role.

3. Final Answer:

   To manage database access and queries easily -> Option D

4. Quick Check:

   Prisma ORM = database access tool [OK]

Hint: Prisma handles database, GraphQL defines schema [OK]

Common Mistakes:

• Confusing Prisma with GraphQL schema definition
• Thinking Prisma manages frontend UI
• Assuming Prisma handles HTTP requests

2. Which of the following is the correct way to import Prisma Client in a Node.js GraphQL resolver file?

easy

A. import Prisma from 'prisma';

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

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

D. const { Prisma } = require('@prisma/client');

Solution

1. Step 1: Recall Prisma Client import syntax

   The official Prisma Client is imported using ES module syntax: import { PrismaClient } from '@prisma/client';

2. Step 2: Identify incorrect import forms

   Options B, C, and D use wrong package names or destructuring that Prisma does not support.

3. Final Answer:

   import { PrismaClient } from '@prisma/client'; -> Option C

4. Quick Check:

   Correct Prisma import = import { PrismaClient } from '@prisma/client'; [OK]

Hint: Use exact package '@prisma/client' with named import [OK]

Common Mistakes:

• Using wrong package name like 'prisma-client'
• Incorrect destructuring of PrismaClient
• Mixing CommonJS require with ES import incorrectly

3. Given this GraphQL resolver using Prisma:

const users = await prisma.user.findMany({ where: { active: true } });
return users;

What does this resolver return?

medium

A. All users including inactive ones

B. Only users with active set to true

C. An error because 'active' is not a valid field

D. An empty list always

Solution

1. Step 1: Analyze the Prisma query filter

   The query uses findMany with a where clause filtering users where active equals true.

2. Step 2: Understand the result of the query

   It returns only users whose active field is true, excluding inactive users.

3. Final Answer:

   Only users with active set to true -> Option B

4. Quick Check:

   findMany with where active:true = filtered users [OK]

Hint: Where filters results; active:true returns only active users [OK]

Common Mistakes:

• Assuming it returns all users ignoring filter
• Thinking it causes an error without schema check
• Believing it always returns empty list

4. You wrote this resolver code but get an error:

const newUser = prisma.user.create({
  data: {
    name: 'Alice'
  }
});
return newUser;

What is the likely cause of the error?

medium

A. Missing await before prisma.user.create call

B. Incorrect field name 'name' in data

C. Using create instead of findMany

D. Returning newUser before defining it

Solution

1. Step 1: Check asynchronous Prisma call

   prisma.user.create returns a Promise, so it needs await to resolve before returning.

2. Step 2: Identify missing await causing error

   Without await, newUser is a Promise, not the created user object, causing issues in return.

3. Final Answer:

   Missing await before prisma.user.create call -> Option A

4. Quick Check:

   Async Prisma calls need await [OK]

Hint: Always await Prisma async calls in resolvers [OK]

Common Mistakes:

• Forgetting to await async Prisma methods
• Assuming create returns data synchronously
• Confusing create with findMany usage

5. You want to fetch a user and their posts in one GraphQL query using Prisma. Which resolver code correctly fetches the user with their posts included?

hard

A. const user = await prisma.user.findUnique({ where: { id }, include: { posts: true } });

B. const user = await prisma.user.findMany({ where: { id }, select: { posts: false } });

C. const user = await prisma.post.findMany({ where: { userId: id } });

D. const user = await prisma.user.findUnique({ where: { id } }); const posts = await prisma.post.findMany({ where: { userId: id } });

Solution

1. Step 1: Understand Prisma's include option

   Using include: { posts: true } fetches related posts along with the user in one query.

2. Step 2: Compare options for fetching user with posts

   const user = await prisma.user.findUnique({ where: { id }, include: { posts: true } }); uses findUnique with include correctly; const user = await prisma.user.findMany({ where: { id }, select: { posts: false } }); excludes posts; const user = await prisma.post.findMany({ where: { userId: id } }); fetches posts only; const user = await prisma.user.findUnique({ where: { id } }); const posts = await prisma.post.findMany({ where: { userId: id } }); fetches separately, not in one query.

3. Final Answer:

   const user = await prisma.user.findUnique({ where: { id }, include: { posts: true } }); -> Option A

4. Quick Check:

   Include fetches relations in one query [OK]

Hint: Use include to fetch related data in one Prisma query [OK]

Common Mistakes:

• Using findMany instead of findUnique for single user
• Not using include to fetch related posts
• Fetching posts separately causing extra queries