How to fix messaging/topics-message-rate-exceeded: Topic subscribers receiving excessive messages in Firebase

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

async function sendToTopicWithRetry(message, topic, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await admin.messaging().sendToTopic(topic, message);
      console.log('Successfully sent message:', response);
      return response;
    } catch (error) {
      if (error.code === 'messaging/topics-message-rate-exceeded') {
        const waitTime = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
        console.log(`Rate limit hit, waiting ${waitTime}ms before retry...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
      } else {
        throw error; // Re-throw non-rate-limit errors
      }
    }
  }
  throw new Error('Max retries exceeded for topic message');
}

class TopicMessageQueue {
  constructor(maxConcurrent = 100) {
    this.maxConcurrent = maxConcurrent;
    this.activeRequests = 0;
    this.queue = [];
  }

  async send(topic, message) {
    // Wait if at capacity
    while (this.activeRequests >= this.maxConcurrent) {
      await new Promise(resolve => setTimeout(resolve, 100));
    }

    this.activeRequests++;
    try {
      const result = await admin.messaging().sendToTopic(topic, message);
      return result;
    } finally {
      this.activeRequests--;
      this.processQueue();
    }
  }

  processQueue() {
    if (this.queue.length > 0 && this.activeRequests < this.maxConcurrent) {
      const next = this.queue.shift();
      next();
    }
  }
}

// Usage
const messageQueue = new TopicMessageQueue(100);
await messageQueue.send('news-updates', {
  notification: { title: 'Breaking News', body: 'Story text' }
});

class MessageBatcher {
  constructor(topic, batchInterval = 5000) {
    this.topic = topic;
    this.batchInterval = batchInterval;
    this.pendingMessages = [];
    this.timer = null;
  }

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

    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 single message with batched data
    await admin.messaging().sendToTopic(this.topic, {
      data: {
        updates: JSON.stringify(batch),
        count: batch.length.toString()
      }
    });
  }
}

// Usage: Send one message every 5 seconds instead of hundreds
const batcher = new MessageBatcher('stock-updates', 5000);
batcher.addMessage({ symbol: 'AAPL', price: 150.25 });
batcher.addMessage({ symbol: 'GOOGL', price: 2800.50 });

// Instead of creating a topic for a small group
// BAD: Topic for 50 users
await admin.messaging().sendToTopic('team-alpha-notifications', message);

// GOOD: Direct send to device tokens
const deviceTokens = [
  'token1...', 'token2...', 'token3...' // Up to 500 tokens per batch
];

await admin.messaging().sendMulticast({
  tokens: deviceTokens,
  notification: {
    title: 'Team Update',
    body: 'New task assigned'
  }
});

// Split a massive global topic into regional topics
// Instead of: 'all-users' (5 million subscribers)
// Use: 'users-north-america', 'users-europe', 'users-asia'

async function sendToRegionalTopics(message) {
  const regions = ['north-america', 'europe', 'asia', 'latam'];

  for (const region of regions) {
    await sendToTopicWithRetry(message, `users-${region}`);
    // Add small delay between regions
    await new Promise(resolve => setTimeout(resolve, 500));
  }
}