fix(leaderboard): restore all-time points to the codev_points ledger

All-time totals regressed in ce3a3d4, which switched every time filter to
recompute points from the tasks table. codev_points is an append-only ledger
written when a task is approved; tasks is mutable. Recomputing all-time totals
from tasks therefore dropped points whose originating task was later deleted,
un-archived, or had its skill_category cleared or changed, so the all-time
leaderboard under-reported. This shipped to production in the #610 release.

Restores the all-time branch in both the technical and project leaderboard
routes to read codev_points, matching pre-regression behaviour and the totals
still used by the dashboards, developer levels, and the /profiles showcase gate.

Weekly and monthly views are unchanged: they keep deriving from approved tasks
via approved_at and the Monday-start getWeekRange/getMonthRange helpers, which
was the sound part of ce3a3d4. No data migration is needed — the ledger still
holds the original values, this was a read-path regression only.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: deocagunot

apps/codebility/app/api/project-leaderboard/route.ts

@@ -35,8 +35,87 @@ export async function GET(request: NextRequest) {
 
     let processedLeaders: ProjectLeader[] = [];
 
-    // The tasks table is the single source of truth for points to ensure consistency
-    // across all-time, monthly, and weekly leaderboards.
+    // All-time totals come from the codev_points ledger via project membership, NOT from
+    // the tasks table. codev_points is append-only; the tasks table is mutable, so
+    // recomputing all-time totals from tasks silently drops points whose originating task
+    // was later deleted, un-archived, or had its skill_category cleared. Time-ranged views
+    // below still derive from tasks, where the approval date is the whole point.
+    if (timeFilter === "all") {
+      const { data: rawData, error: allTimeError } = await supabase
+        .from("projects")
+        .select(`
+          id,
+          name,
+          project_members(
+            codev_id,
+            codev_points(
+              points,
+              skill_category:skill_category_id(name)
+            )
+          )
+        `);
+
+      if (allTimeError) {
+        console.error("Error fetching all-time project leaderboard:", allTimeError);
+        return NextResponse.json(
+          { error: "Failed to fetch leaderboard data", details: allTimeError.message },
+          { status: 500 }
+        );
+      }
+
+      const allTimeMap = new Map<string, {
+        project_id: string;
+        project_name: string;
+        total_points: number;
+        members: Set<string>;
+        skill_breakdown: Record<string, number>;
+      }>();
+
+      rawData?.forEach((project: any) => {
+        const projectId = project.id;
+        if (!projectId) return;
+
+        if (!allTimeMap.has(projectId)) {
+          allTimeMap.set(projectId, {
+            project_id: projectId,
+            project_name: project.name || "Unknown Project",
+            total_points: 0,
+            members: new Set(),
+            skill_breakdown: {}
+          });
+        }
+        const projectData = allTimeMap.get(projectId)!;
+
+        project.project_members?.forEach((member: any) => {
+          if (member.codev_id) projectData.members.add(member.codev_id);
+          member.codev_points?.forEach((point: any) => {
+            const skillName = point.skill_category?.name || "Other";
+            const val = point.points || 0;
+            projectData.total_points += val;
+            projectData.skill_breakdown[skillName] = (projectData.skill_breakdown[skillName] || 0) + val;
+          });
+        });
+      });
+
+      processedLeaders = Array.from(allTimeMap.values())
+        .map(p => ({
+          project_id: p.project_id,
+          project_name: p.project_name,
+          total_points: p.total_points,
+          member_count: p.members.size,
+          skill_breakdown: p.skill_breakdown
+        }))
+        .filter(p => p.total_points > 0)
+        .sort((a, b) => b.total_points - a.total_points)
+        .slice(0, limit);
+
+      return NextResponse.json({
+        leaders: processedLeaders,
+        totalCount: processedLeaders.length
+      });
+    }
+
+    // Weekly/monthly are derived from approved tasks within the requested window.
     let query = supabase
       .from("tasks")
       .select(`
@@ -53,7 +132,7 @@ export async function GET(request: NextRequest) {
     if (timeFilter === "weekly") {
       const { startDate, endDate } = getWeekRange();
       query = query.gte("approved_at", startDate.toISOString()).lte("approved_at", endDate.toISOString());
-    } else if (timeFilter === "monthly") {
+    } else {
       const { startDate, endDate } = getMonthRange();
       query = query.gte("approved_at", startDate.toISOString()).lte("approved_at", endDate.toISOString());
     }

apps/codebility/app/api/technical-leaderboard/route.ts

@@ -35,8 +35,73 @@ export async function GET(request: NextRequest) {
 
     let processedLeaders: TechnicalLeader[] = [];
 
-    // The tasks table is the single source of truth for points to ensure consistency
-    // across all-time, monthly, and weekly leaderboards.
+    // All-time totals come from the codev_points ledger, NOT from the tasks table.
+    //
+    // codev_points is append-only: points are added when a task is approved and are
+    // never removed. The tasks table is mutable, so recomputing all-time totals from it
+    // silently drops every point whose originating task was later deleted, un-archived,
+    // or had its skill_category cleared — which is what caused the all-time leaderboard
+    // to under-report. Time-ranged views below still derive from tasks, where the
+    // approval date is the whole point of the query.
+    if (timeFilter === "all") {
+      const { data: rawPoints, error: pointsError } = await supabase
+        .from("codev_points")
+        .select(`
+          codev_id,
+          points,
+          created_at,
+          codev:codev_id!inner(first_name),
+          skill_category:skill_category_id!inner(name)
+        `)
+        .eq("skill_category.name", category)
+        .not("codev.first_name", "is", null);
+
+      if (pointsError) {
+        console.error("Error fetching all-time technical leaderboard:", pointsError);
+        return NextResponse.json(
+          { error: "Failed to fetch leaderboard data", details: pointsError.message },
+          { status: 500 }
+        );
+      }
+
+      // codev_points holds one row per (codev, skill category), but aggregate defensively
+      // in case duplicate rows exist for a pair.
+      const allTimeMap = new Map<string, TechnicalLeader>();
+
+      rawPoints?.forEach((entry: any) => {
+        const userId = entry.codev_id;
+        if (!userId) return;
+
+        const points = entry.points || 0;
+        const existing = allTimeMap.get(userId);
+
+        if (existing) {
+          existing.total_points += points;
+          if (entry.created_at && entry.created_at > existing.latest_update) {
+            existing.latest_update = entry.created_at;
+          }
+        } else {
+          allTimeMap.set(userId, {
+            codev_id: userId,
+            first_name: entry.codev?.first_name || "Unknown",
+            total_points: points,
+            latest_update: entry.created_at || new Date(0).toISOString()
+          });
+        }
+      });
+
+      processedLeaders = Array.from(allTimeMap.values())
+        .filter(leader => leader.total_points > 0)
+        .sort((a, b) => b.total_points - a.total_points)
+        .slice(0, limit);
+
+      return NextResponse.json({
+        leaders: processedLeaders,
+        totalCount: processedLeaders.length
+      });
+    }
+
+    // Weekly/monthly are derived from approved tasks within the requested window.
     let query = supabase
       .from("tasks")
       .select(`
@@ -53,7 +118,7 @@ export async function GET(request: NextRequest) {
     if (timeFilter === "weekly") {
       const { startDate, endDate } = getWeekRange();
       query = query.gte("approved_at", startDate.toISOString()).lte("approved_at", endDate.toISOString());
-    } else if (timeFilter === "monthly") {
+    } else {
       const { startDate, endDate } = getMonthRange();
       query = query.gte("approved_at", startDate.toISOString()).lte("approved_at", endDate.toISOString());
     }