Alright, let's dive in! Firestore transactions use something called optimistic concurrency control to keep your data consistent. Basically, it reads the data first, caches it locally, and then applies all the operations in one go. If another transaction changes the same document during this time, you'll hit a conflict.

Transactions are like an all-or-nothing deal. Either all the reads and writes succeed, or none of them do. Use them when you need to keep your data consistent.

Example:

const firestore = firebase.firestore();
firestore.runTransaction(async (transaction) => {
  const docRef = firestore.collection('YOUR_COLLECTION').doc('YOUR_DOCUMENT');
  const doc = await transaction.get(docRef);

  if (!doc.exists) {
    throw 'Document does not exist!';
  }
  
  const newValue = doc.data().yourField + 1;
  transaction.update(docRef, { yourField: newValue });
});

Batched writes let you bundle multiple write operations into a single request. All the operations in the batch either succeed or fail together. But keep in mind, batched writes can't read documents or detect conflicts on their own.

Example:

const firestore = firebase.firestore();
const batch = firestore.batch();

const docRef = firestore.collection('YOUR_COLLECTION').doc('YOUR_DOCUMENT');

// Set data in the docRef
batch.set(docRef, { yourField: 'newValue' });

batch.commit().then(() => {
  console.log('Batch committed successfully');
}).catch((error) => {
  console.error('Batch failed: ', error);
});

When transactions fail, you need to handle them with retries because other transactions might be changing the data at the same time.

Example with retries:

async function executeTransaction() {
  try {
    await firestore.runTransaction(async (transaction) => {
      const docRef = firestore.collection('YOUR_COLLECTION').doc('YOUR_DOCUMENT');
      const doc = await transaction.get(docRef);
      // Your update logic here
      const newValue = doc.data().yourField + 1;
      transaction.update(docRef, { yourField: newValue });
    });
    console.log('Transaction successfully committed');
  } catch (error) {
    console.log('Transaction failed, retrying...', error);
    // Retry the transaction
    return executeTransaction();
  }
}

executeTransaction();

When you're reading documents for transactions, be careful about reading too many at once. It can increase the chance of conflicts.

Example of reading a document snapshot:

const docRef = firestore.collection('YOUR_COLLECTION').doc('YOUR_DOCUMENT');

docRef.get().then((doc) => {
  if (doc.exists) {
    console.log('Document data:', doc.data());
  } else {
    console.log('No such document!');
  }
}).catch((error) => {
  console.log('Error getting document:', error);
});

You gotta handle Firestore transaction errors to manage conflicts and other issues smoothly.

Example:

try {
  await firestore.runTransaction(async (transaction) => {
    const docRef = firestore.collection('YOUR_COLLECTION').doc('YOUR_DOCUMENT');
    const doc = await transaction.get(docRef);
    // Perform update
    const newValue = doc.data().yourField + 1;
    transaction.update(docRef, { yourField: newValue });
  });
  console.log('Transaction successfully committed');
} catch (error) {
  console.error('Transaction failed:', error);
  // Optional: retry or handle error specifically
}

For those tricky cases, you can use custom conflict resolution logic to keep your data consistent based on your specific business rules.

Example:

firestore.runTransaction(async (transaction) => {
  const docRef1 = firestore.collection('YOUR_COLLECTION').doc('DOC1');
  const docRef2 = firestore.collection('YOUR_COLLECTION').doc('DOC2');
  
  const doc1 = await transaction.get(docRef1);
  const doc2 = await transaction.get(docRef2);

  if (doc1.exists && doc2.exists) {
    const total = doc1.data().yourField + doc2.data().yourField;
    transaction.update(docRef1, { yourField: total });
    transaction.delete(docRef2);
  }
}).then(() => {
  console.log('Custom conflict resolution applied successfully');
}).catch((error) => {
  console.error('Transaction failed:', error);
});