How to fix PGRST001: Connection to the database was lost in Supabase

async function retryWithBackoff(operation, maxRetries = 5) {
     let lastError;
     for (let i = 0; i < maxRetries; i++) {
       try {
         return await operation();
       } catch (error) {
         lastError = error;
         if (error.message.includes('PGRST001')) {
           // Wait exponentially longer each retry
           const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s, 8s, 16s
           await new Promise(resolve => setTimeout(resolve, delay));
           continue;
         }
         throw error;
       }
     }
     throw lastError;
   }

-- Check max_connections setting
   SHOW max_connections;

   -- Check current connection count
   SELECT count(*) FROM pg_stat_activity;

   -- Check connections by database
   SELECT datname, count(*) as connections
   FROM pg_stat_activity
   GROUP BY datname
   ORDER BY connections DESC;

// Reuse Supabase client instead of creating new instances
   // In serverless environments, cache the client outside handler
   let cachedClient = null;

   export async function handler() {
     if (!cachedClient) {
       cachedClient = createClient(
         process.env.SUPABASE_URL,
         process.env.SUPABASE_ANON_KEY
       );
     }
     return cachedClient;
   }

-- Check for idle connections
   SELECT pid, datname, usename, state, query_start, state_change
   FROM pg_stat_activity
   WHERE state = 'idle'
   ORDER BY state_change;

   -- Kill long-idle connections (use with caution)
   SELECT pg_terminate_backend(pid)
   FROM pg_stat_activity
   WHERE state = 'idle'
   AND state_change < NOW() - INTERVAL '10 minutes';

-- Find slow-running queries
   SELECT pid, usename, datname, query, now() - query_start as duration
   FROM pg_stat_activity
   WHERE state = 'active'
   AND query_start IS NOT NULL
   ORDER BY duration DESC
   LIMIT 10;

   -- Check for queries with locks
   SELECT blocked_locks.pid AS blocked_pid,
          blocked_activity.query AS blocked_query,
          blocking_locks.pid AS blocking_pid,
          blocking_activity.query AS blocking_query
   FROM pg_catalog.pg_locks blocked_locks
   JOIN pg_catalog.pg_stat_activity blocked_activity ON blocked_activity.pid = blocked_locks.pid
   JOIN pg_catalog.pg_locks blocking_locks ON blocking_locks.locktype = blocked_locks.locktype
   AND blocking_locks.database IS NOT DISTINCT FROM blocked_locks.database
   AND blocking_locks.relation IS NOT DISTINCT FROM blocked_locks.relation
   AND blocking_locks.page IS NOT DISTINCT FROM blocked_locks.page
   AND blocking_locks.tuple IS NOT DISTINCT FROM blocked_locks.tuple
   AND blocking_locks.virtualxid IS NOT DISTINCT FROM blocked_locks.virtualxid
   AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid
   AND blocking_locks.classid IS NOT DISTINCT FROM blocked_locks.classid
   AND blocking_locks.objid IS NOT DISTINCT FROM blocked_locks.objid
   AND blocking_locks.objsubid IS NOT DISTINCT FROM blocked_locks.objsubid
   AND blocking_locks.pid != blocked_locks.pid
   JOIN pg_catalog.pg_stat_activity blocking_activity ON blocking_activity.pid = blocking_locks.pid
   WHERE NOT blocked_locks.granted;

// Set statement timeout at connection level
   const supabase = createClient(
     process.env.SUPABASE_URL,
     process.env.SUPABASE_ANON_KEY,
     {
       db: {
         schema: 'public',
         // Set 30 second timeout
         searchPath: 'public',
         // Use connection string with options
         connection: {
           statement_timeout: '30000' // 30 seconds in milliseconds
         }
       }
     }
   );

# Test basic connectivity to Supabase
   ping db.your-project.supabase.co

   # Test PostgreSQL port (5432 for direct, 6543 for pooler)
   nc -zv db.your-project.supabase.co 5432
   nc -zv db.your-project.supabase.co 6543

   # Test with psql (if you have credentials)
   psql "postgresql://postgres:[YOUR-PASSWORD]@db.your-project.supabase.co:5432/postgres"

# Check DNS resolution
   nslookup db.your-project.supabase.co
   dig db.your-project.supabase.co

   # Flush DNS cache if needed
   sudo systemd-resolve --flush-caches  # Linux
   sudo killall -HUP mDNSResponder     # macOS
   ipconfig /flushdns                   # Windows

-- Check CPU and memory usage
   SELECT * FROM pg_stat_database WHERE datname = current_database();

   -- Check disk space
   SELECT pg_database_size(current_database());

   -- Check for resource contention
   SELECT * FROM pg_stat_activity WHERE wait_event_type IS NOT NULL;

class CircuitBreaker {
     constructor(failureThreshold = 5, resetTimeout = 60000) {
       this.failureThreshold = failureThreshold;
       this.resetTimeout = resetTimeout;
       this.failureCount = 0;
       this.lastFailureTime = null;
       this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
     }

     async execute(operation) {
       if (this.state === 'OPEN') {
         if (Date.now() - this.lastFailureTime > this.resetTimeout) {
           this.state = 'HALF_OPEN';
         } else {
           throw new Error('Circuit breaker is OPEN');
         }
       }

       try {
         const result = await operation();
         if (this.state === 'HALF_OPEN') {
           this.reset();
         }
         return result;
       } catch (error) {
         this.recordFailure();
         throw error;
       }
     }

     recordFailure() {
       this.failureCount++;
       this.lastFailureTime = Date.now();
       if (this.failureCount >= this.failureThreshold) {
         this.state = 'OPEN';
       }
     }

     reset() {
       this.failureCount = 0;
       this.lastFailureTime = null;
       this.state = 'CLOSED';
     }
   }

// Log database connection errors with context
   function logDatabaseError(error, context = {}) {
     console.error({
       timestamp: new Date().toISOString(),
       error: error.message,
       code: error.code,
       severity: 'ERROR',
       context: {
         ...context,
         supabaseProject: process.env.SUPABASE_PROJECT_ID,
         environment: process.env.NODE_ENV
       }
     });
   }

   // Use in your application
   try {
     await supabase.from('users').select('*');
   } catch (error) {
     logDatabaseError(error, {
       operation: 'select_users',
       table: 'users'
     });
     // Implement fallback logic
   }