How to fix messaging/message-rate-exceeded in Firebase

const admin = require('firebase-admin');

async function sendMessageWithRetry(message, options = {}) {
  const maxRetries = options.maxRetries || 3;
  const initialDelay = options.initialDelay || 1000; // Start with 1 second

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await admin.messaging().send(message);
      console.log('Message sent successfully:', response);
      return response;
    } catch (error) {
      if (error.code === 'messaging/message-rate-exceeded' ||
          (error.codePrefix === 'messaging' && error.status === 429)) {
        if (attempt < maxRetries - 1) {
          const waitTime = Math.pow(2, attempt) * initialDelay;
          // Add jitter to prevent thundering herd
          const jitter = Math.random() * 0.1 * waitTime;
          const totalWait = waitTime + jitter;
          console.log(`Rate limited. Retrying in ${Math.round(totalWait)}ms (attempt ${attempt + 1}/${maxRetries})`);
          await new Promise(resolve => setTimeout(resolve, totalWait));
          continue;
        }
      }
      // Non-retryable error or max retries exceeded
      throw error;
    }
  }
  throw new Error('Failed to send message after max retries');
}

// Usage
const message = {
  notification: {
    title: 'Hello',
    body: 'World'
  },
  token: 'device_token_here'
};

await sendMessageWithRetry(message);

class FCMMessageQueue {
  constructor(options = {}) {
    this.messagesPerSecond = options.messagesPerSecond || 100; // Default: 100 msg/sec = 6K/min
    this.maxQueueSize = options.maxQueueSize || 5000;
    this.queue = [];
    this.activeCount = 0;
    this.lastSendTime = 0;
  }

  async enqueue(message) {
    if (this.queue.length >= this.maxQueueSize) {
      throw new Error('Message queue is full');
    }

    return new Promise((resolve, reject) => {
      this.queue.push({ message, resolve, reject });
      this.processQueue();
    });
  }

  async processQueue() {
    if (this.queue.length === 0 || this.activeCount >= this.messagesPerSecond) {
      return;
    }

    const now = Date.now();
    const timeSinceLastSend = now - this.lastSendTime;
    const minInterval = 1000 / this.messagesPerSecond;

    if (timeSinceLastSend < minInterval) {
      const delayNeeded = minInterval - timeSinceLastSend;
      setTimeout(() => this.processQueue(), delayNeeded);
      return;
    }

    const { message, resolve, reject } = this.queue.shift();
    this.activeCount++;
    this.lastSendTime = Date.now();

    try {
      const result = await admin.messaging().send(message);
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      this.activeCount--;
      this.processQueue();
    }
  }
}

// Usage
const messageQueue = new FCMMessageQueue({ messagesPerSecond: 100 });

// Queue 1000 messages - they will be sent at 100/second rate
for (const token of deviceTokens) {
  await messageQueue.enqueue({
    notification: { title: 'Update', body: 'New content available' },
    token
  });
}

class MessageBatcher {
  constructor(options = {}) {
    this.batchInterval = options.batchInterval || 5000; // Batch every 5 seconds
    this.maxBatchSize = options.maxBatchSize || 100;
    this.pendingMessages = [];
    this.timer = null;
  }

  addMessage(message) {
    this.pendingMessages.push(message);

    if (this.pendingMessages.length >= this.maxBatchSize) {
      this.flush();
    } else if (!this.timer) {
      this.timer = setTimeout(() => this.flush(), this.batchInterval);
    }
  }

  async flush() {
    if (this.pendingMessages.length === 0) return;

    const batch = this.pendingMessages.splice(0);
    this.timer = null;

    // Send all messages in batch
    const results = await admin.messaging().sendMulticast({
      tokens: batch.map(m => m.token),
      data: {
        updates: JSON.stringify(batch.map(m => m.data)),
        batchTime: new Date().toISOString()
      },
      notification: {
        title: 'Updates Available',
        body: `${batch.length} updates`
      }
    });

    console.log(`Sent ${results.successCount} messages in batch`);
  }
}

// Usage: Instead of 1000 messages, send 1 message with 1000 tokens
const batcher = new MessageBatcher();
for (const token of deviceTokens) {
  batcher.addMessage({ token, data: { userId: '123' } });
}

// SLOW: 1000 separate API calls
const tokens = ['token1', 'token2', 'token3', ...]; // 1000 tokens
for (const token of tokens) {
  await admin.messaging().send({
    token,
    notification: { title: 'Update', body: 'Available' }
  });
}

// FAST: Fewer API calls, handles batching automatically
const message = {
  notification: { title: 'Update', body: 'Available' }
};

// Process tokens in batches of 500 (FCM limit per call)
const batches = [];
for (let i = 0; i < tokens.length; i += 500) {
  const batchTokens = tokens.slice(i, i + 500);
  batches.push(
    admin.messaging().sendMulticast({
      tokens: batchTokens,
      notification: message
    })
  );
}

const results = await Promise.all(batches);
const totalSuccess = results.reduce((sum, r) => sum + r.successCount, 0);
console.log(`Sent successfully to ${totalSuccess} devices`);