fix(scoring): persist canonical scores and update commitlint config

- Persist canonical unfiltered scores to database in compare and user profile endpoints
- Normalize Redis cache invalidation keys for country leaderboards
- Disable body and footer line length limits in commitlint configuration
- Add unit tests for canonical score persistence

Author: O2sa

app/api/compare/route.ts

@@ -349,36 +349,41 @@ async function compareUsers(
 
     // ── Fire-and-forget: detect country & upsert into DB ──────────────
     const country = detectCountry(data.location);
-    if (country) {
+    if (country && process.env.DATABASE_URL?.trim()) {
       const staleDays = parseInt(process.env.GITHUB_USER_STALE_DAYS ?? "14", 10);
-
-      const db = getDatabaseStore();
-      db.upsertUser({
-        username: data.login,
-        name: data.name,
-        avatarUrl: data.avatarUrl,
-        location: data.location,
-        country,
-        rawData: data,
-        scores: score,
-        repoScore: Math.round(score.repoScore),
-        prScore: Math.round(score.prScore),
-        contributionScore: Math.round(score.contributionScore),
-        finalScore: Math.round(score.finalScore),
-        staleDays,
-      })
-        .then(() => {
-          // Invalidate Redis cache for this country
-          const cacheConfig = getCacheConfigFromEnv();
-          const cacheStore = createCacheStore(cacheConfig);
-          if (cacheStore.enabled && cacheStore.del) {
-            const key = `${cacheConfig.namespace}:leaderboard:${country}`;
-            cacheStore.del(key).catch(() => {});
-          }
+      const dbScore = selectedLanguages.length > 0 ? calculateUserScore(data, data.login) : score;
+
+      try {
+        const db = getDatabaseStore();
+        db.upsertUser({
+          username: data.login,
+          name: data.name,
+          avatarUrl: data.avatarUrl,
+          location: data.location,
+          country,
+          rawData: data,
+          scores: dbScore,
+          repoScore: Math.round(dbScore.repoScore),
+          prScore: Math.round(dbScore.prScore),
+          contributionScore: Math.round(dbScore.contributionScore),
+          finalScore: Math.round(dbScore.finalScore),
+          staleDays,
         })
-        .catch((err: unknown) => {
-          console.warn("Failed to upsert user from compare:", err);
-        });
+          .then(() => {
+            // Invalidate Redis cache for this country
+            const cacheConfig = getCacheConfigFromEnv();
+            const cacheStore = createCacheStore(cacheConfig);
+            if (cacheStore.enabled && cacheStore.del) {
+              const key = `${cacheConfig.namespace}:leaderboard:${country.trim().toLowerCase()}`;
+              cacheStore.del(key).catch(() => {});
+            }
+          })
+          .catch((err: unknown) => {
+            console.warn("Failed to upsert user from compare:", err);
+          });
+      } catch {
+        // Ignore DB connection errors in environments without DB
+      }
     }
   }
 

commitlint.config.mjs

@@ -1,3 +1,7 @@
 export default {
   extends: ["@commitlint/config-conventional"],
+  rules: {
+    "body-max-line-length": [0, "always"],
+    "footer-max-line-length": [0, "always"],
+  },
 };

lib/user.ts

@@ -76,6 +76,8 @@ export async function getUserProfile(
   const country = detectCountry(data.location);
   if (country && process.env.DATABASE_URL?.trim()) {
     const staleDays = parseInt(process.env.GITHUB_USER_STALE_DAYS ?? "14", 10);
+    const dbScore =
+      selectedLanguages.length > 0 ? calculateUserScore(data, normalizedUsername) : score;
 
     try {
       const db = getDatabaseStore();
@@ -86,11 +88,11 @@ export async function getUserProfile(
         location: data.location,
         country,
         rawData: data,
-        scores: score,
-        repoScore: Math.round(score.repoScore),
-        prScore: Math.round(score.prScore),
-        contributionScore: Math.round(score.contributionScore),
-        finalScore: Math.round(score.finalScore),
+        scores: dbScore,
+        repoScore: Math.round(dbScore.repoScore),
+        prScore: Math.round(dbScore.prScore),
+        contributionScore: Math.round(dbScore.contributionScore),
+        finalScore: Math.round(dbScore.finalScore),
         staleDays,
       })
         .then(() => {

test/api/compare.route.test.ts

@@ -4,6 +4,7 @@ import { GitHubApiError } from "@/lib/github-graphql-client";
 const mocks = vi.hoisted(() => ({
   getUserData: vi.fn(),
   calculateUserScore: vi.fn(),
+  upsertUser: vi.fn().mockResolvedValue(undefined),
 }));
 
 vi.mock("@/lib/github", () => ({
@@ -14,6 +15,12 @@ vi.mock("@/lib/score", () => ({
   calculateUserScore: mocks.calculateUserScore,
 }));
 
+vi.mock("@/lib/db-store", () => ({
+  getDatabaseStore: () => ({
+    upsertUser: mocks.upsertUser,
+  }),
+}));
+
 import { GET } from "@/app/api/compare/route";
 
 function makeRequest(params: Record<string, string | string[]>): Request {
@@ -293,4 +300,61 @@ describe("GET /api/compare", () => {
     expect(body.errorDetails?.code).toBe("GITHUB_NOT_FOUND");
     expect(body.errorDetails?.targetUsernames).toEqual(["missing-user"]);
   });
+
+  test("persists canonical unfiltered score to db even when selectedLanguage is specified", async () => {
+    process.env.DATABASE_URL = "postgresql://test:test@localhost:5432/test";
+    mocks.upsertUser.mockClear();
+
+    const userA = makeUser("user-a", "User A");
+    const userB = makeUser("user-b", "User B");
+
+    mocks.getUserData.mockResolvedValueOnce({
+      data: userA,
+      metrics: { duration: 0, errors: [] },
+    });
+    mocks.getUserData.mockResolvedValueOnce({
+      data: userB,
+      metrics: { duration: 0, errors: [] },
+    });
+
+    const filteredScoreA = makeScore(20, makeLanguageScores(15));
+    const canonicalScoreA = makeScore(50);
+    const filteredScoreB = makeScore(10, makeLanguageScores(8));
+    const canonicalScoreB = makeScore(40);
+
+    mocks.calculateUserScore
+      .mockReturnValueOnce(filteredScoreA)
+      .mockReturnValueOnce(canonicalScoreA)
+      .mockReturnValueOnce(filteredScoreB)
+      .mockReturnValueOnce(canonicalScoreB);
+
+    const response = await GET(
+      makeRequest({
+        username: ["user-a", "user-b"],
+        selectedLanguage: "TypeScript",
+      }),
+    );
+
+    expect(response.status).toBe(200);
+    expect(mocks.upsertUser).toHaveBeenCalledTimes(2);
+
+    expect(mocks.upsertUser).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({
+        username: "user-a",
+        scores: canonicalScoreA,
+        finalScore: 50,
+      }),
+    );
+    expect(mocks.upsertUser).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        username: "user-b",
+        scores: canonicalScoreB,
+        finalScore: 40,
+      }),
+    );
+
+    delete process.env.DATABASE_URL;
+  });
 });

test/api/user.route.test.ts

@@ -4,6 +4,7 @@ import { GitHubApiError } from "@/lib/github-graphql-client";
 const mocks = vi.hoisted(() => ({
   getUserData: vi.fn(),
   calculateUserScore: vi.fn(),
+  upsertUser: vi.fn().mockResolvedValue(undefined),
 }));
 
 vi.mock("@/lib/github", () => ({
@@ -14,6 +15,12 @@ vi.mock("@/lib/score", () => ({
   calculateUserScore: mocks.calculateUserScore,
 }));
 
+vi.mock("@/lib/db-store", () => ({
+  getDatabaseStore: () => ({
+    upsertUser: mocks.upsertUser,
+  }),
+}));
+
 import { GET } from "@/app/api/user/[username]/route";
 import { getUserProfile } from "@/lib/user";
 
@@ -209,4 +216,34 @@ describe("GET /api/user/[username]", () => {
     expect(result.user.topRepos.length).toBe(1);
     expect(result.user.signals?.reposAnalyzed).toBe(10);
   });
+
+  test("persists canonical unfiltered score to db even when selectedLanguages is provided", async () => {
+    process.env.DATABASE_URL = "postgresql://test:test@localhost:5432/test";
+    mocks.upsertUser.mockClear();
+
+    const rawUser = makeUser("octocat", "The Octocat");
+    mocks.getUserData.mockResolvedValueOnce({
+      data: rawUser,
+      metrics: { duration: 50, errors: [] },
+    });
+
+    const filteredScore = makeScore(30);
+    const canonicalScore = makeScore(70);
+
+    mocks.calculateUserScore.mockReturnValueOnce(filteredScore).mockReturnValueOnce(canonicalScore);
+
+    const result = await getUserProfile("octocat", ["TypeScript"]);
+
+    expect(result.user.finalScore).toBe(30);
+    expect(mocks.upsertUser).toHaveBeenCalledTimes(1);
+    expect(mocks.upsertUser).toHaveBeenCalledWith(
+      expect.objectContaining({
+        username: "octocat",
+        scores: canonicalScore,
+        finalScore: 70,
+      }),
+    );
+
+    delete process.env.DATABASE_URL;
+  });
 });