Transaction handling in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens if a transaction is not committed in Node.js with a database client?

Consider a Node.js application using a database client that supports transactions. If you start a transaction but never commit or rollback, what will be the state of the transaction?

Node.js

async function runTransaction(client) {
  await client.query('BEGIN');
  await client.query('INSERT INTO users(name) VALUES($1)', ['Alice']);
  // No COMMIT or ROLLBACK
}

A The transaction remains open and locks the affected rows until the connection closes or a timeout occurs.

B The transaction automatically commits after the last query executes.

C The transaction automatically rolls back after the last query executes.

D The database throws an error immediately after the INSERT query.

💡 Hint

Think about what happens when a transaction is left hanging without a commit or rollback.

If a transaction is started but not committed or rolled back, it stays open. This can cause locks on the affected rows or tables, potentially blocking other operations until the connection closes or a timeout happens.

📝 Syntax

intermediate

Which option correctly uses async/await to handle a transaction in Node.js?

Given a database client with async query support, which code snippet correctly starts a transaction, inserts a row, commits, and handles errors?

A

async function saveUser(client, name) {
  try {
    await client.query('BEGIN');
    await client.query('INSERT INTO users(name) VALUES($1)', [name]);
  } catch (e) {
    await client.query('ROLLBACK');
  }
  await client.query('COMMIT');
}

B

async function saveUser(client, name) {
  await client.query('BEGIN');
  try {
    await client.query('INSERT INTO users(name) VALUES($1)', [name]);
  } catch (e) {
    await client.query('COMMIT');
  }
}

C

async function saveUser(client, name) {
  await client.query('BEGIN');
  try {
    await client.query('INSERT INTO users(name) VALUES($1)', [name]);
    await client.query('COMMIT');
  } catch (e) {
    await client.query('ROLLBACK');
    throw e;
  }
}

D

async function saveUser(client, name) {
  await client.query('BEGIN');
  await client.query('INSERT INTO users(name) VALUES($1)', [name]);
  await client.query('COMMIT');
  await client.query('ROLLBACK');
}

💡 Hint

Remember to commit only if no error occurs, and rollback on error.

Option C correctly wraps the transaction in a try/catch block. It commits if all queries succeed, and rolls back if any error occurs, then rethrows the error.

🔧 Debug

advanced

Why does this transaction code cause a deadlock?

Examine the following code snippet. Why might it cause a deadlock when multiple instances run concurrently?

Node.js

async function transferFunds(client, fromId, toId, amount) {
  await client.query('BEGIN');
  await client.query('UPDATE accounts SET balance = balance - $1 WHERE id = $2', [amount, fromId]);
  await client.query('UPDATE accounts SET balance = balance + $1 WHERE id = $2', [amount, toId]);
  await client.query('COMMIT');
}

A Because the updates on accounts are done in different order by concurrent transactions, causing circular waits.

B Because the transaction does not use explicit locks, so the database deadlocks automatically.

C Because the COMMIT statement is missing, so the transaction never ends.

D Because the amount parameter is not validated, causing invalid balance updates.

💡 Hint

Think about how concurrent transactions lock rows in different orders.

If two transactions update accounts in opposite order (one updates fromId then toId, the other toId then fromId), they can each hold a lock the other needs, causing a deadlock.

❓ state_output

advanced

What is the final balance after this transaction code runs successfully?

Assume account 1 has balance 100, account 2 has balance 50. What are their balances after this transaction completes?

Node.js

async function transfer(client) {
  await client.query('BEGIN');
  await client.query('UPDATE accounts SET balance = balance - 30 WHERE id = 1');
  await client.query('UPDATE accounts SET balance = balance + 30 WHERE id = 2');
  await client.query('COMMIT');
}

// Initial balances: account 1 = 100, account 2 = 50

A Account 1: 100, Account 2: 50

B Account 1: 70, Account 2: 50

C Account 1: 130, Account 2: 20

D Account 1: 70, Account 2: 80

💡 Hint

Subtract 30 from account 1 and add 30 to account 2.

The transaction deducts 30 from account 1 (100 - 30 = 70) and adds 30 to account 2 (50 + 30 = 80). The commit makes these changes permanent.

🧠 Conceptual

expert

Which statement best describes the ACID property 'Isolation' in database transactions?

Choose the statement that best explains the 'Isolation' property of transactions.

A Isolation guarantees that once a transaction commits, its changes are permanent even if the system crashes.

B Isolation ensures that transactions appear to run sequentially, preventing concurrent transactions from interfering with each other.

C Isolation means that all operations within a transaction are completed successfully or none at all.

D Isolation allows multiple transactions to share the same data without any locking.

💡 Hint

Think about how transactions behave when running at the same time.

Isolation means each transaction runs as if it were alone, so concurrent transactions do not see partial changes from others, preventing interference.