Introduction

Firebase Firestore is a powerful NoSQL database that scales effortlessly, making it a great choice for building real-time applications. However, as your user base grows, managing concurrency becomes essential to avoid data inconsistencies and ensure a smooth user experience. This blog post will explore various techniques to handle concurrent users in Firestore.

Optimistic Concurrency Control

Optimistic concurrency control (OCC) is a popular strategy for handling concurrent operations. It assumes that conflicts are rare and handles them when they occur. In Firestore, you can use the update() method with a conditional operator to implement OCC:

      
        const docRef = db.collection('users').doc('user1');
        docRef.update({
          points: FieldValue.increment(1),
        }, {
          // Conditional: Only update if the current value of 'points' is 10.
          precondition: FieldValue.exists('points') && FieldValue.isEqualTo(10)
        })
        .then(() => {
          console.log("Points updated successfully");
        })
        .catch((error) => {
          console.error("Error updating points: ", error);
        });
      
    

If the condition fails (e.g., the value of 'points' has been changed since you last read it), the update will be rejected. You can then re-read the document and attempt the update again with the updated data.

Transactions

For more complex operations requiring multiple writes to be performed atomically, Firestore provides transactions. Transactions ensure that a sequence of write operations is completed as a single unit. If any operation within the transaction fails, all changes are rolled back.

      
        db.runTransaction(async (transaction) => {
          // Read data from Firestore.
          const userRef = db.collection('users').doc('user1');
          const userDoc = await transaction.get(userRef);
          const currentPoints = userDoc.data().points || 0;

          // Update data within the transaction.
          transaction.update(userRef, {
            points: currentPoints + 1,
          });

          // ... Additional writes within the transaction ...
        })
        .then(() => {
          console.log("Transaction successful!");
        })
        .catch((error) => {
          console.error("Transaction failed: ", error);
        });
      
    

Transactions ensure that data remains consistent even if multiple users attempt to modify the same document simultaneously.

Server-Side Logic

For situations where concurrency issues are complex or require more control, consider using a server-side language like Node.js or Python with Firebase Admin SDK to manage data updates. This allows you to perform complex logic before updating Firestore.

Example (using Node.js and Firebase Admin SDK):

      
        const admin = require('firebase-admin');
        admin.initializeApp();
        const db = admin.firestore();

        exports.updateUserPoints = functions.https.onCall(async (data, context) => {
          // Get user ID and points increment.
          const userId = data.userId;
          const pointsIncrement = data.pointsIncrement;

          // Read the user document.
          const userRef = db.collection('users').doc(userId);
          const userDoc = await userRef.get();

          // Perform custom logic based on user data.
          // ...

          // Update user points.
          await userRef.update({
            points: userDoc.data().points + pointsIncrement
          });

          // ... Additional updates or logic ...
        });
      
    

Server-side logic provides more flexibility and control to handle complex scenarios, especially when you need to enforce business rules or perform calculations before modifying Firestore.