Add missing API endpoints for contributor, messaging, and RAG

scripts/migrate-data.ts

@@ -136,6 +136,80 @@ interface MongoChatHistory {
     createdAt?: Date | string;
 }
 
+interface MongoMentor {
+    _id?: ObjectId;
+    id?: string;
+    userId: string;
+    username: string;
+    expertiseLevel?: string;
+    availabilityHoursPerWeek?: number;
+    timezone?: string;
+    isActive?: boolean;
+    bio?: string;
+    avatarUrl?: string;
+    techStack?: string[];
+    languages?: string[];
+    frameworks?: string[];
+    preferredTopics?: string[];
+    menteeCount?: number;
+    sessionsCompleted?: number;
+    avgRating?: number;
+    totalRatings?: number;
+    maxMentees?: number;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+}
+
+interface MongoTrophy {
+    _id?: ObjectId;
+    id?: string;
+    userId: string;
+    username: string;
+    trophyType: string;
+    name: string;
+    description: string;
+    icon: string;
+    color: string;
+    rarity: string;
+    svgData?: string;
+    isPublic?: boolean;
+    shareUrl?: string;
+    earnedFor?: string;
+    milestoneValue?: number;
+    awardedAt?: Date | string;
+}
+
+interface MongoIssueChat {
+    _id?: ObjectId;
+    id?: string;
+    issueId: string;
+    userId: string;
+    sessionId: string;
+    messages?: MongoChatMessage[];
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+}
+
+interface MongoResource {
+    _id?: ObjectId;
+    id?: string;
+    repoName: string;
+    sourceType?: string;
+    sourceId?: string;
+    resourceType: string;
+    title: string;
+    content: string;
+    description?: string;
+    language?: string;
+    sharedBy: string;
+    sharedById: string;
+    tags?: string[];
+    saveCount?: number;
+    helpfulCount?: number;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+}
+
 // =============================================================================
 // Utilities
 // =============================================================================
@@ -551,6 +625,264 @@ async function migrateChatHistory(
     log(`Chat Messages: ${messageSuccess} migrated, ${messageSkipped} skipped`, "success");
 }
 
+async function migrateMentors(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<Map<string, string>> {
+    log("Migrating Mentors...");
+    const mentorIdMap = new Map<string, string>();
+    const mentors = await mongoDb.collection<MongoMentor>("mentors").find().toArray();
+    log(`Found ${mentors.length} mentors`);
+
+    let success = 0, skipped = 0;
+    for (const mentor of mentors) {
+        const mentorId = extractId(mentor);
+        const originalId = mentor._id?.toString() || mentor.id || "";
+        mentorIdMap.set(originalId, mentorId);
+
+        const mappedUserId = userIdMap.get(mentor.userId) || mentor.userId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.mentors).values({
+                    id: mentorId,
+                    userId: mappedUserId,
+                    username: mentor.username,
+                    expertiseLevel: mentor.expertiseLevel || "intermediate",
+                    availabilityHoursPerWeek: mentor.availabilityHoursPerWeek || 5,
+                    timezone: mentor.timezone || null,
+                    isActive: mentor.isActive ?? true,
+                    bio: mentor.bio || null,
+                    avatarUrl: mentor.avatarUrl || null,
+                    menteeCount: mentor.menteeCount || 0,
+                    sessionsCompleted: mentor.sessionsCompleted || 0,
+                    avgRating: mentor.avgRating || 0,
+                    totalRatings: mentor.totalRatings || 0,
+                    maxMentees: mentor.maxMentees || 3,
+                    createdAt: toIsoString(mentor.createdAt),
+                    updatedAt: toIsoString(mentor.updatedAt),
+                }).onConflictDoNothing();
+
+                // Migrate tech stack
+                if (mentor.techStack?.length) {
+                    for (const tech of mentor.techStack) {
+                        await tursoDb.insert(schema.mentorTechStack).values({
+                            mentorId: mentorId,
+                            tech: tech,
+                        }).onConflictDoNothing();
+                    }
+                }
+
+                // Migrate languages
+                if (mentor.languages?.length) {
+                    for (const lang of mentor.languages) {
+                        await tursoDb.insert(schema.mentorLanguages).values({
+                            mentorId: mentorId,
+                            language: lang,
+                        }).onConflictDoNothing();
+                    }
+                }
+
+                // Migrate frameworks
+                if (mentor.frameworks?.length) {
+                    for (const fw of mentor.frameworks) {
+                        await tursoDb.insert(schema.mentorFrameworks).values({
+                            mentorId: mentorId,
+                            framework: fw,
+                        }).onConflictDoNothing();
+                    }
+                }
+
+                // Migrate preferred topics
+                if (mentor.preferredTopics?.length) {
+                    for (const topic of mentor.preferredTopics) {
+                        await tursoDb.insert(schema.mentorPreferredTopics).values({
+                            mentorId: mentorId,
+                            topic: topic,
+                        }).onConflictDoNothing();
+                    }
+                }
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            log(`[DRY] Mentor: ${mentor.username}`);
+            success++;
+        }
+    }
+    log(`Mentors: ${success} migrated, ${skipped} skipped`, "success");
+    return mentorIdMap;
+}
+
+async function migrateTrophies(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Trophies...");
+    const trophies = await mongoDb.collection<MongoTrophy>("trophies").find().toArray();
+    log(`Found ${trophies.length} trophies`);
+
+    let success = 0, skipped = 0;
+    for (const trophy of trophies) {
+        const trophyId = extractId(trophy);
+        const mappedUserId = userIdMap.get(trophy.userId) || trophy.userId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.trophies).values({
+                    id: trophyId,
+                    userId: mappedUserId,
+                    username: trophy.username,
+                    trophyType: trophy.trophyType,
+                    name: trophy.name,
+                    description: trophy.description,
+                    icon: trophy.icon,
+                    color: trophy.color,
+                    rarity: trophy.rarity,
+                    svgData: trophy.svgData || null,
+                    isPublic: trophy.isPublic ?? true,
+                    shareUrl: trophy.shareUrl || null,
+                    earnedFor: trophy.earnedFor || null,
+                    milestoneValue: trophy.milestoneValue || null,
+                    awardedAt: toIsoString(trophy.awardedAt),
+                }).onConflictDoNothing();
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            log(`[DRY] Trophy: ${trophy.name} for ${trophy.username}`);
+            success++;
+        }
+    }
+    log(`Trophies: ${success} migrated, ${skipped} skipped`, "success");
+}
+
+async function migrateIssueChats(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    issueIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Issue Chats...");
+    const issueChats = await mongoDb.collection<MongoIssueChat>("issue_chats").find().toArray();
+    log(`Found ${issueChats.length} issue chats`);
+
+    let chatSuccess = 0, chatSkipped = 0;
+    let msgSuccess = 0, msgSkipped = 0;
+
+    for (const chat of issueChats) {
+        const chatId = extractId(chat);
+        const mappedUserId = userIdMap.get(chat.userId) || chat.userId;
+        const mappedIssueId = issueIdMap.get(chat.issueId) || chat.issueId;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.issueChats).values({
+                    id: chatId,
+                    issueId: mappedIssueId,
+                    userId: mappedUserId,
+                    sessionId: chat.sessionId,
+                    createdAt: toIsoString(chat.createdAt),
+                    updatedAt: toIsoString(chat.updatedAt),
+                }).onConflictDoNothing();
+                chatSuccess++;
+
+                // Migrate messages
+                if (chat.messages?.length) {
+                    for (const msg of chat.messages) {
+                        const msgId = uuidv4();
+                        try {
+                            await tursoDb.insert(schema.issueChatMessages).values({
+                                id: msgId,
+                                issueChatId: chatId,
+                                role: msg.role,
+                                content: msg.content,
+                                timestamp: toIsoString(msg.timestamp),
+                                githubCommentId: msg.githubCommentId || null,
+                                githubCommentUrl: msg.githubCommentUrl || null,
+                            }).onConflictDoNothing();
+                            msgSuccess++;
+                        } catch (e) {
+                            msgSkipped++;
+                        }
+                    }
+                }
+            } catch (e) {
+                chatSkipped++;
+            }
+        } else {
+            log(`[DRY] Issue Chat: ${chatId} with ${chat.messages?.length || 0} messages`);
+            chatSuccess++;
+            msgSuccess += chat.messages?.length || 0;
+        }
+    }
+    log(`Issue Chats: ${chatSuccess} migrated, ${chatSkipped} skipped`, "success");
+    log(`Issue Chat Messages: ${msgSuccess} migrated, ${msgSkipped} skipped`, "success");
+}
+
+async function migrateResources(
+    mongoDb: ReturnType<MongoClient["db"]>,
+    tursoDb: ReturnType<typeof drizzle>,
+    userIdMap: Map<string, string>,
+    isDryRun: boolean
+): Promise<void> {
+    log("Migrating Resources...");
+    const resources = await mongoDb.collection<MongoResource>("resources").find().toArray();
+    log(`Found ${resources.length} resources`);
+
+    let success = 0, skipped = 0;
+    for (const resource of resources) {
+        const resourceId = extractId(resource);
+        const mappedUserId = userIdMap.get(resource.sharedById) || resource.sharedById;
+
+        if (!isDryRun) {
+            try {
+                await tursoDb.insert(schema.resources).values({
+                    id: resourceId,
+                    repoName: resource.repoName,
+                    sourceType: resource.sourceType || "chat",
+                    sourceId: resource.sourceId || null,
+                    resourceType: resource.resourceType,
+                    title: resource.title,
+                    content: resource.content,
+                    description: resource.description || null,
+                    language: resource.language || null,
+                    sharedBy: resource.sharedBy,
+                    sharedById: mappedUserId,
+                    saveCount: resource.saveCount || 0,
+                    helpfulCount: resource.helpfulCount || 0,
+                    createdAt: toIsoString(resource.createdAt),
+                    updatedAt: toIsoString(resource.updatedAt),
+                }).onConflictDoNothing();
+
+                // Migrate tags
+                if (resource.tags?.length) {
+                    for (const tag of resource.tags) {
+                        await tursoDb.insert(schema.resourceTags).values({
+                            resourceId: resourceId,
+                            tag: tag,
+                        }).onConflictDoNothing();
+                    }
+                }
+                success++;
+            } catch (e) {
+                skipped++;
+            }
+        } else {
+            log(`[DRY] Resource: ${resource.title}`);
+            success++;
+        }
+    }
+    log(`Resources: ${success} migrated, ${skipped} skipped`, "success");
+}
+
 // =============================================================================
 // Main
 // =============================================================================
@@ -599,6 +931,12 @@ async function main() {
         await migrateTemplates(mongoDb, tursoDb, userIdMap, isDryRun);
         await migrateChatHistory(mongoDb, tursoDb, userIdMap, isDryRun);
 
+        // New migrations for complete feature support
+        const mentorIdMap = await migrateMentors(mongoDb, tursoDb, userIdMap, isDryRun);
+        await migrateTrophies(mongoDb, tursoDb, userIdMap, isDryRun);
+        await migrateIssueChats(mongoDb, tursoDb, userIdMap, issueIdMap, isDryRun);
+        await migrateResources(mongoDb, tursoDb, userIdMap, isDryRun);
+
         log("=== Migration Complete ===", "success");
         if (isDryRun) {
             log("Run without --dry-run to perform actual migration", "info");

scripts/migrate-mongo-to-turso.ts

@@ -1,314 +0,0 @@
-/**
- * MongoDB to Turso Migration Script
- * 
- * One-way data migration from MongoDB Atlas to Turso (SQLite).
- * MongoDB data remains unchanged as a read-only backup.
- * 
- * Usage:
- *   npm run migrate:mongo
- *   npm run migrate:mongo -- --dry-run    (preview only)
- * 
- * Required environment variables:
- *   MONGODB_URI - MongoDB Atlas connection string
- *   TURSO_DATABASE_URL - Turso database URL
- *   TURSO_AUTH_TOKEN - Turso auth token
- */
-
-import { MongoClient } from "mongodb";
-import { createClient } from "@libsql/client";
-import { drizzle } from "drizzle-orm/libsql";
-import * as schema from "../src/db/schema";
-import { v4 as uuidv4 } from "uuid";
-import * as dotenv from "dotenv";
-
-// Load environment variables
-dotenv.config({ path: ".env.local" });
-
-// ============================================================================
-// Types for MongoDB Documents
-// ============================================================================
-
-interface MongoUser {
-    _id?: { toString(): string };
-    id?: string;
-    githubId: number;
-    username: string;
-    avatarUrl: string;
-    role?: string;
-    repositories?: string[];
-    githubAccessToken?: string;
-    createdAt?: Date | string;
-    updatedAt?: Date | string;
-}
-
-interface MongoRepository {
-    _id?: { toString(): string };
-    id?: string;
-    githubRepoId: number;
-    name: string;
-    owner: string;
-    userId: string;
-    createdAt?: Date | string;
-}
-
-interface MongoIssue {
-    _id?: { toString(): string };
-    id?: string;
-    githubIssueId: number;
-    number: number;
-    title: string;
-    body?: string;
-    authorName: string;
-    repoId: string;
-    repoName: string;
-    owner?: string;
-    repo?: string;
-    htmlUrl?: string;
-    state?: string;
-    isPR?: boolean;
-    createdAt?: Date | string;
-}
-
-// ============================================================================
-// Utility Functions
-// ============================================================================
-
-function toIsoString(date: Date | string | undefined): string {
-    if (!date) return new Date().toISOString();
-    if (typeof date === "string") return date;
-    return date.toISOString();
-}
-
-function extractId(doc: { _id?: { toString(): string }; id?: string }): string {
-    // Prefer existing UUID id, otherwise convert ObjectId
-    if (doc.id) return doc.id;
-    if (doc._id) return doc._id.toString();
-    return uuidv4();
-}
-
-function log(message: string, type: "info" | "success" | "error" | "warn" = "info") {
-    const icons = { info: "ℹ️", success: "✅", error: "❌", warn: "⚠️" };
-    console.log(`${icons[type]} ${message}`);
-}
-
-// ============================================================================
-// Migration Functions
-// ============================================================================
-
-async function migrateUsers(
-    mongoDb: ReturnType<MongoClient["db"]>,
-    tursoDb: ReturnType<typeof drizzle>,
-    isDryRun: boolean
-): Promise<Map<string, string>> {
-    log("Migrating Users...");
-    const userIdMap = new Map<string, string>();
-
-    const users = await mongoDb.collection<MongoUser>("users").find().toArray();
-    log(`Found ${users.length} users to migrate`);
-
-    for (const mongoUser of users) {
-        const userId = extractId(mongoUser);
-        userIdMap.set(mongoUser._id?.toString() || mongoUser.id || "", userId);
-
-        const tursoUser = {
-            id: userId,
-            githubId: mongoUser.githubId,
-            username: mongoUser.username,
-            avatarUrl: mongoUser.avatarUrl,
-            role: mongoUser.role || null,
-            githubAccessToken: mongoUser.githubAccessToken || null,
-            createdAt: toIsoString(mongoUser.createdAt),
-            updatedAt: toIsoString(mongoUser.updatedAt),
-        };
-
-        if (!isDryRun) {
-            try {
-                await tursoDb.insert(schema.users).values(tursoUser).onConflictDoNothing();
-
-                // Migrate user repositories array to junction table
-                if (mongoUser.repositories && mongoUser.repositories.length > 0) {
-                    for (const repoFullName of mongoUser.repositories) {
-                        await tursoDb.insert(schema.userRepositories).values({
-                            id: uuidv4(),
-                            userId: userId,
-                            repoFullName: repoFullName,
-                            addedAt: toIsoString(mongoUser.createdAt),
-                        }).onConflictDoNothing();
-                    }
-                }
-            } catch (error) {
-                log(`Failed to insert user ${mongoUser.username}: ${error}`, "error");
-            }
-        } else {
-            log(`[DRY RUN] Would insert user: ${mongoUser.username} (${userId})`);
-        }
-    }
-
-    log(`Migrated ${users.length} users`, "success");
-    return userIdMap;
-}
-
-async function migrateRepositories(
-    mongoDb: ReturnType<MongoClient["db"]>,
-    tursoDb: ReturnType<typeof drizzle>,
-    userIdMap: Map<string, string>,
-    isDryRun: boolean
-): Promise<Map<string, string>> {
-    log("Migrating Repositories...");
-    const repoIdMap = new Map<string, string>();
-
-    const repos = await mongoDb.collection<MongoRepository>("repositories").find().toArray();
-    log(`Found ${repos.length} repositories to migrate`);
-
-    for (const mongoRepo of repos) {
-        const repoId = extractId(mongoRepo);
-        repoIdMap.set(mongoRepo._id?.toString() || mongoRepo.id || "", repoId);
-
-        // Map old userId to new userId
-        const mappedUserId = userIdMap.get(mongoRepo.userId) || mongoRepo.userId;
-
-        const tursoRepo = {
-            id: repoId,
-            githubRepoId: mongoRepo.githubRepoId,
-            name: mongoRepo.name,
-            owner: mongoRepo.owner,
-            userId: mappedUserId,
-            createdAt: toIsoString(mongoRepo.createdAt),
-        };
-
-        if (!isDryRun) {
-            try {
-                await tursoDb.insert(schema.repositories).values(tursoRepo).onConflictDoNothing();
-            } catch (error) {
-                log(`Failed to insert repo ${mongoRepo.owner}/${mongoRepo.name}: ${error}`, "error");
-            }
-        } else {
-            log(`[DRY RUN] Would insert repo: ${mongoRepo.owner}/${mongoRepo.name} (${repoId})`);
-        }
-    }
-
-    log(`Migrated ${repos.length} repositories`, "success");
-    return repoIdMap;
-}
-
-async function migrateIssues(
-    mongoDb: ReturnType<MongoClient["db"]>,
-    tursoDb: ReturnType<typeof drizzle>,
-    repoIdMap: Map<string, string>,
-    isDryRun: boolean
-): Promise<void> {
-    log("Migrating Issues...");
-
-    const issues = await mongoDb.collection<MongoIssue>("issues").find().toArray();
-    log(`Found ${issues.length} issues to migrate`);
-
-    let successCount = 0;
-    let errorCount = 0;
-
-    for (const mongoIssue of issues) {
-        const issueId = extractId(mongoIssue);
-
-        // Map old repoId to new repoId
-        const mappedRepoId = repoIdMap.get(mongoIssue.repoId) || mongoIssue.repoId;
-
-        const tursoIssue = {
-            id: issueId,
-            githubIssueId: mongoIssue.githubIssueId,
-            number: mongoIssue.number,
-            title: mongoIssue.title,
-            body: mongoIssue.body || null,
-            authorName: mongoIssue.authorName,
-            repoId: mappedRepoId,
-            repoName: mongoIssue.repoName,
-            owner: mongoIssue.owner || null,
-            repo: mongoIssue.repo || null,
-            htmlUrl: mongoIssue.htmlUrl || null,
-            state: mongoIssue.state || "open",
-            isPR: mongoIssue.isPR || false,
-            createdAt: toIsoString(mongoIssue.createdAt),
-        };
-
-        if (!isDryRun) {
-            try {
-                await tursoDb.insert(schema.issues).values(tursoIssue).onConflictDoNothing();
-                successCount++;
-            } catch (error) {
-                log(`Failed to insert issue #${mongoIssue.number}: ${error}`, "error");
-                errorCount++;
-            }
-        } else {
-            log(`[DRY RUN] Would insert issue: #${mongoIssue.number} - ${mongoIssue.title.substring(0, 40)}...`);
-            successCount++;
-        }
-    }
-
-    log(`Migrated ${successCount} issues (${errorCount} errors)`, successCount > 0 ? "success" : "warn");
-}
-
-// ============================================================================
-// Main Migration Entry Point
-// ============================================================================
-
-async function main() {
-    const args = process.argv.slice(2);
-    const isDryRun = args.includes("--dry-run");
-
-    if (isDryRun) {
-        log("Running in DRY RUN mode - no data will be written", "warn");
-    }
-
-    // Validate environment variables
-    const mongoUri = process.env.MONGODB_URI;
-    const tursoUrl = process.env.TURSO_DATABASE_URL;
-    const tursoToken = process.env.TURSO_AUTH_TOKEN;
-
-    if (!mongoUri) {
-        log("Missing MONGODB_URI environment variable", "error");
-        process.exit(1);
-    }
-    if (!tursoUrl) {
-        log("Missing TURSO_DATABASE_URL environment variable", "error");
-        process.exit(1);
-    }
-
-    log("Starting MongoDB to Turso migration...");
-    log(`MongoDB URI: ${mongoUri.replace(/\/\/[^:]+:[^@]+@/, "//***:***@")}`);
-    log(`Turso URL: ${tursoUrl}`);
-
-    // Connect to MongoDB
-    log("Connecting to MongoDB Atlas...");
-    const mongoClient = new MongoClient(mongoUri);
-    await mongoClient.connect();
-    const mongoDb = mongoClient.db();
-    log("Connected to MongoDB", "success");
-
-    // Connect to Turso
-    log("Connecting to Turso...");
-    const tursoClient = createClient({
-        url: tursoUrl,
-        authToken: tursoToken,
-    });
-    const tursoDb = drizzle(tursoClient, { schema });
-    log("Connected to Turso", "success");
-
-    try {
-        // Run migrations in order (respecting foreign key relationships)
-        const userIdMap = await migrateUsers(mongoDb, tursoDb, isDryRun);
-        const repoIdMap = await migrateRepositories(mongoDb, tursoDb, userIdMap, isDryRun);
-        await migrateIssues(mongoDb, tursoDb, repoIdMap, isDryRun);
-
-        log("Migration completed successfully!", "success");
-
-        if (isDryRun) {
-            log("This was a dry run. Run without --dry-run to perform actual migration.", "info");
-        }
-    } catch (error) {
-        log(`Migration failed: ${error}`, "error");
-        process.exit(1);
-    } finally {
-        await mongoClient.close();
-        log("Closed MongoDB connection");
-    }
-}
-
-main().catch(console.error);

src/app/api/maintainer/issues/route.ts

@@ -0,0 +1,44 @@
+/**
+ * Maintainer Issues Route
+ * 
+ * GET /api/maintainer/issues
+ * Fetch issues for a maintainer with filtering and pagination.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getIssues, getIssuesWithTriage, IssueFilters } from "@/lib/db/queries/issues";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const { searchParams } = new URL(request.url);
+        const page = parseInt(searchParams.get("page") || "1");
+        const limit = parseInt(searchParams.get("limit") || "10");
+        const state = searchParams.get("state") || undefined;
+        const repoId = searchParams.get("repoId") || undefined;
+        const search = searchParams.get("search") || undefined;
+        const withTriage = searchParams.get("withTriage") === "true";
+
+        const filters: IssueFilters = {
+            userId: user.id, // Filter by user's repos
+            state,
+            repoId,
+            search,
+            isPR: false, // Only fetch issues, not PRs
+        };
+
+        const result = withTriage
+            ? await getIssuesWithTriage(filters, page, limit)
+            : await getIssues(filters, page, limit);
+
+        return NextResponse.json(result);
+    } catch (error) {
+        console.error("GET /api/maintainer/issues error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/maintainer/templates/route.ts

@@ -0,0 +1,25 @@
+/**
+ * Maintainer Templates Route
+ * 
+ * GET /api/maintainer/templates
+ * Fetch templates for a maintainer.
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { getTemplatesByOwnerId } from "@/lib/db/queries/templates";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        const templates = await getTemplatesByOwnerId(user.id);
+        return NextResponse.json(templates);
+    } catch (error) {
+        console.error("GET /api/maintainer/templates error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { profileConnectedRepos } from "@/db/schema";
+import { eq } from "drizzle-orm";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ id: string }> }
+) {
+    try {
+        const { 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));
+
+        return NextResponse.json(repos);
+    } 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]/featured-badges/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getUserBadges } from "@/lib/db/queries/gamification";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const badges = await getUserBadges(username);
+        // For now, just return top 5 badges as "featured"
+        // In the future, we could add a "featured" flag to the trophy table
+        const featured = badges.slice(0, 5);
+
+        return NextResponse.json(featured);
+    } catch (error) {
+        console.error("GET /api/profile/:username/featured-badges error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

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

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/db";
+import { repositories, users } from "@/db/schema";
+import { eq, desc } from "drizzle-orm";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+
+        // Find user first to get ID
+        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 });
+        }
+
+        const repos = await db
+            .select()
+            .from(repositories)
+            .where(eq(repositories.userId, user[0].id))
+            .orderBy(desc(repositories.createdAt));
+
+        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/profile/[username]/route.ts

@@ -0,0 +1,19 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getProfileByUsername } from "@/lib/db/queries/users";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const profile = await getProfileByUsername(username);
+        if (!profile) {
+            return NextResponse.json({ error: "Profile not found" }, { status: 404 });
+        }
+        return NextResponse.json(profile);
+    } catch (error) {
+        console.error("GET /api/profile/:username error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/repositories/route.ts

@@ -11,16 +11,26 @@ import { eq, and, desc, count, sql } from "drizzle-orm";
 // Python equivalent (from routes/repository.py):
 //   repos = await db.repositories.find({"userId": user['id']}, {"_id": 0}).to_list(1000)
 //
+import { getCurrentUser } from "@/lib/auth";
+
+// ...
+
 export async function GET(request: NextRequest) {
     try {
         const { searchParams } = new URL(request.url);
-        const userId = searchParams.get("userId");
+        let userId = searchParams.get("userId");
 
+        // If no userId provided, try to get the current authenticated user
         if (!userId) {
-            return NextResponse.json(
-                { error: "userId is required" },
-                { status: 400 }
-            );
+            const currentUser = await getCurrentUser(request);
+            if (currentUser) {
+                userId = currentUser.id;
+            } else {
+                return NextResponse.json(
+                    { error: "userId is required or you must be logged in" },
+                    { status: 401 }
+                );
+            }
         }
 
         const repos = await db

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

@@ -0,0 +1,16 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getUserBadges } from "@/lib/db/queries/gamification";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const badges = await getUserBadges(username);
+        return NextResponse.json(badges);
+    } catch (error) {
+        console.error("GET /api/spark/badges/user/:username error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/spark/gamification/calendar/[username]/route.ts

@@ -0,0 +1,16 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getUserCalendar } from "@/lib/db/queries/gamification";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const calendar = await getUserCalendar(username);
+        return NextResponse.json(calendar);
+    } catch (error) {
+        console.error("GET /api/spark/gamification/calendar/:username error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/app/api/spark/gamification/streak/[username]/route.ts

@@ -0,0 +1,16 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getUserStreak } from "@/lib/db/queries/gamification";
+
+export async function GET(
+    request: NextRequest,
+    context: { params: Promise<{ username: string }> }
+) {
+    try {
+        const { username } = await context.params;
+        const streak = await getUserStreak(username);
+        return NextResponse.json(streak);
+    } catch (error) {
+        console.error("GET /api/spark/gamification/streak/:username error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/lib/db/queries/gamification.ts

@@ -0,0 +1,74 @@
+/**
+ * Gamification Queries - Drizzle ORM
+ */
+
+import { db } from "@/db";
+import { trophies, users, issues } from "@/db/schema";
+import { eq, desc, and, count, not, sql } from "drizzle-orm";
+
+// =============================================================================
+// Badges / Trophies
+// =============================================================================
+
+export async function getUserBadges(username: string) {
+    const user = await db.select().from(users).where(eq(users.username, username)).limit(1);
+    if (!user[0]) return [];
+
+    return db.select()
+        .from(trophies)
+        .where(eq(trophies.userId, user[0].id))
+        .orderBy(desc(trophies.awardedAt));
+}
+
+// =============================================================================
+// Streak
+// =============================================================================
+
+export async function getUserStreak(username: string) {
+    // This is a simplified streak calculation based on issue/PR creation dates
+    // In a real app, you might want to track daily activity explicitly
+
+    const user = await db.select().from(users).where(eq(users.username, username)).limit(1);
+    if (!user[0]) return { currentStreak: 0, longestStreak: 0 };
+
+    const activity = await db.select({
+        createdAt: issues.createdAt
+    })
+        .from(issues)
+        .leftJoin(users, eq(issues.authorName, users.username)) // Assuming authorName matches username
+        .where(eq(users.username, username))
+        .orderBy(desc(issues.createdAt));
+
+    if (activity.length === 0) return { currentStreak: 0, longestStreak: 0 };
+
+    // Calculate streak logic here (simplified for now)
+    // For now returning mock data or simple calculation as true streak logic can be complex
+    // pending actual "daily activity" table
+
+    return {
+        currentStreak: 0,
+        longestStreak: 0
+    };
+}
+
+// =============================================================================
+// Clean Calendar Data
+// =============================================================================
+
+export async function getUserCalendar(username: string) {
+    const user = await db.select().from(users).where(eq(users.username, username)).limit(1);
+    if (!user[0]) return [];
+
+    // Aggregate issues created by day
+    const activity = await db.select({
+        day: sql<string>`substr(${issues.createdAt}, 1, 10)`,
+        value: count()
+    })
+        .from(issues)
+        .leftJoin(users, eq(issues.authorName, users.username))
+        .where(eq(users.username, username))
+        .groupBy(sql`substr(${issues.createdAt}, 1, 10)`)
+        .orderBy(sql`day`);
+
+    return activity;
+}