Custom error extensions in GraphQL - Mini Project: Build & Apply

Custom Error Extensions in GraphQL

📖 Scenario: You are building a GraphQL API for a bookstore. You want to provide clear error messages with extra details when something goes wrong, so clients can understand and handle errors better.

🎯 Goal: Create a GraphQL schema with a query that can return custom errors including additional information in the extensions field.

📋 What You'll Learn

Define a simple GraphQL schema with a book query that takes an id argument.

Create a custom error class that adds an extensions field with extra error details.

Throw the custom error when a book with the given id is not found.

Ensure the error response includes the extensions field with the custom data.

💡 Why This Matters

🌍 Real World

Custom error extensions help API clients understand exactly what went wrong and how to handle errors gracefully.

💼 Career

Many companies use GraphQL APIs and expect developers to provide clear, structured error information for better client-side error handling.

1

Define the GraphQL schema with a book query

Create a GraphQL schema string called typeDefs with a Book type having fields id (ID!), title (String!), and a Query type with a book field that takes an id argument of type ID! and returns a Book.

GraphQL

# Your code here

Hint

Use backticks to create a multi-line string for the schema.

2

Create a custom error class with extensions

Define a class called BookNotFoundError that extends Error. In its constructor, accept a message and set this.extensions to an object with a code property set to BOOK_NOT_FOUND and a timestamp property set to the current ISO date string.

GraphQL

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

  type Query {
    book(id: ID!): Book
  }
`;

// Your code here

Hint

Remember to call super(message) in the constructor.

3

Implement the resolver to throw the custom error

Create a resolvers object with a Query field. Inside Query, define a book function that takes parent, args, and context. Use a hardcoded array books with one book: { id: '1', title: '1984' }. Find the book by args.id. If not found, throw a BookNotFoundError with the message Book with id {args.id} not found. Otherwise, return the book.

GraphQL

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

  type Query {
    book(id: ID!): Book
  }
`;

class BookNotFoundError extends Error {
  constructor(message) {
    super(message);
    this.extensions = {
      code: 'BOOK_NOT_FOUND',
      timestamp: new Date().toISOString()
    };
  }
}

// Your code here

Hint

Use Array.find to locate the book by id.

4

Export the schema and resolvers for server setup

Export the typeDefs and resolvers using module.exports as an object with keys typeDefs and resolvers.

GraphQL

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

  type Query {
    book(id: ID!): Book
  }
`;

class BookNotFoundError extends Error {
  constructor(message) {
    super(message);
    this.extensions = {
      code: 'BOOK_NOT_FOUND',
      timestamp: new Date().toISOString()
    };
  }
}

const resolvers = {
  Query: {
    book(parent, args, context) {
      const books = [{ id: '1', title: '1984' }];
      const book = books.find(b => b.id === args.id);
      if (!book) {
        throw new BookNotFoundError(`Book with id ${args.id} not found`);
      }
      return book;
    }
  }
};

// Your code here

Hint

Use module.exports = { typeDefs, resolvers } to export both.

Practice

1. What is the main purpose of using extensions in GraphQL error responses?

easy

A. To change the data returned by the query

B. To hide errors from the client

C. To speed up the query execution

D. To provide extra information like error codes and details

Solution

1. Step 1: Understand the role of error extensions

   Extensions add extra info to errors, such as codes or metadata.

2. Step 2: Compare with other options

   Extensions do not change data, speed, or hide errors; they enrich error info.

3. Final Answer:

   To provide extra information like error codes and details -> Option D

4. Quick Check:

   Extensions add info = B [OK]

Hint: Extensions add details to errors, not data or speed [OK]

Common Mistakes:

• Thinking extensions change query data
• Assuming extensions hide errors
• Confusing extensions with performance tools

2. Which of the following is the correct way to add a custom error extension in a GraphQL error object?

easy

A. { message: 'Error', extensions: ['BAD_REQUEST'] }

B. { message: 'Error', code: 'BAD_REQUEST' }

C. { message: 'Error', extensions: { code: 'BAD_REQUEST' } }

D. { error: 'Error', extensions: 'BAD_REQUEST' }

Solution

1. Step 1: Identify correct error object structure

   The error object must have a message and an extensions object with code inside.

2. Step 2: Check each option's syntax

   { message: 'Error', extensions: { code: 'BAD_REQUEST' } } correctly nests code inside extensions; others misuse or misplace fields.

3. Final Answer:

   { message: 'Error', extensions: { code: 'BAD_REQUEST' } } -> Option C

4. Quick Check:

   Extensions is an object with code = D [OK]

Hint: Extensions must be an object with keys like code [OK]

Common Mistakes:

• Putting code outside extensions
• Using extensions as a string or array
• Misnaming fields like error instead of message

3. Given this GraphQL error response:

{"errors":[{"message":"Not found","extensions":{"code":"NOT_FOUND","timestamp":"2024-06-01T12:00:00Z"}}]}

What will the client see in the extensions field?

medium

A. {"code":"NOT_FOUND","timestamp":"2024-06-01T12:00:00Z"}

B. "Not found"

C. {"message":"Not found"}

D. An empty object {}

Solution

1. Step 1: Locate the extensions field in the error

   The extensions field contains code and timestamp as key-value pairs.

2. Step 2: Understand what client receives

   The client sees the extensions object exactly as given, with code and timestamp.

3. Final Answer:

   {"code":"NOT_FOUND","timestamp":"2024-06-01T12:00:00Z"} -> Option A

4. Quick Check:

   Extensions content = A [OK]

Hint: Extensions field shows all custom error details as object [OK]

Common Mistakes:

• Confusing message with extensions
• Expecting extensions to be a string
• Ignoring extra fields like timestamp

4. You wrote this error response in your GraphQL server:

{ message: 'Unauthorized', extensions: 'AUTH_ERROR' }

Why does this cause a problem?

medium

A. Extensions must be an object, not a string

B. Message cannot be 'Unauthorized'

C. Extensions field is missing

D. The error object must not have extensions

Solution

1. Step 1: Check the type of extensions field

   Extensions must be an object with key-value pairs, not a string.

2. Step 2: Identify the error cause

   Using a string for extensions causes syntax or runtime errors in GraphQL.

3. Final Answer:

   Extensions must be an object, not a string -> Option A

4. Quick Check:

   Extensions type error = A [OK]

Hint: Extensions must always be an object, never a string [OK]

Common Mistakes:

• Using string instead of object for extensions
• Ignoring GraphQL error format rules
• Assuming message content causes error

5. You want to send a GraphQL error with a custom extension that includes an error code and a retry flag set to false. Which of these error objects correctly implements this?

hard

A. { message: 'Timeout', extensions: { code: 'TIMEOUT', retry: 0 } }

B. { message: 'Timeout', extensions: { code: 'TIMEOUT', retry: false } }

C. { message: 'Timeout', extensions: { code: 'TIMEOUT', retry: 'no' } }

D. { message: 'Timeout', extensions: { code: 'TIMEOUT', retry: null } }

Solution

1. Step 1: Check the data types for extensions fields

   The retry flag should be a boolean false, not string or null or number.

2. Step 2: Validate each option's retry value

   { message: 'Timeout', extensions: { code: 'TIMEOUT', retry: false } } uses boolean false correctly; others use wrong types.

3. Final Answer:

   { message: 'Timeout', extensions: { code: 'TIMEOUT', retry: false } } -> Option B

4. Quick Check:

   Boolean retry flag = C [OK]

Hint: Use boolean false for retry, not string or null [OK]

Common Mistakes:

• Using string 'no' instead of boolean false
• Using null or 0 for boolean flags
• Ignoring correct data types in extensions