Delete mutation pattern in GraphQL - Mini Project: Build & Apply

Delete Mutation Pattern in GraphQL

📖 Scenario: You are building a simple GraphQL API for a library system. The system stores books with their id, title, and author. You want to allow users to delete a book by its id.

🎯 Goal: Create a GraphQL delete mutation called deleteBook that takes a book id as input and returns the deleted book's id and title.

📋 What You'll Learn

Define a Book type with id, title, and author fields

Create a deleteBook mutation that accepts an id argument of type ID!

The mutation should return the deleted book's id and title

Implement resolver logic to remove the book from the data store

💡 Why This Matters

🌍 Real World

Deleting records is a common operation in APIs, such as removing users, products, or posts. This pattern helps maintain data integrity and user control.

💼 Career

Understanding how to implement delete mutations is essential for backend developers working with GraphQL APIs in real-world applications.

1

Define the Book type and initial data

Create a GraphQL type Book with fields id (ID!), title (String!), and author (String!). Also, create an array called books with these exact entries: { id: "1", title: "1984", author: "George Orwell" }, { id: "2", title: "Brave New World", author: "Aldous Huxley" }, and { id: "3", title: "Fahrenheit 451", author: "Ray Bradbury" }.

GraphQL

# Define the Book type and create the books array
# Your code here

Hint

Use the type keyword to define the Book type. Create a JavaScript array named books with the exact book objects.

2

Add the deleteBook mutation to the schema

Add a type Mutation to the GraphQL schema with a deleteBook mutation. It should accept an id argument of type ID! and return a Book.

GraphQL

const { gql } = require('apollo-server');

const typeDefs = gql`
  type Book {
    id: ID!
    title: String!
    author: String!
  }

  # Add the Mutation type with deleteBook mutation here
  # Your code here
`;

const books = [
  { id: "1", title: "1984", author: "George Orwell" },
  { id: "2", title: "Brave New World", author: "Aldous Huxley" },
  { id: "3", title: "Fahrenheit 451", author: "Ray Bradbury" }
];

Hint

Define a Mutation type with a deleteBook field that takes id: ID! and returns a Book.

3

Implement the deleteBook resolver logic

Create a resolvers object with a Mutation field. Implement the deleteBook resolver that takes parent, args, and removes the book with the matching id from the books array. Return the deleted book object.

GraphQL

const { gql } = require('apollo-server');

const typeDefs = gql`
  type Book {
    id: ID!
    title: String!
    author: String!
  }

  type Mutation {
    deleteBook(id: ID!): Book
  }
`;

const books = [
  { id: "1", title: "1984", author: "George Orwell" },
  { id: "2", title: "Brave New World", author: "Aldous Huxley" },
  { id: "3", title: "Fahrenheit 451", author: "Ray Bradbury" }
];

// Add the resolvers object with deleteBook mutation resolver
// Your code here

Hint

Use findIndex to locate the book by id. Use splice to remove it and return the removed book.

4

Export the schema and resolvers for the server

Export the typeDefs and resolvers objects using module.exports so they can be used to create the GraphQL server.

GraphQL

const { gql } = require('apollo-server');

const typeDefs = gql`
  type Book {
    id: ID!
    title: String!
    author: String!
  }

  type Mutation {
    deleteBook(id: ID!): Book
  }
`;

const books = [
  { id: "1", title: "1984", author: "George Orwell" },
  { id: "2", title: "Brave New World", author: "Aldous Huxley" },
  { id: "3", title: "Fahrenheit 451", author: "Ray Bradbury" }
];

const resolvers = {
  Mutation: {
    deleteBook(parent, args) {
      const index = books.findIndex(book => book.id === args.id);
      if (index === -1) return null;
      const deleted = books.splice(index, 1)[0];
      return deleted;
    }
  }
};

// Export typeDefs and resolvers
// Your code here

Hint

Use module.exports to export both typeDefs and resolvers.

Practice

1.

What is the main purpose of a delete mutation in GraphQL?

easy

A. To update existing data in the database

B. To add new data to the database

C. To remove data from the database using an identifier

D. To fetch data without modifying it

Solution

1. Step 1: Understand the role of delete mutations

   Delete mutations are designed to remove data entries, usually by specifying an ID or unique key.

2. Step 2: Compare with other mutation types

   Add mutations create data, update mutations modify data, and queries fetch data without changes.

3. Final Answer:

   To remove data from the database using an identifier -> Option C

4. Quick Check:

   Delete mutation = remove data [OK]

Hint: Delete mutations always remove data by ID [OK]

Common Mistakes:

• Confusing delete with add or update mutations
• Thinking delete fetches data
• Assuming delete mutations do not require an identifier

2.

Which of the following is the correct syntax for a GraphQL delete mutation to remove a user by ID?

mutation {
  deleteUser(id: "123") {
    success
    message
  }
}

easy

A. mutation { deleteUser(id: "123") { success message } }

B. mutation { deleteUser { id: "123" success message } }

C. mutation { deleteUser(id: 123) { success message } }

D. mutation { deleteUser(id: "123") success message }

Solution

1. Step 1: Check argument placement and syntax

   The ID must be passed as an argument inside parentheses with quotes for string: id: "123".

2. Step 2: Verify the selection set braces

   The fields to return (success, message) must be inside braces after the mutation call.

3. Final Answer:

   mutation { deleteUser(id: "123") { success message } } -> Option A

4. Quick Check:

   Correct syntax = mutation { deleteUser(id: "123") { success message } } [OK]

Hint: Arguments go inside parentheses, fields inside braces [OK]

Common Mistakes:

• Passing id without quotes for string
• Placing fields outside braces
• Misplacing argument inside selection set

3.

Given the following delete mutation and response, what is the value of success?

mutation {
  deletePost(id: "abc") {
    success
    message
  }
}

Response:

{
  "data": {
    "deletePost": {
      "success": true,
      "message": "Post deleted successfully"
    }
  }
}

medium

A. false

B. true

C. null

D. undefined

Solution

1. Step 1: Read the mutation response carefully

   The response shows the success field inside deletePost as true.

2. Step 2: Understand the meaning of success

   A true value means the deletion was successful.

3. Final Answer:

   true -> Option B

4. Quick Check:

   Response success = true [OK]

Hint: Check response JSON for success field value [OK]

Common Mistakes:

• Confusing success with message content
• Assuming success is false without checking response
• Ignoring JSON structure

4.

Identify the error in this delete mutation:

mutation {
  deleteComment(commentId: 456) {
    success
    message
  }
}

medium

A. Missing quotes around the commentId value

B. Missing selection set braces

C. Incorrect mutation keyword

D. Using wrong field names in response

Solution

1. Step 1: Check argument data type

   The commentId is likely a string and should be enclosed in quotes: "456".

2. Step 2: Verify mutation syntax

   The mutation keyword and selection set braces are correct; field names are valid.

3. Final Answer:

   Missing quotes around the commentId value -> Option A

4. Quick Check:

   String IDs need quotes [OK]

Hint: String IDs must be in quotes in mutations [OK]

Common Mistakes:

• Passing string IDs without quotes
• Omitting braces around fields
• Using wrong mutation keyword

5.

You want to delete multiple users by their IDs in one mutation call. Which approach correctly applies the delete mutation pattern?

Options:

1. mutation { deleteUsers(ids: ["1", "2", "3"]) { success message } }
2. mutation { deleteUser(id: "1") { success message } deleteUser(id: "2") { success message } }
3. mutation { deleteUser(id: "1") { success message } }
4. mutation { deleteUsers(ids: "1,2,3") { success message } }

hard

A. Call deleteUser mutation multiple times in one request

B. Pass IDs as a comma-separated string in deleteUsers(ids: "1,2,3")

C. Delete only one user at a time with deleteUser(id: "1")

D. Use a single mutation with an array of IDs: deleteUsers(ids: ["1", "2", "3"])

Solution

1. Step 1: Understand batch deletion

   To delete multiple users at once, the mutation must accept an array of IDs.

2. Step 2: Evaluate options

   Use a single mutation with an array of IDs: deleteUsers(ids: ["1", "2", "3"]) correctly passes an array of strings. Call deleteUser mutation multiple times in one request tries multiple mutations in one call, which is invalid syntax. Delete only one user at a time with deleteUser(id: "1") deletes only one user. Pass IDs as a comma-separated string in deleteUsers(ids: "1,2,3") passes a string instead of an array.

3. Final Answer:

   Use a single mutation with an array of IDs: deleteUsers(ids: ["1", "2", "3"]) -> Option D

4. Quick Check:

   Batch delete uses array of IDs [OK]

Hint: Batch deletes use array arguments, not comma strings [OK]

Common Mistakes:

• Trying multiple mutations in one call
• Passing IDs as comma string instead of array
• Assuming single delete mutation handles multiple IDs