Transaction handling in GraphQL - Step-by-Step Execution

Concept Flow - Transaction handling

Start Transaction

↓

Execute Queries

↓

Check for Errors?

Yes→Rollback Transaction

↓

End Transaction

↓

Commit Transaction

This flow shows how a transaction starts, runs queries, checks for errors, and either commits or rolls back.

Execution Sample

GraphQL

mutation {
  startTransaction
  updateUser(id: 1, name: "Alice")
  updateBalance(userId: 1, amount: 100)
  commitTransaction
}

This GraphQL mutation starts a transaction, updates user data and balance, then commits the transaction.

Execution Table

Step	Action	Result	Transaction State
1	startTransaction	Transaction started	Active
2	updateUser(id:1, name:"Alice")	User updated	Active
3	updateBalance(userId:1, amount:100)	Balance updated	Active
4	commitTransaction	Transaction committed	Committed
5	End	No more actions	Ended

💡 Transaction ends after commit; all changes saved.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
Transaction State	None	Active	Active	Active	Committed	Ended
User Name	OldName	OldName	Alice	Alice	Alice	Alice
User Balance	OldBalance	OldBalance	OldBalance	OldBalance + 100	OldBalance + 100	OldBalance + 100

Key Moments - 3 Insights

Why do we need to start a transaction before updating data?

Starting a transaction groups multiple changes so they all succeed or fail together, as shown in steps 1-4 in the execution_table.

What happens if an error occurs during updateBalance?

If an error occurs, the transaction should rollback to undo all changes, preventing partial updates. This is the 'Rollback Transaction' path in the concept_flow.

Why commit the transaction at the end?

Committing saves all changes permanently. Without commit, changes remain temporary and can be lost, as shown in step 4 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the Transaction State after step 3?

A Active

B Committed

C Ended

D None

💡 Hint

Check the 'Transaction State' column for step 3 in the execution_table.

At which step does the transaction get committed?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for 'commitTransaction' action in the execution_table.

If an error occurs at step 3, what should happen next?

A Commit the transaction

B Rollback the transaction

C Ignore the error and continue

D Start a new transaction

💡 Hint

Refer to the concept_flow where errors lead to rollback.

Concept Snapshot

Transaction handling groups multiple database operations.
Start a transaction before changes.
If all succeed, commit to save.
If any fail, rollback to undo.
Ensures data stays consistent.

Full Transcript

Transaction handling in GraphQL involves starting a transaction, performing multiple updates, and then either committing or rolling back based on success or failure. The process begins with startTransaction, followed by executing queries like updateUser and updateBalance. If all queries succeed, commitTransaction saves the changes permanently. If any query fails, rollbackTransaction undoes all changes to keep data consistent. This ensures that partial updates do not corrupt the database. The execution table shows each step and the transaction state changes from Active to Committed. Key moments include understanding why transactions start, what happens on errors, and why committing is necessary. The visual quiz tests understanding of transaction states and error handling.

Practice

1. What is the main purpose of using transactions in a database when working with GraphQL?

easy

A. To group multiple actions so they all succeed or fail together

B. To speed up query execution by caching results

C. To automatically generate GraphQL schemas

D. To encrypt data sent over the network

Solution

1. Step 1: Understand what transactions do

   Transactions ensure that a set of database operations are treated as a single unit.

2. Step 2: Identify the purpose in GraphQL context

   This means either all changes succeed or none do, keeping data consistent.

3. Final Answer:

   To group multiple actions so they all succeed or fail together -> Option A

4. Quick Check:

   Transactions = atomic group actions [OK]

Hint: Transactions keep multiple changes safe together [OK]

Common Mistakes:

• Thinking transactions speed up queries
• Confusing transactions with schema generation
• Assuming transactions encrypt data

2. Which of the following is the correct way to start a transaction in a GraphQL resolver using a typical backend?

easy

A. const transaction = await db.rollback();

B. const transaction = db.commit();

C. const transaction = await db.startTransaction();

D. const transaction = db.query('BEGIN');

Solution

1. Step 1: Identify how to start a transaction

   Starting a transaction usually involves calling a method like startTransaction() asynchronously.

2. Step 2: Check options for correctness

   const transaction = await db.startTransaction(); correctly uses await and startTransaction(), while others are commit, rollback, or raw query.

3. Final Answer:

   const transaction = await db.startTransaction(); -> Option C

4. Quick Check:

   Start transaction = startTransaction() [OK]

Hint: Start transactions with async startTransaction() method [OK]

Common Mistakes:

• Using commit or rollback to start a transaction
• Using raw query strings instead of methods
• Missing await for async calls

3. Given this GraphQL resolver snippet, what will be the output if an error occurs during updateUser()?

async function updateProfile(parent, args, context) {
  const trx = await context.db.startTransaction();
  try {
    await trx.updateUser(args.userId, args.data);
    await trx.commit();
    return 'Success';
  } catch (e) {
    await trx.rollback();
    return 'Failed';
  }
}

medium

A. 'Success'

B. 'Failed'

C. Throws an unhandled exception

D. Returns null

Solution

1. Step 1: Analyze the try block

   The code tries to update the user and commit the transaction.

2. Step 2: Understand error handling

   If updateUser throws an error, the catch block rolls back and returns 'Failed'.

3. Final Answer:

   'Failed' -> Option B

4. Quick Check:

   Error during update = rollback + 'Failed' [OK]

Hint: Errors trigger rollback and return 'Failed' [OK]

Common Mistakes:

• Assuming commit runs even on error
• Expecting unhandled exceptions instead of catch
• Thinking it returns 'Success' always

4. Identify the error in this GraphQL resolver transaction handling code:

async function saveOrder(parent, args, context) {
  const trx = context.db.startTransaction();
  try {
    await trx.insertOrder(args.order);
    await trx.commit();
    return 'Order saved';
  } catch (error) {
    await trx.rollback();
    return 'Error saving order';
  }
}

medium

A. Missing await before startTransaction()

B. No rollback in catch block

C. commit() should be called before insertOrder()

D. Returning string instead of object

Solution

1. Step 1: Check transaction start syntax

   startTransaction() is asynchronous and must be awaited.

2. Step 2: Identify missing await impact

   Without await, trx is a Promise, causing errors on trx.insertOrder().

3. Final Answer:

   Missing await before startTransaction() -> Option A

4. Quick Check:

   Async startTransaction() needs await [OK]

Hint: Always await async transaction start calls [OK]

Common Mistakes:

• Forgetting await on async calls
• Calling commit before operations
• Ignoring rollback on errors

5. You want to update a user's profile and their related settings in one transaction using GraphQL. Which approach ensures both updates succeed or fail together?

async function updateUserAndSettings(parent, args, context) {
  const trx = await context.db.startTransaction();
  try {
    await trx.updateUser(args.userId, args.userData);
    await trx.updateSettings(args.userId, args.settingsData);
    await trx.commit();
    return 'Update successful';
  } catch (error) {
    await trx.rollback();
    return 'Update failed';
  }
}

hard

A. Use separate transactions for user and settings updates

B. Do not use transactions for related updates

C. Commit after each update separately

D. Wrap both updates in a single transaction as shown

Solution

1. Step 1: Understand transaction grouping

   Both updates must be inside one transaction to succeed or fail together.

2. Step 2: Analyze the code approach

   The code wraps both updates in one transaction, committing only if both succeed.

3. Final Answer:

   Wrap both updates in a single transaction as shown -> Option D

4. Quick Check:

   Single transaction = atomic multi-update [OK]

Hint: Group related updates in one transaction [OK]

Common Mistakes:

• Using separate transactions causing partial updates
• Committing too early after first update
• Skipping transactions for multi-step changes