How would you ensure atomicity across multiple object stores in a single transaction?

Question

ICSM Computer · Answer

In IndexedDB, you can ensure atomicity across multiple object stores by using a
single transaction that spans all the stores you want to access or modify.
What Is Atomicity in IndexedDB?
Atomicity means:
All operations within a transaction either succeed together or
fail together — the database is never left in a partial state.
How to Ensure Atomic Operations Across Multiple Stores
Step-by-Step:
const db = await openIndexedDB(); // Assume this opens your DB
const tx = db.transaction(["users", "notes"], "readwrite");
const userStore = tx.objectStore("users");
const noteStore = tx.objectStore("notes");
// Add a user
userStore.put({ id: "u1", name: "Alice" });
// Add a note for that user
noteStore.put({ id: "n1", userId: "u1", content: "My note" });
// Commit is automatic if no error occurs
tx.oncomplete = () =andgt; {
    console.log("Transaction committed successfully.");
};
tx.onerror = () =andgt; {
    console.error("Transaction failed and was rolled back:", tx.error);
};
If any operation inside the transaction fails, all changes are rolled back automatically.
Key Rules for Atomic Transactions
Rule
Explanation
Use the same transaction
All operations must be within the same IDBTransaction instance
Use readwrite mode
Required if you're writing to the stores
Add all needed stores in one go
transaction(["users", "notes"]) — you cannot add stores after
Don’t do async delays inside it
IndexedDB transactions auto-close if you yield to the event loop
Pitfall: No await or setTimeout Inside Transactions
const tx = db.transaction(["users", "notes"], "readwrite");
// Don't do this
await fetch("/something");
noteStore.put(...); // Will throw TransactionInactiveError
Transactions auto-close as soon as the JavaScript thread yields.
✅ Instead, prepare all async data before starting the transaction.
Good Pattern with Error Handling
try {
    const tx = db.transaction(["users", "notes"], "readwrite");
    const userStore = tx.objectStore("users");
    const noteStore = tx.objectStore("notes");
    userStore.put({ id: "u1", name: "Alice" });
    noteStore.put({ id: "n1", userId: "u1", content: "Hello!" });
    await new Promise((resolve, reject) =andgt; {
        tx.oncomplete = resolve;
        tx.onerror = () =andgt; reject(tx.error);
        tx.onabort = () =andgt; reject(tx.error);
    });
    console.log("Transaction successful.");
} catch (err) {
    console.error("Transaction failed:", err);
}
Summary
Tip
Why it Matters
Use a single transaction([...]) call
Ensures atomicity across object stores
Use readwrite mode
Required for writes
No async gaps inside transaction
Prevents auto-close issues
Use .oncomplete, .onerror, .onabort
Detect and respond to success/failure

interview

How would you ensure atomicity across multiple object stores in a single transaction?

ICSM Computer

Can you answer this question?

1 Answers

What Is Atomicity in IndexedDB?

How to Ensure Atomic Operations Across Multiple Stores

Step-by-Step:

Key Rules for Atomic Transactions

Pitfall: No `await` or `setTimeout` Inside Transactions

Good Pattern with Error Handling

Summary

Liked By

Rule	Explanation
Use the same transaction	All operations must be within the same `IDBTransaction` instance
Use `readwrite` mode	Required if you're writing to the stores
Add all needed stores in one go	`transaction(["users", "notes"])` — you cannot add stores after
Don’t do async delays inside it	IndexedDB transactions auto-close if you yield to the event loop

Tip	Why it Matters
Use a single `transaction([...])` call	Ensures atomicity across object stores
Use `readwrite` mode	Required for writes
No async gaps inside transaction	Prevents auto-close issues
Use `.oncomplete`, `.onerror`, `.onabort`	Detect and respond to success/failure