How to fix Firestore: Transaction exceeded 10 MiB request size limit in Firebase

// Before: Too many documents
const batch = writeBatch(db);
for (let i = 0; i < 500; i++) {
  const docRef = doc(db, 'users', `user${i}`);
  batch.set(docRef, largeDataObject);
}
await batch.commit(); // May exceed 10 MiB

// After: Smaller batches
const BATCH_SIZE = 100; // Adjust based on document size
for (let i = 0; i < 500; i += BATCH_SIZE) {
  const batch = writeBatch(db);
  for (let j = i; j < Math.min(i + BATCH_SIZE, 500); j++) {
    const docRef = doc(db, 'users', `user${j}`);
    batch.set(docRef, largeDataObject);
  }
  await batch.commit();
}

import { getFirestore } from 'firebase-admin/firestore';

function estimateDocumentSize(data: any): number {
  // Rough estimation (actual size includes indexes and metadata)
  const jsonSize = JSON.stringify(data).length;
  const indexOverhead = Object.keys(data).length * 100; // Approximate
  return jsonSize + indexOverhead;
}

const MAX_TRANSACTION_SIZE = 10 * 1024 * 1024; // 10 MiB in bytes
const SAFETY_MARGIN = 0.8; // Use 80% of limit to be safe

async function smartBatch(documents: any[]) {
  let currentBatch = writeBatch(db);
  let currentSize = 0;
  let batchCount = 0;

  for (const docData of documents) {
    const docSize = estimateDocumentSize(docData);

    if (currentSize + docSize > MAX_TRANSACTION_SIZE * SAFETY_MARGIN) {
      // Commit current batch and start new one
      await currentBatch.commit();
      console.log(`Committed batch ${++batchCount}`);
      currentBatch = writeBatch(db);
      currentSize = 0;
    }

    const docRef = doc(db, 'collection', docData.id);
    currentBatch.set(docRef, docData);
    currentSize += docSize;
  }

  // Commit final batch
  if (currentSize > 0) {
    await currentBatch.commit();
    console.log(`Committed final batch ${++batchCount}`);
  }
}

import { setDoc, doc } from 'firebase/firestore';

async function parallelWriteWithLimit(
  documents: any[],
  concurrency: number = 50
) {
  const chunks = [];
  for (let i = 0; i < documents.length; i += concurrency) {
    chunks.push(documents.slice(i, i + concurrency));
  }

  for (const chunk of chunks) {
    await Promise.all(
      chunk.map(async (docData) => {
        const docRef = doc(db, 'collection', docData.id);
        return setDoc(docRef, docData);
      })
    );
    console.log(`Processed ${chunk.length} documents`);
  }
}

// Usage
await parallelWriteWithLimit(largeDataset, 50);

{
  "indexes": [
    {
      "collectionGroup": "users",
      "queryScope": "COLLECTION",
      "fields": [
        { "fieldPath": "status", "order": "ASCENDING" },
        { "fieldPath": "createdAt", "order": "DESCENDING" }
      ]
    }
  ]
}

// Before: One large document
const userDoc = {
  id: 'user123',
  profile: { /* large object */ },
  preferences: { /* large object */ },
  activityLog: [ /* hundreds of entries */ ],
  metadata: { /* more data */ }
};

// After: Main document + subcollections
const userDoc = {
  id: 'user123',
  // Only essential fields in main document
};

// Split into subcollections
await setDoc(doc(db, 'users', 'user123'), userDoc);
await setDoc(doc(db, 'users/user123/details/profile'), profileData);
await setDoc(doc(db, 'users/user123/details/preferences'), preferencesData);

// Activity log as separate documents
for (const activity of activityLog) {
  await addDoc(collection(db, 'users/user123/activity'), activity);
}