Add report fetching and user accessed reports functionality

- Implemented GET endpoint to fetch reports by ID from Firestore, returning cached report data or appropriate error messages.
- Added POST endpoint to log accessed reports for users, storing relevant data in the user's accessed_reports array.
- Updated the dashboard to save accessed reports when streaming completes.
- Enhanced the reports page to display user's accessed reports with loading states and error handling.
- Refactored report detail page to fetch report data and handle loading/error states, improving user experience.

Author: alexechoi

junction-app/app/api/reports/[id]/route.ts

@@ -0,0 +1,48 @@
+import { adminDb } from "@/lib/firebase-admin";
+
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+
+    if (!id) {
+      return Response.json({ error: "Report ID is required" }, { status: 400 });
+    }
+
+    console.log("Fetching report for ID:", id);
+
+    // Fetch report from cache collection
+    const cacheDoc = await adminDb
+      .collection("cache")
+      .doc(id.toLowerCase())
+      .get();
+
+    console.log("Cache doc exists:", cacheDoc.exists);
+
+    if (!cacheDoc.exists) {
+      return Response.json(
+        { error: "Report not found", id: id.toLowerCase() },
+        { status: 404 }
+      );
+    }
+
+    const data = cacheDoc.data();
+
+    return Response.json({
+      cached_at: data?.cached_at || null,
+      query: data?.query || id,
+      report: data?.report || {},
+    });
+  } catch (error) {
+    console.error("Error fetching report:", error);
+    return Response.json(
+      {
+        error: "Internal server error",
+        details: error instanceof Error ? error.message : "Unknown error",
+      },
+      { status: 500 }
+    );
+  }
+}

junction-app/app/api/user/accessed-reports/route.ts

@@ -0,0 +1,113 @@
+import { adminDb } from "@/lib/firebase-admin";
+import { FieldValue } from "firebase-admin/firestore";
+
+export async function POST(request: Request) {
+  try {
+    const { userId, entityName } = await request.json();
+
+    if (!userId || !entityName) {
+      return Response.json(
+        { error: "userId and entityName are required" },
+        { status: 400 }
+      );
+    }
+
+    // Get the cached report from the cache collection
+    const cacheDoc = await adminDb.collection("cache").doc(entityName.toLowerCase()).get();
+
+    if (!cacheDoc.exists) {
+      return Response.json(
+        { error: "Report not found in cache" },
+        { status: 404 }
+      );
+    }
+
+    const cacheData = cacheDoc.data();
+
+    // Add to user's accessed_reports array
+    const userRef = adminDb.collection("users").doc(userId);
+
+    await userRef.set(
+      {
+        accessed_reports: FieldValue.arrayUnion({
+          entity_name: entityName.toLowerCase(),
+          accessed_at: new Date().toISOString(),
+          trust_score: cacheData?.report?.trust_score?.score || null,
+          product_name: cacheData?.report?.product_name || entityName,
+          vendor: cacheData?.report?.vendor || null,
+        }),
+      },
+      { merge: true }
+    );
+
+    return Response.json({
+      success: true,
+      message: "Accessed report saved successfully",
+    });
+  } catch (error) {
+    console.error("Error saving accessed report:", error);
+    return Response.json(
+      {
+        error: "Internal server error",
+        details: error instanceof Error ? error.message : "Unknown error",
+      },
+      { status: 500 }
+    );
+  }
+}
+
+// GET endpoint to fetch user's accessed reports
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const userId = searchParams.get("userId");
+
+    if (!userId) {
+      return Response.json({ error: "userId is required" }, { status: 400 });
+    }
+
+    const userDoc = await adminDb.collection("users").doc(userId).get();
+
+    if (!userDoc.exists) {
+      return Response.json({
+        accessed_reports: [],
+      });
+    }
+
+    const userData = userDoc.data();
+    const accessedReports = userData?.accessed_reports || [];
+
+    // Fetch full report details from cache for each accessed report
+    const reportsWithDetails = await Promise.all(
+      accessedReports.map(async (access: any) => {
+        const cacheDoc = await adminDb
+          .collection("cache")
+          .doc(access.entity_name)
+          .get();
+
+        if (cacheDoc.exists) {
+          return {
+            ...access,
+            report: cacheDoc.data()?.report,
+            cached_at: cacheDoc.data()?.cached_at,
+          };
+        }
+
+        return access;
+      })
+    );
+
+    return Response.json({
+      accessed_reports: reportsWithDetails,
+    });
+  } catch (error) {
+    console.error("Error fetching accessed reports:", error);
+    return Response.json(
+      {
+        error: "Internal server error",
+        details: error instanceof Error ? error.message : "Unknown error",
+      },
+      { status: 500 }
+    );
+  }
+}

junction-app/app/dashboard/page.tsx

@@ -61,7 +61,25 @@ export default function DashboardPage() {
     }
   };
 
-  const handleStreamComplete = () => {
+  const handleStreamComplete = async () => {
+    // Save accessed report to user's collection
+    if (user && streamingEntityName) {
+      try {
+        await fetch("/api/user/accessed-reports", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            userId: user.uid,
+            entityName: streamingEntityName,
+          }),
+        });
+      } catch (error) {
+        console.error("Error saving accessed report:", error);
+      }
+    }
+
     // Redirect to reports page after streaming completes
     router.push("/reports");
   };