Enhance attachment handling and logging: improve error handling, enforce required partId, and add detailed logging for downloads

Fixes bug with 404 attachments

Signed-off-by: Shahm Najeeb <Shahm_Najeeb@outlook.com>

Author: DefinetlyNotAI

app/api/accounts/[accountId]/emails/[uid]/attachments/[partId]/route.ts

@@ -17,10 +17,9 @@ export const runtime = 'nodejs'
 export const dynamic = 'force-dynamic'
 export const revalidate = 0
 
-export async function GET(
-    request: NextRequest,
-    {params}: { params: Promise<{ accountId: string; uid: string; partId: string }> }
-) {
+export async function GET(request: NextRequest, {params}: {
+    params: Promise<{ accountId: string; uid: string; partId: string }>
+}) {
     try {
         // Check authentication
         const isAuthenticated = await requireAuth()
@@ -33,29 +32,32 @@ export async function GET(
 
         const {accountId, uid, partId} = await params
 
-        // Rate limiting
-        const ip = request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || "unknown"
-        const rateLimit = checkRateLimit(`attachment:${ip}`, RateLimitSettings.attachmentsLimit, RateLimitSettings.windowMs)
-
-        if (!rateLimit.allowed) {
-            return NextResponse.json(
-                {error: "Too many requests"},
-                {status: 429}
-            )
-        }
-
         // Parse query params
         const searchParams = request.nextUrl.searchParams
         const folder = searchParams.get("folder")
         const filename = searchParams.get("filename") || "attachment"
 
+        console.log(`[API] Attachment request - accountId: ${accountId}, uid: ${uid}, partId: ${partId}, folder: ${folder}, filename: ${filename}`)
+
         if (!folder) {
+            console.error(`[API] Missing folder parameter`)
             return NextResponse.json(
                 {error: "Folder parameter required"},
                 {status: 400}
             )
         }
 
+        // Rate limiting
+        const ip = request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || "unknown"
+        const rateLimit = checkRateLimit(`attachment:${ip}`, RateLimitSettings.attachmentsLimit, RateLimitSettings.windowMs)
+
+        if (!rateLimit.allowed) {
+            return NextResponse.json(
+                {error: "Too many requests"},
+                {status: 429}
+            )
+        }
+
         const uidNum = Number.parseInt(uid, 10)
         if (isNaN(uidNum)) {
             return NextResponse.json(

components/email-viewer.tsx

@@ -107,26 +107,43 @@ export function EmailViewer({accountId, folder, uid}: EmailViewerProps) {
 
     async function downloadAttachment(att: EmailAttachment) {
         try {
-            const response = await fetch(
-                `/api/accounts/${accountId}/emails/${uid}/attachments/${att.partId}?folder=${encodeURIComponent(folder)}&filename=${encodeURIComponent(att.filename || 'attachment')}`
-            )
+            const url = `/api/accounts/${accountId}/emails/${uid}/attachments/${att.partId}?folder=${encodeURIComponent(folder)}&filename=${encodeURIComponent(att.filename || 'attachment')}`
+            console.log(`[EmailViewer] Downloading attachment:`, {
+                partId: att.partId,
+                filename: att.filename,
+                url: url,
+                accountId,
+                uid,
+                folder
+            })
+
+            const response = await fetch(url)
 
             if (!response.ok) {
-                console.error("Failed to download attachment")
+                const errorText = await response.text()
+                console.error("Failed to download attachment", {
+                    status: response.status,
+                    statusText: response.statusText,
+                    url: url,
+                    errorBody: errorText
+                })
+                alert(`Failed to download attachment: ${response.status} ${response.statusText}\n${errorText}`)
                 return
             }
 
             const blob = await response.blob()
-            const url = window.URL.createObjectURL(blob)
+            const downloadUrl = window.URL.createObjectURL(blob)
             const a = document.createElement('a')
-            a.href = url
+            a.href = downloadUrl
             a.download = att.filename || 'attachment'
             document.body.appendChild(a)
             a.click()
-            window.URL.revokeObjectURL(url)
+            window.URL.revokeObjectURL(downloadUrl)
             document.body.removeChild(a)
+            console.log(`[EmailViewer] Successfully downloaded: ${att.filename}`)
         } catch (error) {
             console.error("Error downloading attachment:", error)
+            alert(`Error downloading attachment: ${error instanceof Error ? error.message : 'Unknown error'}`)
         }
     }
 

lib/imap-service.ts

@@ -385,13 +385,17 @@ export async function getEmail(params: GetEmailParams): Promise<EmailDetail | nu
                                 html: sanitizedHtml,
                                 text: parsed.text,
                                 attachments:
-                                    parsed.attachments?.map((att: any, index: number) => ({
-                                        filename: att.filename,
-                                        contentType: att.contentType,
-                                        size: att.size,
-                                        contentId: att.contentId,
-                                        partId: att.partId || `${index + 1}`,
-                                    })) || [],
+                                    parsed.attachments?.map((att: any, index: number) => {
+                                        const partId = `${index + 1}`
+                                        console.log(`[IMAP] Mapping attachment ${index}: ${att.filename}, partId: ${partId}`)
+                                        return {
+                                            filename: att.filename,
+                                            contentType: att.contentType,
+                                            size: att.size,
+                                            contentId: att.contentId,
+                                            partId: partId,
+                                        }
+                                    }) || [],
                             }
 
                             resolve(emailData)
@@ -485,6 +489,17 @@ export async function getAttachment(params: GetAttachmentParams): Promise<{
                             const attachments = parsed.attachments || []
                             const index = parseInt(partId, 10) - 1
 
+                            console.log(`[IMAP] Looking for attachment with partId ${partId} (index ${index}), total attachments: ${attachments.length}`)
+
+                            if (attachments.length > 0) {
+                                console.log(`[IMAP] Available attachments:`, attachments.map((a: any, i: number) => ({
+                                    index: i,
+                                    filename: a.filename,
+                                    size: a.size,
+                                    contentType: a.contentType
+                                })))
+                            }
+
                             if (index >= 0 && index < attachments.length) {
                                 const attachment = attachments[index]
 

types/index.ts

@@ -29,7 +29,7 @@ export interface EmailAttachment {
     contentType?: string
     size?: number
     contentId?: string
-    partId?: string
+    partId: string // Required for downloading attachments
 }
 
 export interface EmailFolder {