How to fix aborted in Firebase

async function retryWithBackoff(operation, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      if (error.code === 'aborted' && attempt < maxRetries - 1) {
        // Exponential backoff: 1s, 2s, 4s, 8s
        const delayMs = Math.pow(2, attempt) * 1000;
        console.log(`Retrying after ${delayMs}ms...`);
        await new Promise(resolve => setTimeout(resolve, delayMs));
      } else {
        throw error;
      }
    }
  }
}

// Usage
const result = await retryWithBackoff(async () => {
  return await db.collection('users').doc('user1').update({
    lastUpdated: admin.firestore.FieldValue.serverTimestamp()
  });
});

// ❌ BAD - All users write to same document, creating contention
async function addScore(userId, points) {
  await db.collection('leaderboard').doc('global-scores').update({
    totalPoints: admin.firestore.FieldValue.increment(points),
    playerCount: admin.firestore.FieldValue.increment(1)
  });
}

// ✅ GOOD - Distribute writes across sharded documents
const SHARD_COUNT = 10;

async function addScore(userId, points) {
  const shardId = Math.floor(Math.random() * SHARD_COUNT);
  await db.collection('leaderboard-shards').doc(`shard-${shardId}`).update({
    totalPoints: admin.firestore.FieldValue.increment(points),
    updatedAt: admin.firestore.FieldValue.serverTimestamp()
  });
}

// Periodically consolidate shards
async function consolidateShards() {
  let totalPoints = 0;
  const shards = await db.collection('leaderboard-shards').get();
  shards.forEach(doc => {
    totalPoints += doc.data().totalPoints;
  });
  await db.collection('leaderboard').doc('global').set({ totalPoints });
}

// ❌ BAD - Single large transaction modifying many documents
async function transferFunds(fromUser, toUser, amount) {
  await db.runTransaction(async (transaction) => {
    const fromDoc = await transaction.get(db.collection('users').doc(fromUser));
    const toDoc = await transaction.get(db.collection('users').doc(toUser));
    const fromBalance = fromDoc.data().balance;
    const toBalance = toDoc.data().balance;

    // Modify 20+ documents in this transaction
    transaction.update(db.collection('users').doc(fromUser), {
      balance: fromBalance - amount,
      lastTransaction: new Date(),
      transactionCount: admin.firestore.FieldValue.increment(1)
    });
    transaction.update(db.collection('users').doc(toUser), {
      balance: toBalance + amount,
      lastDeposit: new Date()
    });
    // ... more updates
  });
}

// ✅ GOOD - Minimal transaction, move logging/analytics elsewhere
async function transferFunds(fromUser, toUser, amount) {
  await db.runTransaction(async (transaction) => {
    const fromRef = db.collection('users').doc(fromUser);
    const toRef = db.collection('users').doc(toUser);

    const fromDoc = await transaction.get(fromRef);
    const toDoc = await transaction.get(toRef);

    transaction.update(fromRef, { balance: fromDoc.data().balance - amount });
    transaction.update(toRef, { balance: toDoc.data().balance + amount });
  });

  // Log to separate collection outside transaction
  await db.collection('transactions').add({
    from: fromUser,
    to: toUser,
    amount: amount,
    timestamp: new Date()
  });
}

// In your firebase.json or function configuration
{
  "functions": {
    "database": {
      "memory": "512MB",
      "maxInstances": 100,           // Increase max concurrent instances
      "minInstances": 10,            // Keep minimum instances warm
      "timeoutSeconds": 60,
      "environmentVariables": {
        "NODE_ENV": "production"
      }
    }
  }
}

// Or deploy with gcloud directly
gcloud functions deploy myFunction \
  --runtime nodejs20 \
  --trigger-http \
  --max-instances 100 \
  --min-instances 10 \
  --memory 512MB

// ❌ HIGH CONTENTION - Multiple transactions on same documents
async function updateMultipleUsers(userIds, updates) {
  for (const userId of userIds) {
    await db.runTransaction(async (transaction) => {
      const userDoc = await transaction.get(db.collection('users').doc(userId));
      transaction.update(db.collection('users').doc(userId), {
        ...updates,
        lastModified: new Date()
      });
    });
  }
}

// ✅ BETTER - Batch write for non-interdependent updates
async function updateMultipleUsers(userIds, updates) {
  const batch = db.batch();

  for (const userId of userIds) {
    batch.update(db.collection('users').doc(userId), {
      ...updates,
      lastModified: new Date()
    });
  }

  await batch.commit();
}

// Log to identify hot-spot documents
function logContention(operation, docPath, duration) {
  if (duration > 500) {
    console.warn(`[CONTENTION] ${operation} on ${docPath} took ${duration}ms`);
  }
}

// Monitor in your Cloud Function
const startTime = Date.now();
try {
  await db.collection('users').doc(userId).update({
    score: admin.firestore.FieldValue.increment(points)
  });
} catch (error) {
  if (error.code === 'aborted') {
    logContention('update', `users/${userId}`, Date.now() - startTime);
  }
}

// Check Firestore logs in Google Cloud Console
// Look for documents with high write rates in the Metrics tab