Error handling is a crucial aspect of any application, and GraphQL is no exception. Proper error handling ensures that your GraphQL server can gracefully handle unexpected situations and provide meaningful feedback to clients. In this section, we will cover the following topics:
- Understanding GraphQL Errors
- Standard Error Handling
- Custom Error Handling
- Error Logging
- Practical Exercises
Understanding GraphQL Errors
GraphQL errors are typically returned in a structured format within the errors field of the response. Here is an example of a typical error response:
{
"data": null,
"errors": [
{
"message": "Cannot query field 'unknownField' on type 'Query'.",
"locations": [
{
"line": 2,
"column": 3
}
],
"path": ["query", "unknownField"]
}
]
}Key Components of a GraphQL Error:
- message: A human-readable description of the error.
- locations: An array of locations where the error occurred in the query.
- path: The path to the field that caused the error.
Standard Error Handling
GraphQL provides built-in mechanisms to handle errors. By default, any unhandled exception in a resolver will result in an error being added to the errors array in the response.
Example of a Resolver with Standard Error Handling:
const resolvers = {
Query: {
user: async (parent, args, context, info) => {
try {
const user = await context.db.getUserById(args.id);
if (!user) {
throw new Error('User not found');
}
return user;
} catch (error) {
throw new Error(error.message);
}
}
}
};In this example, if the user is not found, an error is thrown, and GraphQL will automatically include this error in the response.
Custom Error Handling
For more advanced error handling, you can create custom error classes and use them in your resolvers. This allows you to provide more detailed and specific error information.
Example of Custom Error Classes:
class UserNotFoundError extends Error {
constructor(message) {
super(message);
this.name = 'UserNotFoundError';
}
}
class DatabaseError extends Error {
constructor(message) {
super(message);
this.name = 'DatabaseError';
}
}Using Custom Errors in Resolvers:
const resolvers = {
Query: {
user: async (parent, args, context, info) => {
try {
const user = await context.db.getUserById(args.id);
if (!user) {
throw new UserNotFoundError('User not found');
}
return user;
} catch (error) {
if (error instanceof UserNotFoundError) {
throw new Error(error.message);
} else {
throw new DatabaseError('Database error occurred');
}
}
}
}
};Error Logging
Logging errors is essential for monitoring and debugging your application. You can use logging libraries like winston or bunyan to log errors.
Example of Error Logging with Winston:
const winston = require('winston');
const logger = winston.createLogger({
level: 'error',
format: winston.format.json(),
transports: [
new winston.transports.File({ filename: 'error.log' })
]
});
const resolvers = {
Query: {
user: async (parent, args, context, info) => {
try {
const user = await context.db.getUserById(args.id);
if (!user) {
throw new UserNotFoundError('User not found');
}
return user;
} catch (error) {
logger.error(error.message);
throw new Error('An error occurred');
}
}
}
};Practical Exercises
Exercise 1: Basic Error Handling
Task: Modify the following resolver to handle errors when a user is not found.
const resolvers = {
Query: {
user: async (parent, args, context, info) => {
const user = await context.db.getUserById(args.id);
return user;
}
}
};Solution:
const resolvers = {
Query: {
user: async (parent, args, context, info) => {
try {
const user = await context.db.getUserById(args.id);
if (!user) {
throw new Error('User not found');
}
return user;
} catch (error) {
throw new Error(error.message);
}
}
}
};Exercise 2: Custom Error Handling
Task: Create custom error classes for UserNotFoundError and DatabaseError, and use them in the resolver.
Solution:
class UserNotFoundError extends Error {
constructor(message) {
super(message);
this.name = 'UserNotFoundError';
}
}
class DatabaseError extends Error {
constructor(message) {
super(message);
this.name = 'DatabaseError';
}
}
const resolvers = {
Query: {
user: async (parent, args, context, info) => {
try {
const user = await context.db.getUserById(args.id);
if (!user) {
throw new UserNotFoundError('User not found');
}
return user;
} catch (error) {
if (error instanceof UserNotFoundError) {
throw new Error(error.message);
} else {
throw new DatabaseError('Database error occurred');
}
}
}
}
};Conclusion
In this section, we covered the basics of error handling in GraphQL, including standard error handling, custom error handling, and error logging. Proper error handling is essential for building robust and user-friendly GraphQL APIs. In the next module, we will explore performance and security considerations to further enhance your GraphQL server.