Why mutations modify data in GraphQL - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a mutation that adds a new user with a name.

GraphQL

type Mutation { addUser(name: String!): [1] }

Drag options to blanks, or click blank then click option'

A: User

B{ id: ID, name: String }

C-> User

D!

Attempts:

3 left

💡 Hint

Common Mistakes

Using '!' after the mutation name instead of after the argument type.

Using '->' which is not valid GraphQL syntax.

Trying to define fields inside the mutation signature.

The mutation must specify the return type after the colon. Here, : User means the mutation returns a User object.

2fill in blank

medium

Complete the mutation resolver function to update a user's name by ID.

GraphQL

updateUser: (parent, args, context) => { return context.db.users.[1](args.id, args.name); }

Drag options to blanks, or click blank then click option'

Aupdate

BupdateName

CupdateUserName

Dfind

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'find' which only retrieves data.

Using made-up method names not defined in the context.

Using 'updateName' which is not a standard method.

The correct method to modify user data is typically called update. It updates the user with the given ID and new name.

3fill in blank

hard

Fix the error in the mutation resolver that tries to delete a user but returns nothing.

GraphQL

deleteUser: (parent, args, context) => { context.db.users.delete(args.id); return [1]; }

Drag options to blanks, or click blank then click option'

Aargs.id

Btrue

Cnull

Dcontext.db.users.find(args.id)

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the deleted user's ID which no longer exists.

Returning true which is not a User object.

Trying to find the user after deletion which returns nothing.

After deleting, returning null is common to indicate no user object is returned.

4fill in blank

hard

Complete the code to complete the mutation that creates a post and returns its ID and title.

GraphQL

type Mutation { createPost(title: String!, content: String!): [1] { id, title } }

Drag options to blanks, or click blank then click option'

APost

BUser

C:

D,

Attempts:

3 left

💡 Hint

Common Mistakes

Using ':' instead of ',' between fields.

Returning 'User' instead of 'Post'.

Omitting the comma between fields.

The mutation returns a Post type. Inside the selection set, fields are separated by commas, so , is correct.

5fill in blank

hard

Fill all three blanks to write a mutation resolver that adds a comment and returns the comment text if the content length is greater than 0.

GraphQL

addComment: (parent, args, context) => { if (args.content.[3] [1] 0) { return { text: args.[2] }; } else { return null; } }

Drag options to blanks, or click blank then click option'

A>

Bcontent

Clength

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' instead of '>' in the condition.

Using 'text' instead of 'content' for the argument field.

Using 'length' as a field name instead of a property.

The condition checks if args.content.length is greater than 0. Then it returns an object with the text field set to args.content.

Practice

1. What is the main purpose of a mutation in GraphQL?

easy

A. To modify data by adding, updating, or deleting it

B. To only fetch data without changes

C. To define the schema structure

D. To create a new query type

Solution

1. Step 1: Understand the role of mutations

   Mutations are designed to change data, unlike queries which only fetch data.

2. Step 2: Identify the correct purpose

   Since mutations add, update, or delete data, their main purpose is to modify data.

3. Final Answer:

   To modify data by adding, updating, or deleting it -> Option A

4. Quick Check:

   Mutation = Modify data [OK]

Hint: Mutations always change data, queries only read data [OK]

Common Mistakes:

• Confusing mutations with queries
• Thinking mutations only fetch data
• Believing mutations define schema only

2. Which of the following is the correct way to start a mutation operation in GraphQL?

easy

A. modify { updateUser(id: 1) { name } }

B. query { updateUser(id: 1) { name } }

C. update { updateUser(id: 1) { name } }

D. mutation { updateUser(id: 1) { name } }

Solution

1. Step 1: Identify the keyword for mutations

   GraphQL uses the keyword mutation to start mutation operations.

2. Step 2: Check the options

   Only mutation { updateUser(id: 1) { name } } uses the correct mutation keyword to start the operation.

3. Final Answer:

   mutation { updateUser(id: 1) { name } } -> Option D

4. Quick Check:

   Mutation keyword = mutation [OK]

Hint: Mutations always start with the 'mutation' keyword [OK]

Common Mistakes:

• Using 'query' instead of 'mutation'
• Using non-existent keywords like 'update' or 'modify'
• Omitting the mutation keyword

3. Given the mutation below, what will be the result if the user with id 2 exists?

mutation {
  updateUser(id: 2, input: {name: "Alice"}) {
    id
    name
  }
}

medium

A. Syntax error due to missing input type

B. { "data": { "updateUser": null } }

C. { "data": { "updateUser": { "id": 2, "name": "Alice" } } }

D. No change, returns old user data

Solution

1. Step 1: Understand mutation behavior

   The mutation updates user with id 2, changing the name to "Alice".

2. Step 2: Predict the returned data

   The mutation returns the updated user data with id and new name.

3. Final Answer:

   { "data": { "updateUser": { "id": 2, "name": "Alice" } } } -> Option C

4. Quick Check:

   Mutation updates and returns new data [OK]

Hint: Mutations return updated data if successful [OK]

Common Mistakes:

• Assuming mutation returns null on success
• Thinking mutation causes syntax error here
• Believing mutation returns old data without changes

4. Identify the error in this mutation:

mutation {
  addUser(name: "Bob")
  {
    id
    name
  }
}

medium

A. Mutation keyword is incorrect

B. Missing input argument object for addUser

C. Curly braces are misplaced

D. No error, mutation is correct

Solution

1. Step 1: Check mutation input format

   Mutations usually require input as an object, e.g., addUser(input: {name: "Bob"}).

2. Step 2: Identify missing input argument

   The mutation lacks the input argument object, causing an error.

3. Final Answer:

   Missing input argument object for addUser -> Option B

4. Quick Check:

   Input argument missing = error [OK]

Hint: Mutations need input objects for data changes [OK]

Common Mistakes:

• Forgetting to wrap inputs in an object
• Misplacing curly braces
• Confusing mutation keyword

5. You want to delete a user and then immediately fetch the updated user list in one mutation operation. Which approach correctly uses mutations to achieve this?

hard

A. Use a single mutation with two fields: deleteUser and users to delete and fetch updated list

B. Use a query to delete the user and a mutation to fetch the list

C. Use two separate mutations, one for deleting and one for fetching users

D. Use a mutation to delete the user and a query to fetch the updated list separately

Solution

1. Step 1: Understand mutation capabilities

   GraphQL mutations can include multiple fields to perform several operations in one request.

2. Step 2: Identify correct approach

   Using a single mutation with deleteUser and users fields allows deleting and fetching updated data atomically.

3. Final Answer:

   Use a single mutation with two fields: deleteUser and users to delete and fetch updated list -> Option A

4. Quick Check:

   Single mutation can do multiple related operations [OK]

Hint: Combine delete and fetch in one mutation for atomic update [OK]

Common Mistakes:

• Trying to delete with a query
• Splitting operations into separate requests unnecessarily
• Using mutation only for delete without fetching updated data