Feature: Add LeetCode Stats Card Generator

app/api/leetcode/route.test.ts

@@ -0,0 +1,85 @@
+import { GET } from './route';
+import * as api from '@/services/leetcode/api';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('@/services/leetcode/api', () => ({
+  getLeetCodeStats: vi.fn(),
+}));
+
+describe('GET /api/leetcode', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns 400 for missing username parameter', async () => {
+    const req = new Request('http://localhost/api/leetcode');
+    const res = await GET(req);
+
+    expect(res.status).toBe(400);
+    expect(res.headers.get('Content-Type')).toContain('image/svg+xml');
+
+    const text = await res.text();
+    expect(text).toContain('Username is required');
+  });
+
+  it('returns 400 for invalid bg color parameter', async () => {
+    const req = new Request('http://localhost/api/leetcode?username=user&bg=invalid');
+    const res = await GET(req);
+
+    expect(res.status).toBe(400);
+    expect(res.headers.get('Content-Type')).toContain('image/svg+xml');
+
+    const text = await res.text();
+    expect(text).toContain('bg must be a valid hex color');
+  });
+
+  it('returns 200 SVG with valid user stats', async () => {
+    vi.mocked(api.getLeetCodeStats).mockResolvedValue({
+      username: 'leetcode_dev',
+      totalSolved: 300,
+      easySolved: 100,
+      mediumSolved: 150,
+      hardSolved: 50,
+      ranking: 5000,
+    });
+
+    const req = new Request('http://localhost/api/leetcode?username=leetcode_dev&theme=dark');
+    const res = await GET(req);
+
+    expect(res.status).toBe(200);
+    expect(res.headers.get('Content-Type')).toBe('image/svg+xml; charset=utf-8');
+
+    const text = await res.text();
+    expect(text).toContain("leetcode_dev's LeetCode Stats");
+    expect(text).toContain('Rank #5,000');
+    expect(text).toContain('300');
+  });
+
+  it('returns 304 if ETag matches', async () => {
+    vi.mocked(api.getLeetCodeStats).mockResolvedValue({
+      username: 'leetcode_dev',
+      totalSolved: 300,
+      easySolved: 100,
+      mediumSolved: 150,
+      hardSolved: 50,
+      ranking: 5000,
+    });
+
+    const req1 = new Request('http://localhost/api/leetcode?username=leetcode_dev');
+    const res1 = await GET(req1);
+    const etag = res1.headers.get('ETag');
+    expect(etag).toBeTruthy();
+
+    const req2 = new Request('http://localhost/api/leetcode?username=leetcode_dev', {
+      headers: {
+        'If-None-Match': etag as string,
+      },
+    });
+    const res2 = await GET(req2);
+    expect(res2.status).toBe(304);
+  });
+});

app/api/leetcode/route.ts

@@ -0,0 +1,83 @@
+import { NextResponse } from 'next/server';
+import { getLeetCodeStats } from '@/services/leetcode/api';
+import { generateLeetCodeSVG } from '@/lib/svg/leetcode';
+import { buildInlineErrorSVG } from '@/lib/svg/generator';
+import { resolveErrorTheme } from '@/lib/svg/themes';
+import { leetcodeParamsSchema, coerceQueryParams } from '@/lib/validations';
+import { optimizeSVG } from '@/lib/svg/optimizer';
+import crypto from 'crypto';
+
+const SVG_CSP_HEADER =
+  "default-src 'none'; style-src 'unsafe-inline' https://fonts.googleapis.com; font-src https://fonts.gstatic.com; connect-src https://fonts.gstatic.com; img-src data:;";
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+
+  const parseResult = leetcodeParamsSchema.safeParse(coerceQueryParams(searchParams));
+
+  if (!parseResult.success) {
+    const fieldErrors = parseResult.error.flatten();
+    const firstError =
+      Object.values(fieldErrors.fieldErrors).flat()[0] ??
+      fieldErrors.formErrors[0] ??
+      'Invalid parameters';
+
+    const errTheme = resolveErrorTheme(searchParams);
+    const errorSvg = buildInlineErrorSVG(firstError, {
+      bg: errTheme.bg,
+      accent: errTheme.accent,
+      text: errTheme.text,
+      radius: errTheme.radius,
+    });
+
+    return new NextResponse(errorSvg, {
+      status: 400,
+      headers: {
+        'Content-Type': 'image/svg+xml',
+        'Cache-Control': 'no-store',
+        'Content-Security-Policy': SVG_CSP_HEADER,
+      },
+    });
+  }
+
+  const params = parseResult.data;
+
+  const stats = await getLeetCodeStats(params.username);
+
+  let svg = generateLeetCodeSVG(stats, params);
+
+  if (params.minify) {
+    svg = optimizeSVG(svg);
+  }
+
+  const isRefreshRequested = params.refresh || params.bypassCache;
+  const cacheControl = isRefreshRequested
+    ? 'no-cache, no-store, must-revalidate'
+    : 'public, max-age=30, s-maxage=30, stale-while-revalidate=30';
+
+  const etag = crypto.createHash('sha256').update(svg).digest('hex');
+  const weakEtag = `W/"${etag}"`;
+  const ifNoneMatch = request.headers.get('if-none-match');
+
+  if (ifNoneMatch) {
+    const etags = ifNoneMatch.split(',').map((e) => e.trim());
+    if (etags.includes(weakEtag) || etags.includes(`"${etag}"`)) {
+      return new NextResponse(null, {
+        status: 304,
+        headers: {
+          'Cache-Control': cacheControl,
+          ETag: weakEtag,
+        },
+      });
+    }
+  }
+
+  return new NextResponse(svg, {
+    headers: {
+      'Content-Type': 'image/svg+xml; charset=utf-8',
+      'Cache-Control': cacheControl,
+      'Content-Security-Policy': SVG_CSP_HEADER,
+      ETag: weakEtag,
+    },
+  });
+}

app/contact/page.test.tsx

@@ -10,7 +10,6 @@ import ContactPage from './page';
 vi.mock('framer-motion', () => ({
   AnimatePresence: ({ children }: { children: ReactNode }) => <>{children}</>,
   motion: {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     div: ({
       children,
       initial,
@@ -24,7 +23,7 @@ vi.mock('framer-motion', () => ({
     }: React.HTMLAttributes<HTMLDivElement> & Record<string, unknown>) => (
       <div {...props}>{children}</div>
     ),
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
     form: ({
       children,
       onSubmit,
@@ -38,7 +37,7 @@ vi.mock('framer-motion', () => ({
         {children}
       </form>
     ),
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
     p: ({
       children,
       initial,
@@ -49,7 +48,7 @@ vi.mock('framer-motion', () => ({
     }: React.HTMLAttributes<HTMLParagraphElement> & Record<string, unknown>) => (
       <p {...props}>{children}</p>
     ),
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
     button: ({
       children,
       whileTap,

lib/resume-parser.ts

@@ -136,45 +136,58 @@ async function extractTextFromBuffer(buffer: Buffer, mimeType: string): Promise<
   let rawText = '';
 
   if (mimeType === 'application/pdf') {
-    try {
-      if (buffer.toString('utf-8', 0, 4) === '%PDF') {
+    const header = buffer.toString('utf-8', 0, 4);
+    if (header === '%PDF') {
+      try {
         const { PDFParse } = await import('pdf-parse');
 
         const parser = new PDFParse({ data: buffer });
         const result = await parser.getText();
         await parser.destroy();
 
         rawText = result.text;
-      } else {
-        rawText = buffer.toString('utf-8');
+      } catch (error) {
+        console.warn('Failed to parse PDF using pdf-parse:', error);
+        rawText = '';
       }
-    } catch (error) {
-      console.warn('Failed to parse PDF using pdf-parse, falling back to UTF-8 decoding:', error);
+    } else {
       rawText = buffer.toString('utf-8');
     }
   } else if (
     mimeType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
   ) {
-    try {
-      if (buffer.toString('utf-8', 0, 2) === 'PK') {
+    const header = buffer.toString('utf-8', 0, 2);
+    if (header === 'PK') {
+      try {
         const mammothModule = await import('mammoth');
         const mammothParser = ((mammothModule as unknown as { default?: unknown }).default ||
           mammothModule) as typeof mammothModule;
         const result = await mammothParser.extractRawText({ buffer });
         rawText = result.value;
-      } else {
-        rawText = buffer.toString('utf-8');
+      } catch (error) {
+        console.warn('Failed to parse DOCX using mammoth:', error);
+        rawText = '';
       }
-    } catch (error) {
-      console.warn('Failed to parse DOCX using mammoth, falling back to UTF-8 decoding:', error);
+    } else {
       rawText = buffer.toString('utf-8');
     }
   } else {
     rawText = buffer.toString('utf-8');
   }
 
+  try {
+    if (rawText.includes('Ã')) {
+      const fixedText = Buffer.from(rawText, 'latin1').toString('utf-8');
+      if (!fixedText.includes('\uFFFD')) {
+        rawText = fixedText;
+      }
+    }
+  } catch (_e) {
+    // Ignore encoding fix errors
+  }
+
   const printable = rawText
-    .replace(/[^\x20-\x7E\n\r]/g, ' ')
+    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F\uFFFD]/g, '')
     .replace(/[ \t]+/g, ' ')
     .replace(/\r/g, '')
     .trim();

lib/svg/leetcode.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { generateLeetCodeSVG, getLeetCodeTheme } from './leetcode';
+import type { LeetCodeStatData } from '../../services/leetcode/api';
+import { leetcodeParamsSchema } from '../validations';
+
+describe('LeetCode SVG Generator', () => {
+  const defaultParams = leetcodeParamsSchema.parse({ username: 'testuser' });
+
+  it('renders error state correctly', () => {
+    const stats: LeetCodeStatData = {
+      username: 'testuser',
+      totalSolved: 0,
+      easySolved: 0,
+      mediumSolved: 0,
+      hardSolved: 0,
+      ranking: 0,
+      error: 'User not found',
+    };
+    const svg = generateLeetCodeSVG(stats, defaultParams);
+    expect(svg).toContain('LeetCode Stats');
+    expect(svg).toContain('User not found');
+  });
+
+  it('renders full stats correctly', () => {
+    const stats: LeetCodeStatData = {
+      username: 'john_doe',
+      totalSolved: 500,
+      easySolved: 200,
+      mediumSolved: 250,
+      hardSolved: 50,
+      ranking: 15420,
+    };
+
+    const svg = generateLeetCodeSVG(stats, defaultParams);
+
+    expect(svg).toContain("john_doe's LeetCode Stats");
+    expect(svg).toContain('Rank #15,420');
+    expect(svg).toContain('Total Solved');
+    expect(svg).toContain('500');
+    expect(svg).toContain('Easy');
+    expect(svg).toContain('200');
+    expect(svg).toContain('Medium');
+    expect(svg).toContain('250');
+    expect(svg).toContain('Hard');
+    expect(svg).toContain('50');
+  });
+
+  it('supports theme customization', () => {
+    const customParams = leetcodeParamsSchema.parse({
+      username: 'testuser',
+      theme: 'dracula',
+      bg: '1e1e2e',
+      text: 'f5e0dc',
+      accent: 'cba6f7',
+    });
+
+    const theme = getLeetCodeTheme(customParams);
+    expect(theme.bg).toBe('1e1e2e');
+    expect(theme.text).toBe('f5e0dc');
+    expect(theme.accent).toBe('cba6f7');
+
+    const stats: LeetCodeStatData = {
+      username: 'testuser',
+      totalSolved: 10,
+      easySolved: 5,
+      mediumSolved: 3,
+      hardSolved: 2,
+      ranking: 100,
+    };
+
+    const svg = generateLeetCodeSVG(stats, customParams);
+    expect(svg).toContain('fill="#1e1e2e"');
+  });
+});