apply new changes

src/app/api/contributor/dashboard-summary/route.ts

@@ -8,102 +8,67 @@
 import { NextRequest, NextResponse } from "next/server";
 import { getCurrentUser } from "@/lib/auth";
 import { db } from "@/db";
-import { issues, userRepositories, users } from "@/db/schema";
+import { issues } from "@/db/schema";
 import { eq } from "drizzle-orm";
-import { fetchGitHubContributions } from "@/lib/github-contributions";
 
 export async function GET(request: NextRequest) {
     try {
         const user = await getCurrentUser(request);
         if (!user) {
+            console.log("[Dashboard Summary] No authenticated user");
             return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
         }
 
         console.log("[Dashboard Summary] User:", user.username);
 
-        // Fetch GitHub contributions in parallel with local data
-        console.log("[Dashboard Summary] Starting parallel queries...");
-        const [allItems, trackedRepos, userRecord, githubData] = await Promise.all([
-            // Get all issues/PRs by this contributor from the database
-            (async () => {
-                console.log("[Dashboard Summary] Fetching issues...");
-                const items = await db.select().from(issues).where(eq(issues.authorName, user.username));
-                console.log("[Dashboard Summary] Found %d issues", items.length);
-                return items;
-            })(),
-            // Get tracked repos
-            (async () => {
-                console.log("[Dashboard Summary] Fetching tracked repos...");
-                const repos = await db.select({ repoFullName: userRepositories.repoFullName })
-                    .from(userRepositories)
-                    .where(eq(userRepositories.userId, user.id));
-                console.log("[Dashboard Summary] Found %d tracked repos", repos.length);
-                return repos;
-            })(),
-            // Get user's GitHub token
-            (async () => {
-                console.log("[Dashboard Summary] Fetching user token...");
-                const userData = await db.select({ githubAccessToken: users.githubAccessToken })
-                    .from(users)
-                    .where(eq(users.id, user.id))
-                    .limit(1);
-                console.log("[Dashboard Summary] User token fetch complete");
-                return userData;
-            })(),
-            // Fetch GitHub contributions (will use cache or make API call)
-            (async () => {
-                console.log("[Dashboard Summary] Fetching GitHub contributions...");
-                const ghData = await fetchGitHubContributions(user.username, null).catch(err => {
-                    console.log("[Dashboard Summary] GitHub fetch failed:", err);
-                    return null;
-                });
-                return ghData;
-            })()
-        ]);
+        // Fetch all contributor data from the database
+        try {
+            console.log("[Dashboard Summary] Fetching issues for user:", user.username);
+            const allItems = await db.select().from(issues).where(eq(issues.authorName, user.username));
+            console.log("[Dashboard Summary] Found %d items", allItems.length);
 
-        // Calculate metrics from database records
-        const prs = allItems.filter(item => item.isPR);
-        const issueItems = allItems.filter(item => !item.isPR);
+            // Calculate metrics from database records
+            const prs = allItems.filter(item => item.isPR);
+            const issueItems = allItems.filter(item => !item.isPR);
 
-        // PR metrics
-        const openPRs = prs.filter(pr => pr.state === 'open').length;
-        const mergedPRs = prs.filter(pr => pr.state === 'closed').length;
+            // PR metrics
+            const openPRs = prs.filter(pr => pr.state === 'open').length;
+            const mergedPRs = prs.filter(pr => pr.state === 'closed').length;
 
-        // Issue metrics
-        const openIssues = issueItems.filter(i => i.state === 'open').length;
-        const closedIssues = issueItems.filter(i => i.state === 'closed').length;
+            // Issue metrics
+            const openIssues = issueItems.filter(i => i.state === 'open').length;
+            const closedIssues = issueItems.filter(i => i.state === 'closed').length;
 
-        // Get unique repositories contributed to
-        const uniqueRepos = new Set(allItems.map(item => item.repoName).filter(Boolean));
-        for (const tracked of trackedRepos) {
-            uniqueRepos.add(tracked.repoFullName);
-        }
-
-        // Use GitHub API totalContributions if available, otherwise fallback to local count
-        const totalContributions = githubData?.totalContributions ?? allItems.length;
-        const dataSource = githubData ? 'github' : 'local';
+            // Get unique repositories contributed to
+            const uniqueRepos = new Set(allItems.map(item => item.repoName).filter(Boolean));
+            
+            console.log("[Dashboard Summary] Calculated: %d PRs, %d Issues, %d repos", prs.length, issueItems.length, uniqueRepos.size);
 
-        return NextResponse.json({
-            totalContributions,
-            totalPRs: prs.length,
-            openPRs,
-            mergedPRs,
-            totalIssues: issueItems.length,
-            openIssues,
-            closedIssues,
-            repositoriesContributed: uniqueRepos.size,
-            repositories: Array.from(uniqueRepos),
-            source: dataSource,  // Indicates where the totalContributions came from
-        });
+            return NextResponse.json({
+                totalContributions: allItems.length,
+                totalPRs: prs.length,
+                openPRs,
+                mergedPRs: prs.length - openPRs,
+                totalIssues: issueItems.length,
+                openIssues,
+                closedIssues: issueItems.length - openIssues,
+                repositoriesContributed: uniqueRepos.size,
+                repositories: Array.from(uniqueRepos),
+            });
+        } catch (dbError: any) {
+            console.error("[Dashboard Summary] Database error:", dbError);
+            console.error("[Dashboard Summary] Error message:", dbError?.message);
+            throw dbError;
+        }
 
     } catch (error: any) {
-        console.error("Contributor dashboard-summary error:", error);
-        console.error("Error stack:", error?.stack);
-        console.error("Error message:", error?.message);
+        console.error("[Dashboard Summary] Error:", error);
+        console.error("[Dashboard Summary] Error message:", error?.message);
+        console.error("[Dashboard Summary] Error stack:", error?.stack);
 
         return NextResponse.json({
-            error: "Failed to fetch dashboard data. Please try again.",
-            details: error?.message || "Unknown error"
+            error: "Failed to fetch dashboard data",
+            details: error?.message || "Internal server error"
         }, { status: 500 });
     }
 }

src/db/index.ts

@@ -32,25 +32,39 @@ let _db: LibSQLDatabase<typeof schema> | null = null;
 
 function getClient(): Client {
     if (!_client) {
+        // Check environment variables
+        if (!process.env.TURSO_DATABASE_URL) {
+            console.error("[DB] TURSO_DATABASE_URL not set. Using file-only mode.");
+        }
+        if (!process.env.TURSO_AUTH_TOKEN) {
+            console.warn("[DB] TURSO_AUTH_TOKEN not set. Remote sync will not work.");
+        }
+
         // Determine replica path (works on Hugging Face Spaces and local)
         const replicaPath = process.env.REPLICA_DB_PATH || path.join(process.cwd(), "replica.db");
         
         console.log(`[DB] Setting up Turso Embedded Replicas:`);
         console.log(`  • Local replica: ${replicaPath}`);
-        console.log(`  • Remote sync: ${process.env.TURSO_DATABASE_URL?.slice(0, 30)}...`);
+        console.log(`  • Remote sync URL: ${process.env.TURSO_DATABASE_URL?.slice(0, 30)}...`);
         console.log(`  • Sync interval: ${process.env.SYNC_INTERVAL || "60"}s`);
         
-        _client = createClient({
-            // Local embedded replica for fast reads
-            url: `file:${replicaPath}`,
-            // Remote Turso database for syncing
-            syncUrl: process.env.TURSO_DATABASE_URL!,
-            authToken: process.env.TURSO_AUTH_TOKEN,
-            // Sync interval: 60 seconds (adjust as needed)
-            syncInterval: parseInt(process.env.SYNC_INTERVAL || "60"),
-            // Optional: Encryption key for replica (if you want encrypted local storage)
-            encryptionKey: process.env.REPLICA_ENCRYPTION_KEY,
-        });
+        try {
+            _client = createClient({
+                // Local embedded replica for fast reads
+                url: `file:${replicaPath}`,
+                // Remote Turso database for syncing (optional)
+                syncUrl: process.env.TURSO_DATABASE_URL,
+                authToken: process.env.TURSO_AUTH_TOKEN,
+                // Sync interval: 60 seconds (adjust as needed)
+                syncInterval: parseInt(process.env.SYNC_INTERVAL || "60"),
+                // Optional: Encryption key for replica (if you want encrypted local storage)
+                encryptionKey: process.env.REPLICA_ENCRYPTION_KEY,
+            });
+            console.log("[DB] ✅ Client initialized successfully");
+        } catch (error: any) {
+            console.error("[DB] ❌ Failed to initialize client:", error?.message);
+            throw error;
+        }
     }
     return _client;
 }
@@ -99,9 +113,16 @@ export async function getReplicaStatus(): Promise<{
 
 export const db = new Proxy({} as LibSQLDatabase<typeof schema>, {
     get(_target, prop, receiver) {
-        if (!_db) {
-            _db = drizzle(getClient(), { schema });
+        try {
+            if (!_db) {
+                const client = getClient();
+                _db = drizzle(client, { schema });
+                console.log("[DB] ✅ Drizzle instance initialized");
+            }
+            return Reflect.get(_db, prop, receiver);
+        } catch (error: any) {
+            console.error("[DB Proxy] Error:", error?.message);
+            throw error;
         }
-        return Reflect.get(_db, prop, receiver);
     },
 });

src/lib/db/queries/issues.ts

@@ -204,78 +204,102 @@ export async function getIssuesWithTriage(filters: IssueFilters, page = 1, limit
 
     console.log("[getIssuesWithTriage] Starting query with filters:", filters, "page:", page, "limit:", limit);
 
-    // Build conditions (identical to getIssues)
-    const conditions = [];
-    if (filters.repoId) conditions.push(eq(issues.repoId, filters.repoId));
-    if (filters.repoName) conditions.push(eq(issues.repoName, filters.repoName));
-    if (filters.authorName) conditions.push(eq(issues.authorName, filters.authorName));
-    if (filters.state) conditions.push(eq(issues.state, filters.state));
-    if (filters.isPR !== undefined) conditions.push(eq(issues.isPR, filters.isPR));
-    if (filters.search) {
-        conditions.push(or(
-            like(issues.title, `%${filters.search}%`),
-            like(issues.bodySummary, `%${filters.search}%`)
-        ));
-    }
-
-    if (filters.userId) {
-        const userRepos = await db.select({ id: repositories.id })
-            .from(repositories)
-            .where(and(
-                eq(repositories.userId, filters.userId),
-                eq(repositories.addedByUser, true)
+    try {
+        // Build conditions (identical to getIssues)
+        const conditions = [];
+        if (filters.repoId) conditions.push(eq(issues.repoId, filters.repoId));
+        if (filters.repoName) conditions.push(eq(issues.repoName, filters.repoName));
+        if (filters.authorName) conditions.push(eq(issues.authorName, filters.authorName));
+        if (filters.state) conditions.push(eq(issues.state, filters.state));
+        if (filters.isPR !== undefined) conditions.push(eq(issues.isPR, filters.isPR));
+        if (filters.search) {
+            conditions.push(or(
+                like(issues.title, `%${filters.search}%`),
+                like(issues.bodySummary, `%${filters.search}%`)
             ));
-        const repoIds = userRepos.map(r => r.id);
-
-        if (repoIds.length > 0) {
-            conditions.push(sql`${issues.repoId} IN (${sql.join(repoIds.map(id => sql`'${id}'`), sql`, `)})`);
-        } else {
-            return { issues: [], total: 0, page: safePage, limit, totalPages: 0 };
         }
-    }
-
-    const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
-
-    console.log("[getIssuesWithTriage] Built where clause, fetching count...");
-
-    // Get total count
-    const countResult = await db.select({ count: count() })
-        .from(issues)
-        .where(whereClause);
-    const total = countResult[0]?.count || 0;
-    const totalPages = Math.ceil(total / limit);
-
-    console.log("[getIssuesWithTriage] Total count:", total, "totalPages:", totalPages);
-
-    // ✅ Single JOIN query: issues LEFT JOIN triageData
-    // Database executes this in one round-trip, no N+1
-    console.log("[getIssuesWithTriage] Executing JOIN query...");
-    const results = await db.select({
-        issue: issues,
-        triage: triageData,
-    })
-        .from(issues)
-        .leftJoin(triageData, eq(triageData.issueId, issues.id))
-        .where(whereClause)
-        .orderBy(desc(issues.createdAt))
-        .limit(limit)
-        .offset(offset);
 
-    console.log("[getIssuesWithTriage] Query returned %d results", results.length);
+        if (filters.userId) {
+            const userRepos = await db.select({ id: repositories.id })
+                .from(repositories)
+                .where(and(
+                    eq(repositories.userId, filters.userId),
+                    eq(repositories.addedByUser, true)
+                ));
+            const repoIds = userRepos.map(r => r.id);
+
+            if (repoIds.length > 0) {
+                conditions.push(sql`${issues.repoId} IN (${sql.join(repoIds.map(id => sql`'${id}'`), sql`, `)})`);
+            } else {
+                return { issues: [], total: 0, page: safePage, limit, totalPages: 0 };
+            }
+        }
 
-    // Transform [ {issue, triage}, {issue, triage}, ... ] into [ {issue, triage}, ... ]
-    const issuesWithTriage = results.map(row => ({
-        ...row.issue,
-        triage: row.triage || null,
-    }));
+        const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+
+        console.log("[getIssuesWithTriage] Built where clause, fetching count...");
+
+        // Get total count
+        const countResult = await db.select({ count: count() })
+            .from(issues)
+            .where(whereClause);
+        const total = countResult[0]?.count || 0;
+        const totalPages = Math.ceil(total / limit);
+
+        console.log("[getIssuesWithTriage] Total count:", total, "totalPages:", totalPages);
+
+        // Fetch issues using simple query
+        console.log("[getIssuesWithTriage] Executing issues query...");
+        const issueResults = await db.select()
+            .from(issues)
+            .where(whereClause)
+            .orderBy(desc(issues.createdAt))
+            .limit(limit)
+            .offset(offset);
+
+        console.log("[getIssuesWithTriage] Query returned %d results", issueResults.length);
+
+        // Fetch triage data for these issues
+        if (issueResults.length === 0) {
+            return {
+                issues: [],
+                total,
+                page: safePage,
+                limit,
+                totalPages,
+            };
+        }
 
-    return {
-        issues: issuesWithTriage,
-        total,
-        page: safePage,
-        limit,
-        totalPages,
-    };
+        console.log("[getIssuesWithTriage] Fetching triage data for %d issues", issueResults.length);
+        const issueIds = issueResults.map(i => i.id);
+        const triageDataResults = await db.select()
+            .from(triageData)
+            .where(sql`${triageData.issueId} IN (${sql.join(issueIds.map(id => sql`'${id}'`), sql`, `)})`);
+
+        console.log("[getIssuesWithTriage] Found %d triage records", triageDataResults.length);
+
+        // Create a map of triage data by issueId for quick lookup
+        const triageMap = new Map(triageDataResults.map(t => [t.issueId, t]));
+
+        // Merge issues with their triage data
+        const issuesWithTriage = issueResults.map(issue => ({
+            ...issue,
+            triage: triageMap.get(issue.id) || null,
+        }));
+
+        return {
+            issues: issuesWithTriage,
+            total,
+            page: safePage,
+            limit,
+            totalPages,
+        };
+    } catch (error: any) {
+        console.error("[getIssuesWithTriage] Query failed:", error);
+        console.error("[getIssuesWithTriage] Error message:", error?.message);
+        console.error("[getIssuesWithTriage] Error stack:", error?.stack);
+        throw error;
+    }
 }
 
 // =============================================================================