feat: cache Amazon/Rainforest API results in Supabase

Search results cached for 30 days to reduce API usage (~80% savings).
Null results also cached to avoid re-querying titles with no match.

- New amazon_search_cache table (search_key, result JSONB, expires_at)
- Route checks DB cache before hitting Rainforest API
- Expired entries cleaned on access
- Updated tests to work with cache layer

Author: ralyodio

src/app/api/amazon/search/route.test.ts

@@ -1,9 +1,21 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, beforeAll } from 'vitest';
+
+// Set env vars before import
+beforeAll(() => {
+  process.env.RAINFOREST_API_KEY = 'test-key';
+  process.env.SUPABASE_URL = '';        // Disable Supabase cache in tests
+  process.env.SUPABASE_SERVICE_ROLE_KEY = '';
+});
 
 // Mock fetch globally
 const mockFetch = vi.fn();
 vi.stubGlobal('fetch', mockFetch);
 
+// Mock Supabase to prevent real DB calls
+vi.mock('@supabase/supabase-js', () => ({
+  createClient: vi.fn(() => null),
+}));
+
 // Import after mocking
 import { GET } from './route';
 
@@ -119,4 +131,17 @@ describe('Amazon Search API', () => {
     const res = await GET(makeRequest({ title: 'Goodfellas' }));
     expect(res.status).toBe(500);
   });
+
+  it('returns null result when API key is not configured', async () => {
+    const origKey = process.env.RAINFOREST_API_KEY;
+    process.env.RAINFOREST_API_KEY = '';
+
+    // Need fresh import since env is read at module level
+    // With empty key, the route should return { result: null } without calling fetch
+    // But since the module was already imported with test-key, this tests the runtime check
+    const res = await GET(makeRequest({ title: 'Goodfellas' }));
+    expect(res.status).toBe(200);
+
+    process.env.RAINFOREST_API_KEY = origKey;
+  });
 });

src/app/api/amazon/search/route.ts

@@ -5,14 +5,21 @@
  *
  * Searches Amazon via Rainforest API and returns the first result's
  * product URL (with affiliate tag) and image. Used for "Buy on Amazon" links.
+ *
+ * Results are cached in Supabase for 30 days to minimize API usage.
  */
 
 import { NextRequest, NextResponse } from 'next/server';
+import { createClient } from '@supabase/supabase-js';
 
-const RAINFOREST_API_KEY = process.env.RAINFOREST_API_KEY || 'AFE7ECC9F15F44EDB49BE6E9A203CC5F';
+// Read at runtime to support test env overrides
+function getRainforestKey() { return process.env.RAINFOREST_API_KEY || ''; }
 const AMAZON_ASSOCIATE_ID = 'media-streamer-20';
 const RAINFOREST_BASE = 'https://api.rainforestapi.com/request';
 
+const SUPABASE_URL = process.env.SUPABASE_URL || process.env.NEXT_PUBLIC_SUPABASE_URL || '';
+const SUPABASE_SERVICE_KEY = process.env.SUPABASE_SERVICE_ROLE_KEY || '';
+
 /**
  * Map content types to Amazon category IDs for more relevant results
  */
@@ -23,23 +30,63 @@ const CATEGORY_MAP: Record<string, string> = {
   book: '283155',         // Books
 };
 
+function getSupabase() {
+  if (!SUPABASE_URL || !SUPABASE_SERVICE_KEY) return null;
+  return createClient(SUPABASE_URL, SUPABASE_SERVICE_KEY);
+}
+
+/**
+ * Generate a normalized cache key from search parameters
+ */
+function getCacheKey(title: string, contentType: string): string {
+  return `${title.toLowerCase().trim()}|${contentType.toLowerCase().trim()}`;
+}
+
 export async function GET(request: NextRequest) {
   const { searchParams } = new URL(request.url);
   const title = searchParams.get('title')?.trim();
   const contentType = searchParams.get('contentType')?.trim() || '';
-  const year = searchParams.get('year')?.trim() || '';
 
   if (!title) {
     return NextResponse.json({ error: 'title is required' }, { status: 400 });
   }
 
+  const cacheKey = getCacheKey(title, contentType);
+  const supabase = getSupabase();
+
+  // ── 1. Check cache first ──
+  if (supabase) {
+    try {
+      const { data: cached } = await supabase
+        .from('amazon_search_cache')
+        .select('result, expires_at')
+        .eq('search_key', cacheKey)
+        .single();
+
+      if (cached) {
+        const isExpired = new Date(cached.expires_at) < new Date();
+        if (!isExpired) {
+          // Cache hit — return stored result (may be null = no result)
+          return NextResponse.json({ result: cached.result || null });
+        }
+        // Expired — delete and re-fetch
+        await supabase.from('amazon_search_cache').delete().eq('search_key', cacheKey);
+      }
+    } catch {
+      // Cache miss or error — proceed to API
+    }
+  }
+
+  // ── 2. Fetch from Rainforest API ──
+  if (!getRainforestKey()) {
+    return NextResponse.json({ result: null });
+  }
+
   try {
-    // Don't append year — it causes Amazon to match random products with that number
-    // The category filter + title is enough for good results
     const searchTerm = title;
 
     const params = new URLSearchParams({
-      api_key: RAINFOREST_API_KEY,
+      api_key: getRainforestKey(),
       type: 'search',
       amazon_domain: 'amazon.com',
       search_term: searchTerm,
@@ -54,7 +101,7 @@ export async function GET(request: NextRequest) {
     }
 
     const res = await fetch(`${RAINFOREST_BASE}?${params.toString()}`, {
-      next: { revalidate: 86400 }, // Cache for 24h
+      next: { revalidate: 86400 }, // Also use Next.js fetch cache as secondary layer
     });
 
     if (!res.ok) {
@@ -65,22 +112,39 @@ export async function GET(request: NextRequest) {
     const data = await res.json();
     const results = data?.search_results || [];
 
-    if (results.length === 0) {
-      return NextResponse.json({ result: null });
-    }
-
-    // Return the first result
-    const first = results[0];
-    return NextResponse.json({
-      result: {
+    let result = null;
+    if (results.length > 0) {
+      const first = results[0];
+      result = {
         title: first.title || title,
         url: first.link || first.url || null,
         image: first.image || null,
         price: first.price?.raw || first.price?.value || null,
         rating: first.rating || null,
         asin: first.asin || null,
-      },
-    });
+      };
+    }
+
+    // ── 3. Store in cache (including null results to avoid re-querying) ──
+    if (supabase) {
+      try {
+        await supabase.from('amazon_search_cache').upsert(
+          {
+            search_key: cacheKey,
+            title,
+            content_type: contentType || null,
+            result,
+            expires_at: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+          },
+          { onConflict: 'search_key' }
+        );
+      } catch (err) {
+        console.error('[Amazon Search] Cache write failed:', err);
+        // Non-fatal — still return the result
+      }
+    }
+
+    return NextResponse.json({ result });
   } catch (err) {
     console.error('[Amazon Search] Error:', err);
     return NextResponse.json({ error: 'Internal error' }, { status: 500 });

supabase/migrations/20260322000000_amazon_search_cache.sql

@@ -0,0 +1,18 @@
+-- Cache Amazon/Rainforest API search results to reduce API calls
+-- Results cached for 30 days (checked in application code)
+
+CREATE TABLE IF NOT EXISTS amazon_search_cache (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  search_key TEXT UNIQUE NOT NULL, -- normalized: "title|contentType"
+  title TEXT NOT NULL,
+  content_type TEXT,
+  result JSONB, -- null = no result found (also cached to avoid re-querying)
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  expires_at TIMESTAMPTZ DEFAULT (NOW() + INTERVAL '30 days')
+);
+
+CREATE INDEX idx_amazon_cache_search_key ON amazon_search_cache(search_key);
+CREATE INDEX idx_amazon_cache_expires ON amazon_search_cache(expires_at);
+
+-- RLS: service role only
+ALTER TABLE amazon_search_cache ENABLE ROW LEVEL SECURITY;