How to fix Remote Config: Code 8003 - Most recently fetched config is already activated in Firebase

import { getRemoteConfig, isSupported } from "firebase/remote-config";

// Initialize Remote Config
const remoteConfig = getRemoteConfig();

async function checkAndActivate() {
  // First, check if Remote Config is supported
  if (!await isSupported()) {
    console.warn('Remote Config not supported');
    return;
  }

  try {
    // Fetch the configuration
    await remoteConfig.fetchAndActivate();

    // Or use separate fetch and activate with status checking:
    const fetched = await remoteConfig.fetch();

    // Check if already activated
    if (fetched) {
      // fetched is true if new config was fetched
      const activated = await remoteConfig.activate();
      if (activated) {
        console.log('Configuration activated successfully');
      } else {
        console.log('Configuration was already activated or no new config available');
        // This is NOT an error - it's normal behavior
      }
    }
  } catch (error) {
    if (error.code === 8003) {
      console.log('Configuration already activated - this is expected behavior');
      // Handle gracefully - no need to retry
    } else {
      console.error('Remote Config error:', error);
      throw error;
    }
  }
}

class RemoteConfigManager {
  constructor() {
    this.isActivating = false;
    this.lastActivatedVersion = null;
    this.remoteConfig = getRemoteConfig();
  }

  async activateConfig() {
    // Prevent concurrent activation attempts
    if (this.isActivating) {
      console.log('Activation already in progress');
      return false;
    }

    this.isActivating = true;

    try {
      const fetched = await this.remoteConfig.fetch();

      if (!fetched) {
        console.log('No new configuration available');
        return false;
      }

      // Get the fetched config version
      const configInfo = this.remoteConfig.getValue('firebase_remote_config');
      const fetchedVersion = configInfo.getSource() === 'remote' ?
        'remote-' + Date.now() : 'default';

      // Check if this version was already activated
      if (this.lastActivatedVersion === fetchedVersion) {
        console.log('This configuration version was already activated');
        return false;
      }

      const activated = await this.remoteConfig.activate();

      if (activated) {
        this.lastActivatedVersion = fetchedVersion;
        console.log('New configuration activated:', fetchedVersion);
        return true;
      } else {
        console.log('Configuration already activated (returned false)');
        return false;
      }
    } catch (error) {
      if (error.code === 8003) {
        console.log('Configuration already activated (caught error 8003)');
        // Update our tracking to reflect this
        this.lastActivatedVersion = 'unknown'; // Or track actual version
        return false;
      }
      throw error;
    } finally {
      this.isActivating = false;
    }
  }
}

// Usage
const configManager = new RemoteConfigManager();

// Only activate when needed (e.g., app start, manual refresh)
await configManager.activateConfig();

import { useState, useCallback } from 'react';
import { getRemoteConfig } from 'firebase/remote-config';

export function useRemoteConfig() {
  const [isActivating, setIsActivating] = useState(false);
  const [lastActivated, setLastActivated] = useState(null);
  const remoteConfig = getRemoteConfig();

  const activateConfig = useCallback(async () => {
    if (isActivating) {
      console.log('Already activating');
      return false;
    }

    setIsActivating(true);

    try {
      const fetched = await remoteConfig.fetch();

      if (!fetched) {
        return false;
      }

      const activated = await remoteConfig.activate();

      if (activated) {
        setLastActivated(new Date());
        return true;
      }

      return false;
    } catch (error) {
      if (error.code === 8003) {
        setLastActivated(new Date()); // Assume it's activated
        return false;
      }
      throw error;
    } finally {
      setIsActivating(false);
    }
  }, [isActivating, remoteConfig]);

  return { activateConfig, isActivating, lastActivated };
}

class ActivationLock {
  constructor() {
    this.lock = false;
    this.waiting = [];
  }

  async acquire() {
    if (!this.lock) {
      this.lock = true;
      return () => {
        this.lock = false;
        // Process next waiting request if any
        if (this.waiting.length > 0) {
          const next = this.waiting.shift();
          next();
        }
      };
    }

    // Wait for lock to be released
    return new Promise((resolve) => {
      this.waiting.push(() => {
        this.lock = true;
        resolve(() => {
          this.lock = false;
          if (this.waiting.length > 0) {
            const next = this.waiting.shift();
            next();
          }
        });
      });
    });
  }
}

class SafeRemoteConfig {
  constructor() {
    this.lock = new ActivationLock();
    this.remoteConfig = getRemoteConfig();
  }

  async safeActivate() {
    const release = await this.lock.acquire();

    try {
      const fetched = await this.remoteConfig.fetch();

      if (!fetched) {
        return { activated: false, reason: 'no_new_config' };
      }

      try {
        const activated = await this.remoteConfig.activate();

        if (activated) {
          return { activated: true, reason: 'new_config_activated' };
        } else {
          return { activated: false, reason: 'already_activated' };
        }
      } catch (error) {
        if (error.code === 8003) {
          return { activated: false, reason: 'already_activated_error' };
        }
        throw error;
      }
    } finally {
      release();
    }
  }
}

// Usage - safe from race conditions
const safeConfig = new SafeRemoteConfig();

// Multiple calls will be serialized
Promise.all([
  safeConfig.safeActivate(),
  safeConfig.safeActivate(),
  safeConfig.safeActivate()
]).then(results => {
  console.log('Results:', results);
  // Only one will actually activate, others will return already_activated
});

function debounce(func, wait) {
  let timeout;
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

class DebouncedRemoteConfig {
  constructor() {
    this.remoteConfig = getRemoteConfig();
    this.debouncedActivate = debounce(this._activate.bind(this), 1000);
    this.activationPromise = null;
  }

  async _activate() {
    if (this.activationPromise) {
      // Return existing promise if activation is in progress
      return this.activationPromise;
    }

    this.activationPromise = (async () => {
      try {
        const fetched = await this.remoteConfig.fetch();

        if (!fetched) {
          return { activated: false };
        }

        const activated = await this.remoteConfig.activate();
        return { activated: !!activated };
      } catch (error) {
        if (error.code === 8003) {
          return { activated: false, error: 'already_activated' };
        }
        throw error;
      } finally {
        this.activationPromise = null;
      }
    })();

    return this.activationPromise;
  }

  // Public method - debounced
  activate() {
    return this.debouncedActivate();
  }
}

async function activateRemoteConfigWithRecovery() {
  const remoteConfig = getRemoteConfig();

  try {
    // Attempt 1: Normal activation
    const activated = await remoteConfig.fetchAndActivate();

    if (activated) {
      console.log('Configuration activated on first attempt');
      return { success: true, attempt: 1 };
    }

    // fetchAndActivate returned false (not an error)
    console.log('No new configuration or already activated');
    return { success: true, attempt: 1, alreadyActive: true };

  } catch (error) {
    console.log('Activation attempt failed:', error.code, error.message);

    if (error.code === 8003) {
      // Error 8003: Already activated - not actually a problem
      console.log('Configuration was already activated (error 8003)');
      return { success: true, attempt: 1, alreadyActive: true };
    }

    if (error.code === 8001) {
      // Throttled - wait and retry
      console.log('Throttled, waiting 60 seconds...');
      await new Promise(resolve => setTimeout(resolve, 60000));
    }

    // Attempt 2: Retry with exponential backoff
    try {
      await new Promise(resolve => setTimeout(resolve, 2000)); // 2 second delay

      const activated = await remoteConfig.fetchAndActivate();

      if (activated) {
        console.log('Configuration activated on retry');
        return { success: true, attempt: 2 };
      }

      return { success: true, attempt: 2, alreadyActive: true };

    } catch (retryError) {
      console.log('Retry also failed:', retryError.code);

      if (retryError.code === 8003) {
        return { success: true, attempt: 2, alreadyActive: true };
      }

      // Give up and use default values
      console.error('Failed to activate remote config after retry:', retryError);
      return {
        success: false,
        attempt: 2,
        error: retryError,
        usingDefaults: true
      };
    }
  }
}

// Advanced recovery with multiple strategies
class RemoteConfigRecovery {
  constructor() {
    this.remoteConfig = getRemoteConfig();
    this.maxRetries = 3;
    this.retryDelays = [1000, 5000, 30000]; // 1s, 5s, 30s
  }

  async activateWithRecovery(strategy = 'normal') {
    switch (strategy) {
      case 'normal':
        return this.normalActivation();
      case 'aggressive':
        return this.aggressiveActivation();
      case 'conservative':
        return this.conservativeActivation();
      default:
        return this.normalActivation();
    }
  }

  async normalActivation() {
    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
      try {
        const activated = await this.remoteConfig.fetchAndActivate();

        if (activated) {
          return { success: true, attempt: attempt + 1 };
        }

        // Returned false, not an error
        return { success: true, attempt: attempt + 1, alreadyActive: true };

      } catch (error) {
        if (error.code === 8003) {
          // Already activated - success
          return { success: true, attempt: attempt + 1, alreadyActive: true };
        }

        if (attempt < this.maxRetries - 1) {
          const delay = this.retryDelays[attempt] || 1000;
          console.log('Attempt ' + (attempt + 1) + ' failed, retrying in ' + delay + 'ms...');
          await new Promise(resolve => setTimeout(resolve, delay));
        } else {
          console.error('All ' + this.maxRetries + ' attempts failed:', error);
          return { success: false, attempt: attempt + 1, error };
        }
      }
    }
  }

  async aggressiveActivation() {
    // Clear cache and force fetch
    this.remoteConfig.settings.minimumFetchIntervalMillis = 0;

    try {
      const activated = await this.remoteConfig.fetchAndActivate();
      return { success: !!activated, aggressive: true };
    } catch (error) {
      if (error.code === 8003) {
        return { success: true, aggressive: true, alreadyActive: true };
      }
      throw error;
    } finally {
      // Restore default settings
      this.remoteConfig.settings.minimumFetchIntervalMillis = 3600000; // 1 hour
    }
  }

  async conservativeActivation() {
    // Only activate if enough time has passed since last activation
    const lastActivation = localStorage.getItem('lastRemoteConfigActivation');
    const now = Date.now();

    if (lastActivation && (now - parseInt(lastActivation)) < 300000) { // 5 minutes
      console.log('Skipping activation - too soon since last activation');
      return { success: true, skipped: true, reason: 'too_soon' };
    }

    const result = await this.normalActivation();

    if (result.success) {
      localStorage.setItem('lastRemoteConfigActivation', now.toString());
    }

    return result;
  }
}

// Mock Firebase Remote Config for testing
const createMockRemoteConfig = () => {
  let activatedVersion = null;
  let fetchCount = 0;

  return {
    fetch: jest.fn().mockImplementation(() => {
      fetchCount++;
      return Promise.resolve(fetchCount > 1); // Return true after first fetch
    }),

    activate: jest.fn().mockImplementation(() => {
      if (activatedVersion === fetchCount) {
        throw { code: 8003, message: 'Most recently fetched config is already activated' };
      }
      activatedVersion = fetchCount;
      return Promise.resolve(true);
    }),

    fetchAndActivate: jest.fn().mockImplementation(() => {
      return this.fetch().then(fetched => {
        if (!fetched) return Promise.resolve(false);
        return this.activate().then(() => true);
      });
    }),

    // For testing
    _getState: () => ({ activatedVersion, fetchCount })
  };
};

// Test cases
describe('Remote Config Activation', () => {
  test('should activate successfully on first attempt', async () => {
    const mockRemoteConfig = createMockRemoteConfig();
    const manager = new RemoteConfigManager(mockRemoteConfig);

    const result = await manager.activateConfig();

    expect(result.success).toBe(true);
    expect(mockRemoteConfig.fetch).toHaveBeenCalledTimes(1);
    expect(mockRemoteConfig.activate).toHaveBeenCalledTimes(1);
  });

  test('should handle already-activated error gracefully', async () => {
    const mockRemoteConfig = createMockRemoteConfig();
    const manager = new RemoteConfigManager(mockRemoteConfig);

    // First activation
    await manager.activateConfig();

    // Second activation (should fail with 8003)
    const result = await manager.activateConfig();

    expect(result.success).toBe(true); // Should still be considered success
    expect(result.alreadyActive).toBe(true);
    expect(mockRemoteConfig.fetch).toHaveBeenCalledTimes(2);
  });

  test('should prevent race conditions', async () => {
    const mockRemoteConfig = createMockRemoteConfig();
    const manager = new RemoteConfigManager(mockRemoteConfig);

    // Simulate concurrent activation attempts
    const promises = Array(5).fill().map(() => manager.activateConfig());

    const results = await Promise.all(promises);

    // Only one should actually activate, others should handle gracefully
    const successfulActivations = results.filter(r => r.success && !r.alreadyActive);
    expect(successfulActivations.length).toBe(1);

    const alreadyActiveResults = results.filter(r => r.alreadyActive);
    expect(alreadyActiveResults.length).toBe(4);
  });
});

**Debug logging for production:**

**Using Firebase Debug View:**
1. Enable debug mode for Remote Config: