AppHighway + Supabase: Vollständiger Backend-Stack ohne Server

// Secrets über Supabase CLI setzen
supabase secrets set APPHIGHWAY_API_KEY=your_key_here

// In Edge Functions zugreifen
const apiKey = Deno.env.get('APPHIGHWAY_API_KEY')

Why: Verhindert versehentliche Key-Offenlegung, ermöglicht einfache Key-Rotation, verschiedene Keys pro Umgebung

const callWithRetry = async (fn: () => Promise<any>, retries = 3) => {
  for (let i = 0; i < retries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
    }
  }
};

Why: Behandelt vorübergehende Netzwerkausfälle, verbessert Zuverlässigkeit, bessere Benutzererfahrung

-- Benutzer können nur ihre eigenen Daten sehen
CREATE POLICY "Users view own data"
  ON user_data FOR SELECT
  USING (auth.uid() = user_id);

-- Edge Functions können schreiben, aber Benutzer nicht
CREATE POLICY "Service role can write"
  ON processed_data FOR INSERT
  WITH CHECK (true);

Why: Verhindert Datenlecks, erzwingt Sicherheit auf Datenbankebene, Defense in Depth

// Zuerst Cache prüfen
const { data: cached } = await supabase
  .from('api_cache')
  .select('result')
  .eq('key', cacheKey)
  .gte('expires_at', new Date().toISOString())
  .single();

if (cached) return cached.data.result

// API aufrufen und Ergebnis cachen
const result = await callAppHighway()
await supabase.from('api_cache').insert({ key: cacheKey, result })

Why: Reduziert API-Kosten, verbessert Antwortzeit, reduziert Last auf AppHighway

-- Im Hintergrund verarbeiten
CREATE TRIGGER process_async
  AFTER INSERT ON tasks
  FOR EACH ROW
  EXECUTE FUNCTION call_edge_function();

-- Benutzer erhält sofortige Antwort
INSERT INTO tasks (data) VALUES ('...');
SOFORT ZURÜCKGEBEN;

Why: Bessere UX mit sofortigen Antworten, behandelt schwere Verarbeitung asynchron, skalierbare Architektur

// Timing-Logs hinzufügen
const start = Date.now();
const result = await callAppHighway();
console.log(`API-Aufruf dauerte ${Date.now() - start}ms`);

// Fehler mit Kontext protokollieren
try {
  await process();
} catch (error) {
  console.error('Verarbeitung fehlgeschlagen:', {
    error: error.message,
    userId,
    timestamp: new Date().toISOString()
  });
  throw error;
}

Why: Identifizieren Sie Performance-Engpässe, debuggen Sie Produktionsprobleme, optimieren Sie API-Nutzung

// Anstelle sequenzieller Verarbeitung
for (const item of items) {
  await processWithAppHighway(item); // Langsam!
}

// Parallele Verarbeitung verwenden
const results = await Promise.all(
  items.map(item => processWithAppHighway(item))
); // Schnell!

Why: 10x schnellere Verarbeitung, bessere Ressourcennutzung, niedrigere Latenz

try {
  const result = await callAppHighway();
} catch (error) {
  if (error.status === 429) {
    // Rate Limit - mit Backoff wiederholen
    return await retryWithBackoff();
  } else if (error.status === 401) {
    // Ungültiger API-Key - Admin benachrichtigen
    await notifyAdmin('Ungültiger AppHighway-API-Key');
    throw new Error('Konfigurationsfehler');
  } else if (error.status >= 500) {
    // Serverfehler - wiederholen
    return await retry();
  } else {
    // Client-Fehler - an Benutzer zurückgeben
    throw new Error(`API-Fehler: ${error.message}`);
  }
}

Why: Besseres Debugging, graceful Degradation, verbesserte Zuverlässigkeit

// Datenbanktypen definieren
import { Database } from './database.types';

type Review = Database['public']['Tables']['reviews']['Row'];

// API-Antworttypen definieren
interface SentimentResult {
  score: number;
  label: 'positive' | 'negative' | 'neutral';
  confidence: number;
}

const analyzeReview = async (review: Review): Promise<SentimentResult> => {
  // Vollständig typsicher
};

Why: Fehler zur Compile-Zeit erkennen, bessere IDE-Unterstützung, selbstdokumentierender Code

const corsHeaders = {
  'Access-Control-Allow-Origin': '*',
  'Access-Control-Allow-Headers': 'authorization, x-client-info, apikey, content-type',
};

serve(async (req) => {
  // Preflight behandeln
  if (req.method === 'OPTIONS') {
    return new Response('ok', { headers: corsHeaders });
  }

  // In Antwort einschließen
  return new Response(data, {
    headers: { ...corsHeaders, 'Content-Type': 'application/json' }
  });
});

Why: Ermöglicht Browser-basierte API-Aufrufe, verhindert CORS-Fehler, bessere Sicherheit