Merge branch 'main' into test/2279-feature-cards

Author: sheeeuWu

.github/scripts/check-duplicates.js

@@ -18,13 +18,13 @@ function cosineSimilarity(vecA, vecB) {
 
 async function run() {
   const geminiApiKey = process.env.GEMINI_API_KEY;
-  const githubToken = process.env.GITHUB_TOKEN;
+  const githubToken = process.env.GITHUB_PAT || process.env.GITHUB_TOKEN;
 
   if (!geminiApiKey) {
     throw new Error('❌ Missing GEMINI_API_KEY environment variable.');
   }
   if (!githubToken) {
-    throw new Error('❌ Missing GITHUB_TOKEN environment variable.');
+    throw new Error('❌ Missing GITHUB_PAT or GITHUB_TOKEN environment variable.');
   }
 
   const octokit = github.getOctokit(githubToken);

README.md

@@ -191,6 +191,7 @@ URL Parameter > Theme Default > System Fallback
 | `shading`         | `boolean` | No         | `false`                        | Apply intensity-based opacity shading to tower faces so lower intensity levels appear slightly dimmer                                                                     |
 | `opacity`         | `number`  | No         | `1.0`                          | Global opacity scalar for all tower fill-opacity values (0.1–1.0). `opacity=0.5` = semi-transparent ghost look. `opacity=0.8` = faded, great on light backgrounds.        |
 | `gradient`        | `boolean` | No         | `false`                        | Opt-in to show volumetric gradients on the monolith floor                                                                                                                 |
+| `badges`          | `boolean` | No         | `false`                        | Render dynamic glowing milestone badges (e.g., 365-day streak, 1K+ commits) on the SVG                                                                                    |
 
 ### Grace Period Examples
 

app/api/notify/route.ts

@@ -37,7 +37,11 @@ export async function POST(req: NextRequest): Promise<NextResponse<NotificationR
   // Rate limiting
   const ip = getClientIp(req);
 
-  if (ip !== 'unknown' && !(await notifyRateLimiter.check(ip))) {
+  // fallback ensures rate limit is ALWAYS applied
+  const rateLimitKey =
+    ip && ip !== 'unknown' ? ip : `unknown:${req.headers.get('user-agent') ?? 'no-agent'}`;
+
+  if (!(await notifyRateLimiter.check(rateLimitKey))) {
     return NextResponse.json(
       { success: false, message: 'Too many requests, please try again later.' },
       { status: 429 }

app/api/streak/route.ts

@@ -99,6 +99,7 @@ export async function GET(request: Request) {
       glow,
       format,
       days,
+      badges,
     } = parseResult.data;
     const normalizedView = view as 'default' | 'monthly' | 'heatmap' | 'pulse';
     const themeName = theme || 'dark';
@@ -182,6 +183,7 @@ export async function GET(request: Request) {
       disable_particles,
       glow,
       animate,
+      badges,
     };
 
     let calendar;

app/api/track-user/route.ts

@@ -9,7 +9,9 @@ export async function POST(req: Request) {
   // Get IP for rate limiting securely
   const ip = getClientIp(req);
 
-  if (ip !== '127.0.0.1' && ip !== 'unknown' && !(await trackUserRateLimiter.check(ip))) {
+  const rateLimitKey = ip === 'unknown' ? 'unknown-client' : ip;
+
+  if (ip !== '127.0.0.1' && !(await trackUserRateLimiter.check(rateLimitKey))) {
     return NextResponse.json(
       { success: false, error: 'Too many requests, please try again later.' },
       { status: 429 }

app/api/user-details/route.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GET } from './route';
+
+vi.mock('@/lib/github', () => ({
+  fetchUserProfile: vi.fn(),
+  fetchGitHubContributions: vi.fn(),
+}));
+
+import { fetchUserProfile, fetchGitHubContributions } from '@/lib/github';
+import type { ContributionCalendar } from '@/types';
+
+const mockCalendar: ContributionCalendar = {
+  totalContributions: 15,
+  weeks: [
+    {
+      contributionDays: [
+        { contributionCount: 5, date: '2024-06-10' },
+        { contributionCount: 5, date: '2024-06-11' },
+        { contributionCount: 5, date: '2024-06-12' },
+      ],
+    },
+  ],
+};
+
+const mockProfile = {
+  login: 'testuser',
+  name: 'Test User',
+  avatar_url: 'https://github.com/testuser.png',
+  public_repos: 12,
+};
+
+function makeRequest(params: Record<string, string> = {}): Request {
+  const url = new URL('http://localhost/api/user-details');
+  for (const [key, value] of Object.entries(params)) {
+    url.searchParams.set(key, value);
+  }
+  return new Request(url.toString());
+}
+
+describe('GET /api/user-details', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(fetchUserProfile).mockResolvedValue(mockProfile as any);
+    vi.mocked(fetchGitHubContributions).mockResolvedValue({
+      calendar: mockCalendar,
+      repoContributions: [],
+      totalPRs: 0,
+      totalIssues: 0,
+    });
+  });
+
+  it('returns 400 when username is missing', async () => {
+    const response = await GET(makeRequest());
+    expect(response.status).toBe(400);
+    const body = await response.json();
+    expect(body.error).toBe('Username is required');
+  });
+
+  it('returns 400 when username format is invalid', async () => {
+    const response = await GET(makeRequest({ username: 'invalid_user_name_@' }));
+    expect(response.status).toBe(400);
+    const body = await response.json();
+    expect(body.error).toBe('Invalid username format');
+  });
+
+  it('returns 200 with user details and streak stats on success', async () => {
+    const response = await GET(makeRequest({ username: 'testuser' }));
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body).toEqual({
+      exists: true,
+      login: 'testuser',
+      name: 'Test User',
+      avatar_url: 'https://github.com/testuser.png',
+      public_repos: 12,
+      stats: {
+        currentStreak: 3,
+        longestStreak: 3,
+        totalContributions: 15,
+      },
+    });
+  });
+
+  it('returns 404 when user is not found', async () => {
+    vi.mocked(fetchUserProfile).mockRejectedValue(new Error('User not found'));
+    const response = await GET(makeRequest({ username: 'missinguser' }));
+    expect(response.status).toBe(404);
+    const body = await response.json();
+    expect(body.error).toBe('User not found');
+  });
+
+  it('gracefully handles contributions fetch failure and returns profile details', async () => {
+    vi.mocked(fetchGitHubContributions).mockRejectedValue(new Error('API limit reached'));
+    const response = await GET(makeRequest({ username: 'testuser' }));
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body.stats).toEqual({
+      currentStreak: 0,
+      longestStreak: 0,
+      totalContributions: 0,
+    });
+  });
+});

app/api/user-details/route.ts

@@ -0,0 +1,49 @@
+import { NextResponse } from 'next/server';
+import { fetchUserProfile, fetchGitHubContributions } from '@/lib/github';
+import { calculateStreak } from '@/lib/calculate';
+import { validateGitHubUsername } from '@/lib/validations';
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const username = searchParams.get('username')?.trim();
+
+  if (!username) {
+    return NextResponse.json({ error: 'Username is required' }, { status: 400 });
+  }
+
+  if (!validateGitHubUsername(username)) {
+    return NextResponse.json({ error: 'Invalid username format' }, { status: 400 });
+  }
+
+  try {
+    const [profile, contributions] = await Promise.all([
+      fetchUserProfile(username),
+      fetchGitHubContributions(username).catch(() => null),
+    ]);
+
+    let stats = { currentStreak: 0, longestStreak: 0, totalContributions: 0 };
+    if (contributions) {
+      const calculated = calculateStreak(contributions.calendar);
+      stats = {
+        currentStreak: calculated.currentStreak,
+        longestStreak: calculated.longestStreak,
+        totalContributions: calculated.totalContributions,
+      };
+    }
+
+    return NextResponse.json({
+      exists: true,
+      login: profile.login,
+      name: profile.name,
+      avatar_url: profile.avatar_url,
+      public_repos: profile.public_repos,
+      stats,
+    });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : '';
+    if (message.includes('not found') || message.includes('404')) {
+      return NextResponse.json({ error: 'User not found' }, { status: 404 });
+    }
+    return NextResponse.json({ error: message || 'Failed to fetch user details' }, { status: 500 });
+  }
+}

app/compare/CompareClient.tsx

@@ -37,7 +37,7 @@ import {
 
 /* ── types ────────────────────────────────────────────────────────────── */
 
-interface UserProfile {
+export interface UserProfile {
   username: string;
   name: string;
   avatarUrl: string;
@@ -54,7 +54,7 @@ interface UserProfile {
   };
 }
 
-interface UserStats {
+export interface UserStats {
   currentStreak: number;
   peakStreak: number;
   totalContributions: number;
@@ -63,28 +63,28 @@ interface UserStats {
   totalIssues?: number;
 }
 
-interface LanguageData {
+export interface LanguageData {
   name: string;
   color: string;
   percentage: number;
 }
 
-interface ActivityData {
+export interface ActivityData {
   date: string;
   count: number;
   intensity: 0 | 1 | 2 | 3 | 4;
   locAdditions?: number;
   locDeletions?: number;
 }
 
-interface CompareUserData {
+export interface CompareUserData {
   profile: UserProfile;
   stats: UserStats;
   languages: LanguageData[];
   activity: ActivityData[];
 }
 
-interface CompareResponse {
+export interface CompareResponse {
   user1: CompareUserData;
   user2: CompareUserData;
   error?: string;

app/compare/CompareClient.type-compiler.test.tsx

@@ -0,0 +1,68 @@
+import { describe, expectTypeOf, it } from 'vitest';
+
+import type {
+  ActivityData,
+  CompareResponse,
+  CompareUserData,
+  LanguageData,
+  UserProfile,
+  UserStats,
+} from './CompareClient';
+
+describe('CompareClient Type Compiler Validation', () => {
+  it('validates UserProfile structure', () => {
+    expectTypeOf<UserProfile>().toEqualTypeOf<{
+      username: string;
+      name: string;
+      avatarUrl: string;
+      isPro: boolean;
+      bio: string;
+      location: string;
+      joinedDate: string;
+      developerScore: number;
+      stats: {
+        repositories: number;
+        followers: number;
+        following: number;
+        stars: number;
+      };
+    }>();
+  });
+
+  it('validates UserStats numeric and optional fields', () => {
+    expectTypeOf<UserStats>().toEqualTypeOf<{
+      currentStreak: number;
+      peakStreak: number;
+      totalContributions: number;
+      codingHabit?: string;
+      totalPRs?: number;
+      totalIssues?: number;
+    }>();
+  });
+
+  it('validates LanguageData structure', () => {
+    expectTypeOf<LanguageData>().toEqualTypeOf<{
+      name: string;
+      color: string;
+      percentage: number;
+    }>();
+  });
+
+  it('accepts optional fields in ActivityData without compile errors', () => {
+    expectTypeOf<ActivityData>().toEqualTypeOf<{
+      date: string;
+      count: number;
+      intensity: 0 | 1 | 2 | 3 | 4;
+      locAdditions?: number;
+      locDeletions?: number;
+    }>();
+  });
+
+  it('validates CompareResponse structure', () => {
+    expectTypeOf<CompareResponse>().toEqualTypeOf<{
+      user1: CompareUserData;
+      user2: CompareUserData;
+      error?: string;
+    }>();
+  });
+});