How to fix Firestore: Transactions fail when client is offline in Firebase

// JavaScript/Web
import { collection, query, onSnapshot, runTransaction, disableNetwork, enableNetwork } from "firebase/firestore";

const db = getFirestore();

// Check if currently online
firebase.firestore().disableNetwork().then(() => {
  // Network is disabled (offline mode)
}).catch(() => {
  // Network is enabled (online mode)
});

// Android
import com.google.firebase.firestore.ktx.firestore
import kotlinx.coroutines.*

val db = Firebase.firestore

db.disableNetwork()
  .addOnSuccessListener {
    // Offline mode enabled
  }
  .addOnFailureListener { e ->
    // Network is already disabled or error occurred
  }

if (navigator.onLine) {
  // Safe to run transaction
  await db.runTransaction(async (transaction) => {
    // Your transaction code
  });
} else {
  console.warn("Cannot run transaction: client is offline");
  // Handle offline case
}

// This works offline and queues until reconnection
const batch = db.batch();

const ref1 = db.collection("users").doc("user1");
batch.set(ref1, { name: "Alice", updated: new Date() });

const ref2 = db.collection("users").doc("user2");
batch.update(ref2, { status: "active" });

const ref3 = db.collection("logs").doc("log1");
batch.delete(ref3);

await batch.commit(); // Will queue if offline

// Instead of: transaction reads user.profileId, then updates profile
   // Store: user document includes denormalized profile fields
   {
     userId: "123",
     profileName: "Alice",  // Denormalized copy
     profilePhoto: "url"    // Denormalized copy
   }

// Generate ID first
   const postId = uuidv4();

   // Write without reading
   await db.collection("posts").doc(postId).set({
     id: postId,
     title: "My post",
     authorId: currentUser.uid,
     timestamp: serverTimestamp()
   });

try {
  await db.runTransaction(async (transaction) => {
    const userRef = db.collection("users").doc("user123");
    const userData = await transaction.get(userRef);

    if (!userData.exists) {
      throw new Error("User not found");
    }

    const newBalance = userData.data().balance - 100;
    transaction.update(userRef, { balance: newBalance });
  });

  console.log("Transaction succeeded");
} catch (error) {
  if (error.code === "UNAVAILABLE") {
    console.error("Transaction failed: client is offline or server unavailable");
    // Show user-friendly message
    // Retry when connection restored
  } else if (error.code === "FAILED_PRECONDITION") {
    console.error("Transaction precondition failed");
  } else {
    console.error("Transaction failed:", error);
  }
}

// Android Kotlin
try {
  db.runTransaction { transaction ->
    val userRef = db.collection("users").document("user123")
    val userData = transaction.get(userRef)

    val balance = userData.getLong("balance") ?: 0L
    transaction.update(userRef, "balance", balance - 100)
  }.addOnSuccessListener {
    Log.d(TAG, "Transaction succeeded")
  }.addOnFailureListener { e ->
    when {
      e.code == FirebaseFirestoreException.Code.UNAVAILABLE -> {
        Log.e(TAG, "Offline or server unavailable")
      }
      else -> Log.e(TAG, "Transaction failed", e)
    }
  }
} catch (e: Exception) {
  Log.e(TAG, "Error", e)
}

// Web - Enable offline persistence
import { initializeFirestore, enableIndexedDbPersistence } from "firebase/firestore";

const db = initializeFirestore(app, {
  // config options
});

enableIndexedDbPersistence(db)
  .catch((err) => {
    if (err.code == "failed-precondition") {
      console.error("Multiple tabs open - persistence disabled");
    } else if (err.code == "unimplemented") {
      console.error("Browser doesn't support persistence");
    }
  });