Merge branch 'main' into test/verify-cache-for-date-instance-values-1

JhaSourav07 · web-flow · commit 811947a56765 · 2026-06-01T03:04:38.000+05:30
diff --git a/app/api/notify/route.test.ts b/app/api/notify/route.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { NextRequest } from 'next/server';
 import { GET, POST } from './route';
+import dbConnect from '@/lib/mongodb';
 
 // Mock dependencies
 vi.mock('@/lib/mongodb', () => ({ default: vi.fn() }));
@@ -88,6 +89,7 @@ describe('POST /api/notify', () => {
     expect(res.status).toBe(400);
     const data = await res.json();
     expect(data.message).toContain('Malformed JSON');
+    expect(dbConnect).not.toHaveBeenCalled();
   });
 
   // ── Rate limiting ────────────────────────────────────────────────────────
diff --git a/app/api/track-user/route.ts b/app/api/track-user/route.ts
@@ -4,8 +4,12 @@ import { User } from '@/models/User';
 import { trackUserRateLimiter } from '@/lib/rate-limit';
 
 export async function POST(req: Request) {
-  // Get IP for rate limiting
-  const ip = req.headers.get('x-forwarded-for') || req.headers.get('x-real-ip') || 'unknown';
+  // Get IP for rate limiting.
+  // x-real-ip is provided by Vercel/Nginx as the true client IP.
+  // We fall back to the LAST IP in the x-forwarded-for chain, which is appended by the Vercel proxy.
+  const forwardedFor = req.headers.get('x-forwarded-for');
+  const fallbackIp = forwardedFor ? forwardedFor.split(',').pop()?.trim() : 'unknown';
+  const ip = req.headers.get('x-real-ip') || fallbackIp || 'unknown';
 
   if (ip !== 'unknown' && !(await trackUserRateLimiter.check(ip))) {
     return NextResponse.json(
diff --git a/app/layout.tsx b/app/layout.tsx
@@ -66,8 +66,26 @@ export const metadata: Metadata = {
 
 export default function RootLayout({ children }: { children: React.ReactNode }) {
   return (
-    <html lang="en">
-      <body className={`${inter.className} bg-black`}>
+    <html lang="en" suppressHydrationWarning>
+      <head>
+        <script
+          dangerouslySetInnerHTML={{
+            __html: `
+              try {
+                const storedTheme = window.localStorage.getItem('theme');
+                if (storedTheme === 'light') {
+                  document.documentElement.classList.remove('dark');
+                  document.documentElement.style.colorScheme = 'light';
+                } else {
+                  document.documentElement.classList.add('dark');
+                  document.documentElement.style.colorScheme = 'dark';
+                }
+              } catch (_) {}
+            `,
+          }}
+        />
+      </head>
+      <body className={inter.className}>
         <ScrollRestoration />
         <BrandParticles />
         <Navbar />
diff --git a/lib/cache.test.ts b/lib/cache.test.ts
@@ -409,11 +409,15 @@ describe('TTLCache', () => {
       const matrix = [
         [1, 2],
         [3, 4],
+        [5, 6],
       ];
 
       cache.set('matrix', matrix, 60_000);
 
-      expect(cache.get('matrix')).toEqual(matrix);
+      const cached = cache.get('matrix');
+
+      expect(cached).toEqual(matrix);
+      expect(cached?.[2]?.[1]).toBe(6);
 
       cache.destroy();
     });
@@ -545,6 +549,34 @@ describe('TTLCache', () => {
       cache.destroy();
     });
 
+    it('verify TTLCache behavior for empty string keys (Variation 2)', () => {
+      const cache = new TTLCache<string>();
+
+      // Assert that setting a value with empty string key throws error
+      expect(() => {
+        cache.set('', 'test-value', 60_000);
+      }).toThrow(Error);
+
+      // Verify the error message is correct
+      expect(() => {
+        cache.set('', 'test-value', 60_000);
+      }).toThrow('Cache key cannot be empty');
+
+      // Verify that cache remains empty (no entry for empty key)
+      expect(cache.has('')).toBe(false);
+      expect(cache.get('')).toBeNull();
+
+      // Verify cache size is still 0
+      expect(cache.size()).toBe(0);
+
+      // Verify that normal operations still work after failed attempt
+      cache.set('valid-key', 'value', 60_000);
+      expect(cache.get('valid-key')).toBe('value');
+      expect(cache.size()).toBe(1);
+
+      cache.destroy();
+    });
+
     it('handles rapid get/set/delete cycles', () => {
       const cache = new TTLCache<number>();
       for (let i = 0; i < 100; i++) {
diff --git a/lib/github.test.ts b/lib/github.test.ts
@@ -1527,6 +1527,83 @@ describe('GitHub API cache behavior', () => {
 
     expect(fetch).toHaveBeenCalledTimes(1);
   });
+
+  it('cache hit: second fetchContributedRepos call uses cached value', async () => {
+    const mockNodes = [{ name: 'cached-repo' }];
+    vi.mocked(fetch).mockResolvedValue(
+      mockResponse({
+        data: {
+          user: {
+            repositoriesContributedTo: {
+              nodes: mockNodes,
+            },
+          },
+        },
+      })
+    );
+
+    await fetchContributedRepos('octocat');
+    await fetchContributedRepos('octocat');
+
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('dedupes concurrent fetchContributedRepos requests for the same cold cache key', async () => {
+    let resolveFetch!: (response: Response) => void;
+    vi.mocked(fetch).mockImplementation(
+      () =>
+        new Promise<Response>((resolve) => {
+          resolveFetch = resolve;
+        })
+    );
+
+    const requests = Promise.all([
+      fetchContributedRepos('octocat'),
+      fetchContributedRepos('octocat'),
+      fetchContributedRepos('octocat'),
+    ]);
+
+    await vi.waitFor(() => expect(fetch).toHaveBeenCalledTimes(1));
+
+    resolveFetch(
+      mockResponse({
+        data: {
+          user: {
+            repositoriesContributedTo: {
+              nodes: [{ name: 'deduped-repo' }],
+            },
+          },
+        },
+      })
+    );
+
+    const results = await requests;
+    expect(results.map((repos) => repos[0]?.name)).toEqual([
+      'deduped-repo',
+      'deduped-repo',
+      'deduped-repo',
+    ]);
+  });
+
+  it('refresh bypass: bypassCache=true forces fresh fetchContributedRepos fetch', async () => {
+    const mockNodes = [{ name: 'repo' }];
+    vi.mocked(fetch).mockImplementation(async () =>
+      mockResponse({
+        data: {
+          user: {
+            repositoriesContributedTo: {
+              nodes: mockNodes,
+            },
+          },
+        },
+      })
+    );
+
+    await fetchContributedRepos('octocat');
+    await fetchContributedRepos('octocat', { bypassCache: true });
+
+    expect(fetch).toHaveBeenCalledTimes(2);
+  });
 });
 
 describe('generateAchievements', () => {
diff --git a/lib/github.ts b/lib/github.ts
@@ -250,9 +250,11 @@ export const GITHUB_CACHE_TTL_MS = 5 * 60 * 1000;
 const contributionsCache = new DistributedCache<ExtendedContributionData>(1000);
 const profileCache = new DistributedCache<GitHubUserProfile>(1000);
 const reposCache = new DistributedCache<GitHubRepo[]>(500);
+const contributedReposCache = new DistributedCache<Record<string, unknown>[]>(500);
 const pendingContributions = new Map<string, Promise<ExtendedContributionData>>();
 const pendingProfiles = new Map<string, Promise<GitHubUserProfile>>();
 const pendingRepos = new Map<string, Promise<GitHubRepo[]>>();
+const pendingContributedRepos = new Map<string, Promise<Record<string, unknown>[]>>();
 
 interface GitHubUserProfile {
   login: string;
@@ -269,18 +271,18 @@ interface GitHubUserProfile {
 }
 
 export function cacheKey(
-  kind: 'contributions' | 'profile' | 'repos',
+  kind: 'contributions' | 'profile' | 'repos' | 'repos:contributed',
   username: string,
   year?: string
 ): string;
 export function cacheKey(
-  kind: 'contributions' | 'profile' | 'repos',
+  kind: 'contributions' | 'profile' | 'repos' | 'repos:contributed',
   username: string,
   from?: string,
   to?: string
 ): string;
 export function cacheKey(
-  kind: 'contributions' | 'profile' | 'repos',
+  kind: 'contributions' | 'profile' | 'repos' | 'repos:contributed',
   username: string,
   yearOrFrom?: string,
   to?: string
@@ -297,9 +299,11 @@ export function clearGitHubApiCacheForTests(): void {
   contributionsCache.clear();
   profileCache.clear();
   reposCache.clear();
+  contributedReposCache.clear();
   pendingContributions.clear();
   pendingProfiles.clear();
   pendingRepos.clear();
+  pendingContributedRepos.clear();
 }
 
 function dedupeRequest<T>(
@@ -940,38 +944,54 @@ export async function fetchContributedRepos(
   username: string,
   options: FetchOptions = {}
 ): Promise<Record<string, unknown>[]> {
-  const query = `
-    query($login: String!) {
-      user(login: $login) {
-        repositoriesContributedTo(first: 100, contributionTypes: [COMMIT, ISSUE, PULL_REQUEST, REPOSITORY], orderBy: {field: UPDATED_AT, direction: DESC}) {
-          nodes {
-            name
-            nameWithOwner
-            owner { login }
-            stargazerCount
-            forkCount
-            primaryLanguage { name }
-            updatedAt
+  const key = cacheKey('repos:contributed', username);
+  if (!options.bypassCache) {
+    const cached = await contributedReposCache.get(key);
+    if (cached) return cached;
+  }
+
+  const load = async () => {
+    const query = `
+      query($login: String!) {
+        user(login: $login) {
+          repositoriesContributedTo(first: 100, contributionTypes: [COMMIT, ISSUE, PULL_REQUEST, REPOSITORY], orderBy: {field: UPDATED_AT, direction: DESC}) {
+            nodes {
+              name
+              nameWithOwner
+              owner { login }
+              stargazerCount
+              forkCount
+              primaryLanguage { name }
+              updatedAt
+            }
           }
         }
       }
-    }
-  `;
+    `;
 
-  const res = await fetchWithRetry(GITHUB_GRAPHQL_URL, {
-    method: 'POST',
-    headers: getHeaders(),
-    body: JSON.stringify({
-      query,
-      variables: { login: username },
-    }),
-    cache: 'no-store',
-    signal: options.signal,
-  });
+    const res = await fetchWithRetry(GITHUB_GRAPHQL_URL, {
+      method: 'POST',
+      headers: getHeaders(),
+      body: JSON.stringify({
+        query,
+        variables: { login: username },
+      }),
+      cache: 'no-store',
+      signal: options.signal,
+    });
+
+    if (!res.ok) return [];
+    const data = await res.json();
+    const result = data?.data?.user?.repositoriesContributedTo?.nodes || [];
+
+    if (!options.bypassCache) {
+      await contributedReposCache.set(key, result, GITHUB_CACHE_TTL_MS);
+    }
+    return result;
+  };
 
-  if (!res.ok) return [];
-  const data = await res.json();
-  return data?.data?.user?.repositoriesContributedTo?.nodes || [];
+  if (options.bypassCache) return load();
+  return dedupeRequest(pendingContributedRepos, key, load);
 }
 
 export interface DeveloperScoreInput {
diff --git a/lib/svg/generator.test.ts b/lib/svg/generator.test.ts
@@ -14,6 +14,7 @@ import {
 } from './generator';
 import type { BadgeParams, ContributionCalendar, StreakStats, MonthlyStats } from '../../types';
 import { hexColor } from './sanitizer';
+import { themes } from './themes';
 
 describe('generateSVG', () => {
   const mockStats: StreakStats = {
@@ -868,6 +869,29 @@ describe('generateSVG', () => {
       expect(svg).not.toContain('ABCDEFGHIJKLMNOPQRSTUVWXYZ');
     });
   });
+
+  describe('verify all supported themes produce valid SVG output', () => {
+    it('generates a valid SVG and contains the theme accent color for each supported theme', () => {
+      for (const theme of Object.values(themes)) {
+        const svg = generateSVG(
+          mockStats,
+          {
+            user: 'octocat',
+            bg: theme.bg,
+            text: theme.text,
+            accent: theme.accent,
+            speed: '8s',
+            scale: 'linear',
+          } as unknown as BadgeParams,
+          mockCalendar
+        );
+
+        expect(svg).toContain('<svg');
+        expect(svg).toContain('</svg>');
+        expect(svg.toLowerCase()).toContain(theme.accent.toLowerCase());
+      }
+    });
+  });
 });
 
 describe('generateMonthlySVG', () => {
diff --git a/lib/svg/layout.test.ts b/lib/svg/layout.test.ts
@@ -223,22 +223,22 @@ it('assigns correct row and col values based on week/day position', () => {
     weeks: [
       {
         contributionDays: [
+          { contributionCount: 1, date: '2024-06-09' },
           { contributionCount: 1, date: '2024-06-10' },
           { contributionCount: 1, date: '2024-06-11' },
-          { contributionCount: 1, date: '2024-06-12' },
         ],
       },
       {
         contributionDays: [
-          { contributionCount: 1, date: '2024-06-13' },
-          { contributionCount: 1, date: '2024-06-14' },
-          { contributionCount: 1, date: '2024-06-15' },
+          { contributionCount: 1, date: '2024-06-16' },
+          { contributionCount: 1, date: '2024-06-17' },
+          { contributionCount: 1, date: '2024-06-18' },
         ],
       },
     ],
   } as unknown as ContributionCalendar;
 
-  const towers = computeTowers(calendar, 'linear', '2024-06-15');
+  const towers = computeTowers(calendar, 'linear', '2024-06-18');
 
   expect(towers[0].row).toBe(0);
   expect(towers[0].col).toBe(0);
diff --git a/lib/svg/layout.ts b/lib/svg/layout.ts
diff --git a/lib/validations.test.ts b/lib/validations.test.ts
diff --git a/package-lock.json b/package-lock.json
