Fix missing await for async AI service calls

src/app/api/profile/[username]/connect-repo/route.ts

@@ -0,0 +1,179 @@
+/**
+ * Connect Repository Route
+ * 
+ * POST /api/profile/{userId}/connect-repo
+ * Connect a GitHub repo for monitoring and import its issues
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { db } from "@/db";
+import { repositories, issues, users } from "@/db/schema";
+import { eq, and } from "drizzle-orm";
+import { generateId, now } from "@/lib/utils";
+import { createGitHubClient, fetchRepository } from "@/lib/github-client";
+
+export async function POST(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { username: userId } = await context.params;
+
+        // Verify user owns this profile
+        if (user.id !== userId) {
+            return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+        }
+
+        const body = await request.json();
+        const { repo_name } = body;
+
+        if (!repo_name) {
+            return NextResponse.json({ error: "repo_name is required" }, { status: 400 });
+        }
+
+        // Parse owner/repo from full name
+        const parts = repo_name.split('/');
+        const owner = parts.length > 1 ? parts[0] : user.username;
+        const repoName = parts.length > 1 ? parts[1] : parts[0];
+        const fullName = `${owner}/${repoName}`;
+
+        // Check if already connected
+        const existing = await db.select()
+            .from(repositories)
+            .where(and(
+                eq(repositories.name, fullName),
+                eq(repositories.userId, userId)
+            ))
+            .limit(1);
+
+        if (existing.length > 0) {
+            return NextResponse.json({
+                message: "Repository already connected",
+                repository: existing[0]
+            });
+        }
+
+        // Fetch repo info from GitHub
+        let githubRepoId = null;
+        if (user.githubAccessToken) {
+            try {
+                const octokit = createGitHubClient(user.githubAccessToken);
+                const repoData = await fetchRepository(octokit, owner, repoName);
+                githubRepoId = String(repoData.id);
+            } catch (e) {
+                console.warn("Could not fetch repo from GitHub:", e);
+            }
+        }
+
+        // Create repository record
+        const newRepo = {
+            id: generateId(),
+            githubRepoId: githubRepoId ? Number(githubRepoId) : Date.now(),
+            name: fullName,
+            owner,
+            userId,
+            createdAt: now(),
+        };
+
+        await db.insert(repositories).values(newRepo);
+
+        // Fetch and import issues from the repo
+        if (user.githubAccessToken) {
+            try {
+                const octokit = createGitHubClient(user.githubAccessToken);
+
+                // Fetch open issues
+                const { data: ghIssues } = await octokit.issues.listForRepo({
+                    owner,
+                    repo: repoName,
+                    state: 'open',
+                    per_page: 50,
+                });
+
+                // Import each issue
+                for (const ghIssue of ghIssues) {
+                    // Skip PRs in issues list
+                    if (ghIssue.pull_request) continue;
+
+                    const existingIssue = await db.select()
+                        .from(issues)
+                        .where(eq(issues.githubIssueId, ghIssue.id))
+                        .limit(1);
+
+                    if (existingIssue.length === 0) {
+                        await db.insert(issues).values({
+                            id: generateId(),
+                            githubIssueId: ghIssue.id,
+                            number: ghIssue.number,
+                            title: ghIssue.title,
+                            body: ghIssue.body || '',
+                            authorName: ghIssue.user?.login || 'unknown',
+                            repoId: newRepo.id,
+                            repoName: fullName,
+                            owner,
+                            repo: repoName,
+                            htmlUrl: ghIssue.html_url,
+                            state: ghIssue.state,
+                            isPR: false,
+                            createdAt: now(),
+                        });
+                    }
+                }
+
+                // Fetch open PRs
+                const { data: ghPRs } = await octokit.pulls.list({
+                    owner,
+                    repo: repoName,
+                    state: 'open',
+                    per_page: 50,
+                });
+
+                for (const ghPR of ghPRs) {
+                    const existingPR = await db.select()
+                        .from(issues)
+                        .where(eq(issues.githubIssueId, ghPR.id))
+                        .limit(1);
+
+                    if (existingPR.length === 0) {
+                        await db.insert(issues).values({
+                            id: generateId(),
+                            githubIssueId: ghPR.id,
+                            number: ghPR.number,
+                            title: ghPR.title,
+                            body: ghPR.body || '',
+                            authorName: ghPR.user?.login || 'unknown',
+                            repoId: newRepo.id,
+                            repoName: fullName,
+                            owner,
+                            repo: repoName,
+                            htmlUrl: ghPR.html_url,
+                            state: ghPR.state,
+                            isPR: true,
+                            createdAt: now(),
+                        });
+                    }
+                }
+
+                console.log(`Imported issues and PRs from ${fullName}`);
+            } catch (e) {
+                console.error("Error importing issues:", e);
+                // Don't fail the request, repo is still connected
+            }
+        }
+
+        return NextResponse.json({
+            message: "Repository connected successfully",
+            repository: newRepo
+        }, { status: 201 });
+
+    } catch (error) {
+        console.error("POST /api/profile/:id/connect-repo error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/profile/[username]/connected-repos/route.ts

@@ -1,6 +1,13 @@
+/**
+ * Connected Repositories Route
+ * 
+ * GET /api/profile/{userId}/connected-repos
+ * Get user's connected repositories
+ */
+
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/db";
-import { profileConnectedRepos } from "@/db/schema";
+import { repositories } from "@/db/schema";
 import { eq } from "drizzle-orm";
 
 export async function GET(
@@ -8,14 +15,17 @@ export async function GET(
     context: { params: Promise<{ username: string }> }
 ) {
     try {
-        const { username: id } = await context.params;
-        // 'id' here corresponds to the profile's userId (since userId is PK for profiles)
-        const repos = await db
-            .select()
-            .from(profileConnectedRepos)
-            .where(eq(profileConnectedRepos.profileId, id));
+        const { username: userId } = await context.params;
+
+        // Fetch repositories connected by this user
+        const repos = await db.select()
+            .from(repositories)
+            .where(eq(repositories.userId, userId));
 
-        return NextResponse.json(repos);
+        // Return list of repo names for simple display
+        return NextResponse.json({
+            repos: repos.map(r => r.name)
+        });
     } catch (error) {
         console.error("GET /api/profile/:id/connected-repos error:", error);
         return NextResponse.json({ error: "Internal server error" }, { status: 500 });

src/app/api/profile/[username]/disconnect-repo/route.ts

@@ -0,0 +1,52 @@
+/**
+ * Disconnect Repository Route
+ * 
+ * DELETE /api/profile/{userId}/disconnect-repo
+ * Disconnect a repository
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { db } from "@/db";
+import { repositories } from "@/db/schema";
+import { eq, and } from "drizzle-orm";
+
+export async function DELETE(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { username: userId } = await context.params;
+        const { searchParams } = new URL(request.url);
+        const repoName = searchParams.get("repo_name");
+
+        if (!repoName) {
+            return NextResponse.json({ error: "repo_name is required" }, { status: 400 });
+        }
+
+        // Verify user owns this profile
+        if (user.id !== userId) {
+            return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+        }
+
+        // Delete the repository
+        await db.delete(repositories)
+            .where(and(
+                eq(repositories.name, repoName),
+                eq(repositories.userId, userId)
+            ));
+
+        return NextResponse.json({
+            message: "Repository disconnected successfully"
+        });
+
+    } catch (error) {
+        console.error("DELETE /api/profile/:id/disconnect-repo error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/profile/[username]/repos/route.ts

@@ -1,7 +1,15 @@
+/**
+ * User Repositories Route
+ * 
+ * GET /api/profile/{username}/repos
+ * Fetch user's GitHub repositories
+ */
+
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/db";
-import { repositories, users } from "@/db/schema";
-import { eq, desc } from "drizzle-orm";
+import { users } from "@/db/schema";
+import { eq } from "drizzle-orm";
+import { createGitHubClient, fetchAllUserRepositories } from "@/lib/github-client";
 
 export async function GET(
     request: NextRequest,
@@ -10,20 +18,38 @@ export async function GET(
     try {
         const { username } = await context.params;
 
-        // Find user first to get ID
+        // Find user to get their GitHub token
         const user = await db.select().from(users).where(eq(users.username, username)).limit(1);
 
         if (!user[0]) {
-            return NextResponse.json({ error: "User not found" }, { status: 404 });
+            return NextResponse.json({ repos: [] });
         }
 
-        const repos = await db
-            .select()
-            .from(repositories)
-            .where(eq(repositories.userId, user[0].id))
-            .orderBy(desc(repositories.createdAt));
+        // If user has a GitHub token, fetch their repos from GitHub
+        if (user[0].githubAccessToken) {
+            try {
+                const octokit = createGitHubClient(user[0].githubAccessToken);
+                const repos = await fetchAllUserRepositories(octokit, username);
+
+                return NextResponse.json({
+                    repos: repos.map(repo => ({
+                        name: repo.full_name,
+                        description: repo.description,
+                        language: repo.language,
+                        stars: repo.stargazers_count,
+                        forks: repo.forks_count,
+                        url: repo.html_url,
+                        private: repo.private,
+                        updatedAt: repo.updated_at,
+                    }))
+                });
+            } catch (githubError) {
+                console.error("GitHub API error:", githubError);
+                // Fall through to return empty on error
+            }
+        }
 
-        return NextResponse.json(repos);
+        return NextResponse.json({ repos: [] });
     } catch (error) {
         console.error("GET /api/profile/:username/repos error:", error);
         return NextResponse.json({ error: "Internal server error" }, { status: 500 });

src/app/api/spark/badges/user/[username]/route.ts

@@ -1,5 +1,28 @@
+/**
+ * User Badges Route
+ * 
+ * GET /api/spark/badges/user/{username}
+ * Fetch user's badges/achievements
+ */
+
 import { NextRequest, NextResponse } from "next/server";
-import { getUserBadges } from "@/lib/db/queries/gamification";
+import { db } from "@/db";
+import { trophies, users } from "@/db/schema";
+import { eq, desc } from "drizzle-orm";
+
+// Badge definitions - these are the possible badges a user can earn
+const BADGE_DEFINITIONS = [
+    { id: 'first_pr', name: 'First Pull Request', description: 'Opened your first pull request', icon: '🎯', category: 'contribution' },
+    { id: 'first_issue', name: 'First Issue', description: 'Created your first issue', icon: '📝', category: 'contribution' },
+    { id: 'merged_pr', name: 'PR Merged', description: 'Had a pull request merged', icon: '🎉', category: 'contribution' },
+    { id: 'streak_7', name: '7 Day Streak', description: 'Contributed for 7 days in a row', icon: '🔥', category: 'streak' },
+    { id: 'streak_30', name: '30 Day Streak', description: 'Contributed for 30 days in a row', icon: '💪', category: 'streak' },
+    { id: 'contributor_10', name: '10 Contributions', description: 'Made 10 contributions', icon: '⭐', category: 'milestone' },
+    { id: 'contributor_50', name: '50 Contributions', description: 'Made 50 contributions', icon: '🌟', category: 'milestone' },
+    { id: 'contributor_100', name: '100 Contributions', description: 'Made 100 contributions', icon: '💯', category: 'milestone' },
+    { id: 'mentor', name: 'Mentor', description: 'Helped another contributor', icon: '🧑‍🏫', category: 'community' },
+    { id: 'reviewer', name: 'Code Reviewer', description: 'Reviewed pull requests', icon: '👀', category: 'contribution' },
+];
 
 export async function GET(
     request: NextRequest,
@@ -7,8 +30,35 @@ export async function GET(
 ) {
     try {
         const { username } = await context.params;
-        const badges = await getUserBadges(username);
-        return NextResponse.json(badges);
+
+        // Get user
+        const user = await db.select().from(users).where(eq(users.username, username)).limit(1);
+        if (!user[0]) {
+            return NextResponse.json({ all_badges: BADGE_DEFINITIONS, earned_badges: [] });
+        }
+
+        // Get earned trophies/badges from database
+        const earnedTrophies = await db.select()
+            .from(trophies)
+            .where(eq(trophies.userId, user[0].id))
+            .orderBy(desc(trophies.awardedAt));
+
+        // Map earned trophies to badge IDs
+        const earnedBadgeIds = new Set(earnedTrophies.map(t => t.trophyType));
+
+        // Mark badges as earned/not earned
+        const allBadges = BADGE_DEFINITIONS.map(badge => ({
+            ...badge,
+            earned: earnedBadgeIds.has(badge.id),
+            awardedAt: earnedTrophies.find(t => t.trophyType === badge.id)?.awardedAt || null,
+        }));
+
+        return NextResponse.json({
+            all_badges: allBadges,
+            earned_badges: allBadges.filter(b => b.earned),
+            total_earned: earnedTrophies.length,
+            total_possible: BADGE_DEFINITIONS.length,
+        });
     } catch (error) {
         console.error("GET /api/spark/badges/user/:username error:", error);
         return NextResponse.json({ error: "Internal server error" }, { status: 500 });