Transaction handling in GraphQL - Mini Project: Build & Apply

Transaction Handling in GraphQL

📖 Scenario: You are building a simple GraphQL API for a bookstore. Customers can place orders for books. To keep data safe, you need to handle transactions so that either the entire order is saved or nothing is saved if something goes wrong.

🎯 Goal: Build a GraphQL mutation that handles a transaction to add a new order with multiple books. The transaction should ensure all books are added to the order or none at all if an error occurs.

📋 What You'll Learn

Create a GraphQL type Order with fields id and books (list of strings).

Create a mutation createOrder that accepts a list of book titles.

Use a transaction to add the order and books atomically.

Rollback the transaction if any book title is empty.

💡 Why This Matters

🌍 Real World

Transaction handling is crucial in real-world applications like e-commerce to keep data consistent and avoid partial updates.

💼 Career

Understanding how to implement transactions in GraphQL APIs is important for backend developers working with databases and APIs.

1

Define the Order type

Create a GraphQL type called Order with fields id of type ID! and books which is a list of non-nullable String!.

GraphQL

# Define the Order type here

Hint

Use type Order { id: ID! books: [String!]! } syntax.

2

Add createOrder mutation signature

Add a mutation called createOrder that takes an argument bookTitles which is a list of non-nullable String! and returns an Order.

GraphQL

type Order {
  id: ID!
  books: [String!]!
}

# Add createOrder mutation signature here

Hint

Mutations are defined inside type Mutation { ... }.

3

Implement transaction logic in resolver

In the resolver for createOrder, start a transaction, check that no book title is empty, add the order with books, and commit the transaction. If any book title is empty, rollback the transaction.

GraphQL

type Order {
  id: ID!
  books: [String!]!
}

type Mutation {
  createOrder(bookTitles: [String!]!): Order
}

const resolvers = {
  Mutation: {
    createOrder: async (_, { bookTitles }, { db }) => {
      // Start transaction
      // Check for empty titles
      // Add order and books
      // Commit or rollback
    }
  }
};

Hint

Use try...catch with transaction.commit() and transaction.rollback().

4

Complete the GraphQL schema export

Export the GraphQL schema including the Order type and Mutation type with createOrder mutation.

GraphQL

type Order {
  id: ID!
  books: [String!]!
}

type Mutation {
  createOrder(bookTitles: [String!]!): Order
}

const resolvers = {
  Mutation: {
    createOrder: async (_, { bookTitles }, { db }) => {
      const transaction = await db.transaction();
      try {
        if (bookTitles.some(title => title === "")) {
          throw new Error("Book title cannot be empty");
        }
        const order = await db.orders.create({ books: bookTitles }, { transaction });
        await transaction.commit();
        return order;
      } catch (error) {
        await transaction.rollback();
        throw error;
      }
    }
  }
};

# Export schema here

Hint

Export typeDefs and resolvers for your GraphQL server.