Implement signed URLs for audio to reduce Vercel egress

- Add /api/audio/signed-url/[audioId] endpoint to generate signed URLs
- Update audio library to generate signed URLs for all audio files
- Frontend now uses signed URLs (playUrl) instead of Vercel proxy
- Remove full chapter content from library response (only send preview)
- Audio files now stream directly from Supabase, bypassing Vercel
- Reduces Vercel cached egress from ~20MB per play to ~1KB per URL generation

Author: SeanOnamade

writegeist-web/app/api/audio/download/[audioId]/route.ts

@@ -60,13 +60,14 @@ export async function GET(
     console.log('File downloaded successfully, size:', fileData.size)
 
     // Return the file as a response
+    // Note: Consider redirecting to audio_url (Supabase public URL) instead to avoid Vercel egress
     return new NextResponse(fileData.stream(), {
       status: 200,
       headers: {
         'Content-Type': 'audio/mpeg',
         'Content-Length': fileData.size.toString(),
         'Content-Disposition': `attachment; filename="chapter_${audio.chapter_id}_audio.mp3"`,
-        'Cache-Control': 'private, max-age=3600'
+        'Cache-Control': 'no-cache, no-store, must-revalidate' // Prevent Vercel caching to reduce egress
       }
     })
 

writegeist-web/app/api/audio/library/route.ts

@@ -17,6 +17,7 @@ export async function GET(request: NextRequest) {
     console.log('Loading audio library for user:', user.id)
 
     // Get all chapters for the user with their audio status
+    // Note: We only select content_length to calculate preview, not full content to reduce egress
     const { data: chapters, error: chaptersError } = await supabase
       .from('chapters')
       .select(`
@@ -64,9 +65,31 @@ export async function GET(request: NextRequest) {
 
     console.log(`Found ${audioData.length} audio records`)
 
+    // Generate signed URLs for all completed audio files
+    const audioWithSignedUrls = await Promise.all(
+      audioData
+        .filter(a => a.status === 'completed' && a.file_path)
+        .map(async (audio) => {
+          try {
+            const { data: signedUrlData } = await supabase.storage
+              .from('audio-files')
+              .createSignedUrl(audio.file_path, 3600) // 1 hour expiration
+            
+            return {
+              ...audio,
+              signedUrl: signedUrlData?.signedUrl || null
+            }
+          } catch (error) {
+            console.error('Error generating signed URL for audio:', audio.id, error)
+            return { ...audio, signedUrl: null }
+          }
+        })
+    )
+
     // Combine chapters with their audio status and outdated detection
     const chaptersWithAudio = chapters?.map(chapter => {
-      const audio = audioData.find(a => a.chapter_id === chapter.id)
+      const audio = audioWithSignedUrls.find(a => a.chapter_id === chapter.id) || 
+                    audioData.find(a => a.chapter_id === chapter.id)
 
       // Check if audio is outdated (compare content hashes)
       let isOutdated = false
@@ -81,13 +104,21 @@ export async function GET(request: NextRequest) {
         }
       }
 
+      // Don't send full content - only preview to reduce egress
+      const { content, ...chapterWithoutContent } = chapter
+      
       return {
-        ...chapter,
-        audio: audio ? { ...audio, isOutdated } : null,
+        ...chapterWithoutContent,
+        audio: audio ? { 
+          ...audio, 
+          isOutdated,
+          // Include signedUrl if available, otherwise fallback to audio_url or null
+          playUrl: audio.signedUrl || audio.audio_url || null
+        } : null,
         project: chapter.projects,
-        // Calculate content preview
-        content_preview: chapter.content 
-          ? chapter.content.substring(0, 200) + (chapter.content.length > 200 ? '...' : '')
+        // Calculate content preview (don't send full content to reduce egress)
+        content_preview: content 
+          ? content.substring(0, 200) + (content.length > 200 ? '...' : '')
           : 'No content'
       }
     }) || []

writegeist-web/app/api/audio/signed-url/[audioId]/route.ts

@@ -0,0 +1,75 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { createClient } from '@/lib/supabase/server'
+
+/**
+ * GET /api/audio/signed-url/[audioId]
+ * Generate a signed URL for an audio file (expires in 1 hour)
+ * This avoids Vercel egress charges by serving files directly from Supabase
+ */
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ audioId: string }> }
+) {
+  try {
+    const { audioId } = await params
+    const supabase = await createClient()
+    
+    // Get the current user
+    const { data: { user }, error: userError } = await supabase.auth.getUser()
+    if (userError || !user) {
+      return NextResponse.json(
+        { error: 'User not authenticated' },
+        { status: 401 }
+      )
+    }
+
+    // Get audio record to verify ownership and get file path
+    const { data: audio, error: audioError } = await supabase
+      .from('chapter_audio')
+      .select('*')
+      .eq('id', audioId)
+      .eq('user_id', user.id)
+      .single()
+
+    if (audioError || !audio) {
+      return NextResponse.json(
+        { error: 'Audio file not found' },
+        { status: 404 }
+      )
+    }
+
+    if (audio.status !== 'completed' || !audio.file_path) {
+      return NextResponse.json(
+        { error: 'Audio file not ready' },
+        { status: 400 }
+      )
+    }
+
+    // Generate signed URL (expires in 1 hour = 3600 seconds)
+    const { data: signedUrlData, error: signedUrlError } = await supabase.storage
+      .from('audio-files')
+      .createSignedUrl(audio.file_path, 3600)
+
+    if (signedUrlError || !signedUrlData) {
+      console.error('Error generating signed URL:', signedUrlError)
+      return NextResponse.json(
+        { error: 'Failed to generate signed URL' },
+        { status: 500 }
+      )
+    }
+
+    return NextResponse.json({
+      success: true,
+      signedUrl: signedUrlData.signedUrl,
+      expiresIn: 3600
+    })
+
+  } catch (error) {
+    console.error('Signed URL generation error:', error)
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    )
+  }
+}
+

writegeist-web/app/api/audio/stream/[audioId]/route.ts

@@ -54,13 +54,15 @@ export async function GET(
     }
 
     // Return the file for streaming
+    // Note: This route should only be used as fallback. Prefer using audio_url (Supabase public URL) directly
+    // to avoid Vercel Cached Egress charges
     return new NextResponse(fileData.stream(), {
       status: 200,
       headers: {
         'Content-Type': 'audio/mpeg',
         'Content-Length': fileData.size.toString(),
         'Accept-Ranges': 'bytes',
-        'Cache-Control': 'private, max-age=3600'
+        'Cache-Control': 'no-cache, no-store, must-revalidate' // Prevent Vercel caching to reduce egress
       }
     })
 

writegeist-web/app/audio/page.tsx

@@ -575,7 +575,7 @@ export default function AudioPage() {
                           className="w-full"
                           preload="metadata"
                         >
-                          <source src={`/api/audio/stream/${chapter.audio.id}`} type="audio/mpeg" />
+                          <source src={chapter.audio.playUrl || chapter.audio.audio_url || `/api/audio/stream/${chapter.audio.id}`} type="audio/mpeg" />
                           Your browser does not support the audio element.
                         </audio>
                       </div>