How to fix EdgeFunctionError: Function invocation timeout in Supabase

// Instead of sequential API calls
const results = [];
for (const item of items) {
  const result = await fetchExternalApi(item); // Slow!
  results.push(result);
}

// Use Promise.all for parallel execution
const promises = items.map(item => fetchExternalApi(item));
const results = await Promise.all(promises); // Much faster!

// Set timeout for fetch requests
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout

try {
  const response = await fetch('https://api.example.com/data', {
    signal: controller.signal
  });
  clearTimeout(timeoutId);
  // Process response
} catch (error) {
  if (error.name === 'AbortError') {
    console.error('Request timed out');
    // Return cached data or fallback response
  }
  throw error;
}

// Supabase client with statement timeout
const { data, error } = await supabase
  .from('users')
  .select('*')
  .limit(1000)
  .timeout(3000); // 3 second timeout

// Pagination example
async function processAllUsers() {
  let page = 0;
  const pageSize = 100;
  let hasMore = true;

  while (hasMore) {
    const { data: users, error } = await supabase
      .from('users')
      .select('*')
      .range(page * pageSize, (page + 1) * pageSize - 1);

    if (error) throw error;

    // Process this batch
    await processUserBatch(users);

    hasMore = users.length === pageSize;
    page++;
  }
}

// Streaming example for file processing
import { readableStreamFromReader } from "https://deno.land/[email protected]/streams/mod.ts";

async function processLargeFile(filePath: string) {
  const file = await Deno.open(filePath);
  const stream = readableStreamFromReader(file);

  for await (const chunk of stream) {
    // Process chunk by chunk
    await processChunk(chunk);
  }

  file.close();
}

console.time('database-query');
const { data, error } = await supabase.from('users').select('*');
console.timeEnd('database-query'); // Logs execution time

console.time('external-api');
const response = await fetch('https://api.example.com');
console.timeEnd('external-api');

const start = performance.now();
// Your code here
const duration = performance.now() - start;
console.log(`Operation took ${duration}ms`);

// Immediate response
export async function handler(req: Request) {
  const jobId = generateJobId();

  // Start background processing (e.g., queue to Redis)
  await queueBackgroundJob(jobId, req);

  return new Response(JSON.stringify({ jobId, status: 'processing' }), {
    status: 202, // Accepted
    headers: { 'Content-Type': 'application/json' }
  });
}

# Use tools like k6 or artillery for load testing
k6 run --vus 10 --duration 30s script.js

class CircuitBreaker {
  private failures = 0;
  private lastFailure = 0;
  private readonly threshold = 5;
  private readonly resetTimeout = 60000; // 1 minute

  async execute(fn: () => Promise<any>) {
    if (this.isOpen()) {
      throw new Error('Circuit breaker open');
    }

    try {
      const result = await fn();
      this.reset();
      return result;
    } catch (error) {
      this.recordFailure();
      throw error;
    }
  }

  private isOpen() {
    return this.failures >= this.threshold &&
           Date.now() - this.lastFailure < this.resetTimeout;
  }

  private recordFailure() {
    this.failures++;
    this.lastFailure = Date.now();
  }

  private reset() {
    this.failures = 0;
  }
}