MongoDB with GraphQL - Step-by-Step Execution

Concept Flow - MongoDB with GraphQL

Client sends GraphQL query

↓

GraphQL Server parses query

↓

Resolver functions execute

↓

Resolvers query MongoDB database

↓

MongoDB returns data

↓

GraphQL Server formats response

↓

Client receives requested data

The client sends a GraphQL query, the server parses it, resolvers fetch data from MongoDB, then the server returns the requested data to the client.

Execution Sample

GraphQL

query {
  books {
    title
    author
  }
}

This query asks for a list of books with their titles and authors from MongoDB via GraphQL.

Execution Table

Step	Action	GraphQL Query Part	MongoDB Operation	Data Returned	Result Sent to Client
1	Receive query	query { books { title author } }	None	None	None
2	Parse query	Identify 'books' field and subfields 'title', 'author'	None	None	None
3	Call resolver for 'books'	books	db.books.find({}, {title: 1, author: 1})	List of book documents with title and author	None
4	Format data	Prepare list of {title, author} objects	None	None	Formatted JSON data
5	Send response	Return data to client	None	None	[{title: 'Book1', author: 'Author1'}, ...]
6	Client receives data	Display books list	None	None	Displayed book list

💡 Query fully resolved and data sent to client

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
query	None	Parsed AST of query	Parsed AST	Parsed AST	Parsed AST
resolverResult	None	None	MongoDB cursor with book docs	List of book objects	List of book objects
response	None	None	None	Formatted JSON	Sent to client

Key Moments - 3 Insights

Why does the resolver query MongoDB only after parsing the GraphQL query?

Because the server needs to know exactly what fields the client requested (like 'title' and 'author') before asking MongoDB, as shown in execution_table step 3.

How does GraphQL know which MongoDB collection to query?

The resolver functions are written to connect specific GraphQL fields (like 'books') to MongoDB collections (like 'books'), as seen in execution_table step 3.

Why is the data formatted after fetching from MongoDB?

MongoDB returns raw documents; GraphQL formats them to match the query shape before sending to the client, as shown in execution_table step 4.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the server query MongoDB?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Check the 'MongoDB Operation' column in execution_table rows.

According to variable_tracker, what does 'resolverResult' hold after Step 3?

A Formatted JSON response

B MongoDB cursor with book documents

C Parsed query AST

D Client's original query string

💡 Hint

Look at the 'resolverResult' row and the 'After Step 3' column in variable_tracker.

If the client requested an additional field 'year', which step would change?

A All of the above

B Step 3 MongoDB query

C Step 2 parsing

D Step 4 formatting

💡 Hint

Adding a field affects parsing, querying, and formatting as shown in execution_table steps 2-4.

Concept Snapshot

MongoDB with GraphQL:
- Client sends GraphQL query
- Server parses query and calls resolvers
- Resolvers query MongoDB collections
- Data returned is formatted to match query
- Response sent back to client
- Enables flexible, precise data fetching

Full Transcript

This visual execution shows how a GraphQL query requesting books with titles and authors is processed. The client sends the query, the server parses it to understand requested fields, then resolver functions query MongoDB for matching data. MongoDB returns documents, which the server formats to match the GraphQL query shape. Finally, the server sends the formatted data back to the client. Variables like the parsed query, resolver results, and response data change step-by-step. Key moments clarify why parsing happens before querying and how resolvers connect GraphQL fields to MongoDB collections. The quiz tests understanding of when MongoDB is queried and how data flows through the system.

Practice

1. What is the main purpose of using GraphQL with MongoDB?

easy

A. To store data in tables instead of documents

B. To replace MongoDB with a SQL database

C. To automatically backup MongoDB data

D. To query only the specific data fields needed from MongoDB

Solution

1. Step 1: Understand GraphQL's role

   GraphQL allows clients to request exactly the data they want, no more, no less.

2. Step 2: Connect to MongoDB data

   MongoDB stores flexible documents, and GraphQL queries these documents precisely.

3. Final Answer:

   To query only the specific data fields needed from MongoDB -> Option D

4. Quick Check:

   GraphQL queries = precise data retrieval [OK]

Hint: GraphQL fetches only requested fields from MongoDB [OK]

Common Mistakes:

• Thinking GraphQL replaces MongoDB
• Confusing document storage with tables
• Assuming GraphQL handles backups

2. Which of the following is the correct way to define a GraphQL query to fetch a list of users from MongoDB?

easy

A. query { users { id name email } }

B. mutation { users { id name email } }

C. query users { id name email }

D. fetch users from MongoDB

Solution

1. Step 1: Identify GraphQL query syntax

   GraphQL queries start with the keyword query followed by the selection set.

2. Step 2: Check the options

   query { users { id name email } } correctly uses query { users { id name email } } to fetch user fields.

3. Final Answer:

   query { users { id name email } } -> Option A

4. Quick Check:

   GraphQL query syntax = query + selection set [OK]

Hint: Queries start with 'query' keyword, mutations with 'mutation' [OK]

Common Mistakes:

• Using mutation instead of query for fetching data
• Omitting braces or keywords
• Writing invalid syntax like 'fetch users from MongoDB'

3. Given this GraphQL query to fetch a user by ID:
query { user(id: "123") { name age } }
And MongoDB has a user document { _id: "123", name: "Alice", age: 30, city: "NY" }, what will be the query result?

medium

A. { "data": { "user": { "name": "Alice", "age": 30 } } }

B. { "data": { "user": { "name": "Alice", "city": "NY" } } }

C. { "data": { "user": { "id": "123", "name": "Alice" } } }

D. { "error": "User not found" }

Solution

1. Step 1: Understand the query fields

   The query requests only name and age fields for user with id "123".

2. Step 2: Match MongoDB document fields

   The document has those fields: name "Alice" and age 30, so those are returned.

3. Final Answer:

   { "data": { "user": { "name": "Alice", "age": 30 } } } -> Option A

4. Quick Check:

   Requested fields returned exactly [OK]

Hint: GraphQL returns only requested fields, ignoring others [OK]

Common Mistakes:

• Expecting all document fields returned
• Confusing id with _id field
• Assuming error when user exists

4. You wrote this GraphQL mutation to add a new user:
mutation { addUser(name: "Bob", age: "25") { id name } }
But you get an error: "Field 'addUser' argument 'age' of type 'Int!' was provided invalid value." What is the likely cause?

medium

A. The mutation syntax is incorrect; should use query instead

B. The age argument is missing in the schema definition

C. The age argument was provided as a string, not an integer

D. The age value 25 is invalid because it is too low

Solution

1. Step 1: Analyze the error message

   The error says the 'age' argument type is 'Int!' but the value is invalid.

2. Step 2: Analyze the query literal

   The query provides age: "25" as a string literal, but the schema expects an integer literal for Int!, causing the invalid value error.

3. Final Answer:

   The age argument was provided as a string, not an integer -> Option C

4. Quick Check:

   Type mismatch in argument causes invalid value error [OK]

Hint: Match argument types exactly as schema defines [OK]

Common Mistakes:

• Using query instead of mutation for data change
• Ignoring schema argument types
• Assuming numeric values are always valid

5. You want to update a user's city in MongoDB using GraphQL. The schema defines a mutation:
updateUser(id: ID!, city: String!): User
Which resolver code snippet correctly updates the city field in MongoDB?

hard

A. return UserModel.updateOne({ id }, { city });

B. return UserModel.findByIdAndUpdate(id, { city }, { new: true });

C. return UserModel.findOneAndDelete({ _id: id });

D. return UserModel.insertOne({ id, city });

Solution

1. Step 1: Identify correct MongoDB update method

   findByIdAndUpdate updates a document by its _id and returns the updated document.

2. Step 2: Check options for update and return

   return UserModel.findByIdAndUpdate(id, { city }, { new: true }); uses findByIdAndUpdate with { new: true } to return updated user, matching schema.

3. Final Answer:

   return UserModel.findByIdAndUpdate(id, { city }, { new: true }); -> Option B

4. Quick Check:

   Use findByIdAndUpdate to update and return new doc [OK]

Hint: Use findByIdAndUpdate with { new: true } to get updated doc [OK]

Common Mistakes:

• Using updateOne without returning updated document
• Deleting instead of updating
• Inserting new document instead of updating existing