How to fix request_timeout: Processing request took too long in Supabase

async function retryAuthOperation(operation: () => Promise<any>, maxRetries = 3) {
  let lastError;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      lastError = error;

      // Check if it's a timeout error
      if (error.message?.includes('request_timeout') || error.code === 'request_timeout') {
        // Exponential backoff: 1s, 2s, 4s, etc.
        const delay = Math.pow(2, attempt) * 1000;
        console.log(`Auth timeout, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }

      // Not a timeout error, rethrow immediately
      throw error;
    }
  }

  throw lastError; // All retries failed
}

// Usage
const { data, error } = await retryAuthOperation(() =>
  supabase.auth.signInWithPassword({ email, password })
);

// Instead of multiple sequential auth calls
async function complexAuthFlow() {
  // Bad: Multiple sequential calls increase timeout risk
  await supabase.auth.signUp({ email, password });
  await supabase.auth.updateUser({ data: { profile: '...' } });
  await supabase.auth.refreshSession();

  // Good: Batch operations where possible
  const { data, error } = await supabase.auth.signUp({
    email,
    password,
    options: {
      data: { profile: '...' } // Include metadata in signup
    }
  });
}

// Optimize RLS policies that affect auth
// Check for slow RLS policies on auth-related tables:

// Check Supabase status before critical operations
async function checkSupabaseStatus() {
  try {
    const response = await fetch('https://status.supabase.com/api/v2/status.json');
    const status = await response.json();

    // Check if Auth service is operational
    const authStatus = status.components.find(c => c.name === 'Auth');
    return authStatus?.status === 'operational';
  } catch {
    return false; // Assume issues if status check fails
  }
}

// Implement fallback authentication
async function authenticateWithFallback(email: string, password: string) {
  const isSupabaseHealthy = await checkSupabaseStatus();

  if (!isSupabaseHealthy) {
    // Fallback to local auth or cached sessions
    return await fallbackAuth(email, password);
  }

  try {
    const { data, error } = await supabase.auth.signInWithPassword({
      email,
      password
    });

    if (error?.code === 'request_timeout') {
      // Try fallback after timeout
      console.warn('Supabase auth timeout, using fallback');
      return await fallbackAuth(email, password);
    }

    return { data, error };
  } catch (error) {
    console.error('Auth failed:', error);
    return await fallbackAuth(email, password);
  }
}

// Local storage fallback for critical user data
function setupAuthFallback() {
  // Store essential user data locally
  localStorage.setItem('last_known_auth_state', JSON.stringify({
    user: supabase.auth.getUser(),
    timestamp: Date.now()
  }));
}

// Supabase client with custom timeout configuration
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
  {
    auth: {
      autoRefreshToken: true,
      persistSession: true,
      detectSessionInUrl: true,
      // Timeout settings
      flowType: 'pkce',
      // Additional fetch options for timeout control
    },
    global: {
      // Global fetch options
      fetch: (url, options) => {
        return fetch(url, {
          ...options,
          // Set request timeout
          signal: AbortSignal.timeout(10000), // 10 second timeout
        });
      },
    },
  }
);

// For Node.js environments, configure keep-alive and connection pooling
const { createClient } = require('@supabase/supabase-js');
const https = require('https');

const agent = new https.Agent({
  keepAlive: true,
  maxSockets: 50, // Increase connection pool
  keepAliveMsecs: 1000,
});

const supabase = createClient(url, key, {
  global: {
    fetch: (url, options) => {
      return fetch(url, {
        ...options,
        agent, // Use custom agent for connection pooling
        signal: AbortSignal.timeout(15000), // 15 second timeout
      });
    },
  },
});

// Cache auth state to reduce API calls
class AuthCache {
  private cache = new Map<string, { data: any; timestamp: number }>();
  private readonly TTL = 5 * 60 * 1000; // 5 minutes

  async getAuthState() {
    const cached = this.cache.get('auth_state');

    if (cached && Date.now() - cached.timestamp < this.TTL) {
      return cached.data; // Return cached data
    }

    // Fetch fresh data
    const { data } = await supabase.auth.getSession();
    this.cache.set('auth_state', { data, timestamp: Date.now() });
    return data;
  }

  invalidate() {
    this.cache.delete('auth_state');
  }
}

// Optimistic updates for auth operations
async function optimisticSignIn(email: string, password: string) {
  // Immediately update UI optimistically
  updateUI({ loading: true, user: null });

  try {
    const { data, error } = await supabase.auth.signInWithPassword({
      email,
      password
    });

    if (error) {
      // Rollback optimistic update
      updateUI({ loading: false, user: null, error });
      throw error;
    }

    // Confirm optimistic update
    updateUI({ loading: false, user: data.user, error: null });
    return data;
  } catch (error) {
    updateUI({ loading: false, user: null, error });
    throw error;
  }
}

// Use service workers for offline auth
if ('serviceWorker' in navigator) {
  navigator.serviceWorker.register('/auth-sw.js').then(() => {
    console.log('Auth service worker registered');
  });
}

// Track auth request metrics
class AuthMetrics {
  private timeouts = 0;
  private totalRequests = 0;
  private timeoutTimestamps: number[] = [];

  trackRequest(startTime: number) {
    this.totalRequests++;

    return (error?: any) => {
      const duration = Date.now() - startTime;

      if (error?.code === 'request_timeout') {
        this.timeouts++;
        this.timeoutTimestamps.push(Date.now());

        // Log timeout details
        console.warn(`Auth timeout: duration=${duration}ms, totalTimeouts=${this.timeouts}`);

        // Alert if timeout rate is high
        if (this.timeouts > 10 && this.timeouts / this.totalRequests > 0.1) {
          this.alertHighTimeoutRate();
        }
      }

      // Log all auth request durations
      console.log(`Auth request: duration=${duration}ms, success=${!error}`);
    };
  }

  private alertHighTimeoutRate() {
    // Send alert to monitoring service
    console.error(`High auth timeout rate: ${this.timeouts}/${this.totalRequests} requests timed out`);

    // Could integrate with:
    // - Sentry
    // - Datadog
    // - Custom alerting system
  }

  getMetrics() {
    return {
      timeouts: this.timeouts,
      totalRequests: this.totalRequests,
      timeoutRate: this.totalRequests > 0 ? this.timeouts / this.totalRequests : 0,
      recentTimeouts: this.timeoutTimestamps.filter(ts => Date.now() - ts < 3600000).length
    };
  }
}

// Usage
const metrics = new AuthMetrics();

async function monitoredAuthRequest() {
  const startTime = Date.now();
  const track = metrics.trackRequest(startTime);

  try {
    const result = await supabase.auth.getSession();
    track(); // No error
    return result;
  } catch (error) {
    track(error); // Track error
    throw error;
  }
}

// Periodic metrics reporting
setInterval(() => {
  const m = metrics.getMetrics();
  console.log('Auth metrics:', m);
}, 60000); // Every minute