Fixing 500 Internal Server Errors from Lovable API Calls

// Browser console only shows:
// POST https://xxx.supabase.co/functions/v1/my-function 500
// Error: Internal Server Error
// This tells you nothing about the actual cause

// Cloud tab → Logs shows the real error:
// Error: TypeError: Cannot read properties of undefined (reading 'split')
//   at handler (file:///src/index.ts:15:32)
//
// Now you know: line 15 in the Edge Function is calling .split()
// on a value that is undefined — probably a missing env variable

// Edge Function code references a secret that does not exist
const apiKey = Deno.env.get("OPENAI_API_KEY");
// apiKey is undefined → crash when used
const response = await fetch("https://api.openai.com/v1/...", {
  headers: { Authorization: `Bearer ${apiKey}` }
  // Sends "Bearer undefined" → API returns 401 → Edge Function crashes

// 1. Add the secret in Cloud tab → Secrets:
//    Name: OPENAI_API_KEY
//    Value: sk-your-actual-key
// 2. Add a guard in the Edge Function:
const apiKey = Deno.env.get("OPENAI_API_KEY");
if (!apiKey) {
  console.error("OPENAI_API_KEY secret is not set");
  return new Response(
    JSON.stringify({ error: "Server configuration error" }),
    { status: 500, headers: { "Content-Type": "application/json" } }
  );
}

import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
serve(async (req) => {
  const { query } = await req.json();
  const result = await supabase.from("products").select(query);
  return new Response(JSON.stringify(result.data));
});
// Any error crashes the entire function with a generic 500

import { serve } from "https://deno.land/std@0.168.0/http/server.ts";
serve(async (req) => {
  try {
    const body = await req.json().catch(() => null);
    if (!body) {
      return new Response(
        JSON.stringify({ error: "Invalid request body — expected JSON" }),
        { status: 400, headers: { "Content-Type": "application/json" } }
      );
    }
    const { query } = body;
    const result = await supabase.from("products").select(query);
    if (result.error) {
      console.error("Database query error:", result.error.message);
      return new Response(
        JSON.stringify({ error: "Database query failed" }),
        { status: 500, headers: { "Content-Type": "application/json" } }
      );
    }
    return new Response(JSON.stringify({ data: result.data }), {
      headers: { "Content-Type": "application/json" },
    });
  } catch (error) {
    console.error("Edge Function error:", error.message, error.stack);
    return new Response(
      JSON.stringify({ error: "Internal server error" }),
      { status: 500, headers: { "Content-Type": "application/json" } }
    );
  }
});

// Long-running operation that exceeds the timeout
serve(async (req) => {
  // This fetches 10,000 rows and processes each one — may timeout
  const { data } = await supabase.from("logs").select("*");
  const processed = data.map(row => expensiveOperation(row));
  return new Response(JSON.stringify(processed));
});

// Paginated approach that stays within timeout limits
serve(async (req) => {
  try {
    const { page = 0, pageSize = 100 } = await req.json();
    const from = page * pageSize;
    const to = from + pageSize - 1;
    const { data, error, count } = await supabase
      .from("logs")
      .select("*", { count: "exact" })
      .range(from, to);
    if (error) throw error;
    return new Response(
      JSON.stringify({ data, total: count, page, pageSize }),
      { headers: { "Content-Type": "application/json" } }
    );
  } catch (error) {
    console.error("Logs fetch error:", error.message);
    return new Response(
      JSON.stringify({ error: "Failed to fetch logs" }),
      { status: 500, headers: { "Content-Type": "application/json" } }
    );
  }
});