Merge remote-tracking branch 'upstream/main' into fix/issue-1489

# Conflicts:
#	lib/calculate.test.ts

Author: boss477

app/api/streak/route.test.ts

@@ -291,6 +291,54 @@ describe('GET /api/streak', () => {
     });
   });
 
+  describe('edge cases for empty/private profiles', () => {
+    it('Scenario 1: Normal active GitHub user', async () => {
+      const response = await GET(makeRequest({ user: 'octocat' }));
+      expect(response.status).toBe(200);
+      const body = await response.text();
+      expect(body).toContain('<svg');
+    });
+
+    it('Scenario 2 & 3: User with 0 public repositories or private profile (empty calendar)', async () => {
+      vi.mocked(fetchGitHubContributions).mockResolvedValue({
+        calendar: {
+          totalContributions: 0,
+          weeks: [],
+        },
+        repoContributions: [],
+      } as unknown as ExtendedContributionData);
+
+      const response = await GET(makeRequest({ user: 'private-user' }));
+      expect(response.status).toBe(200);
+      const body = await response.text();
+      expect(body).toContain('<svg');
+      // Should show 0 contributions and streaks
+      expect(body).toContain('>0<');
+    });
+
+    it('Scenario 4: Nonexistent username', async () => {
+      vi.mocked(fetchGitHubContributions).mockRejectedValue(
+        new Error('GitHub user "nonexistent" not found')
+      );
+
+      const response = await GET(makeRequest({ user: 'nonexistent' }));
+      expect(response.status).toBe(404);
+      const body = await response.text();
+      expect(body).toContain('<svg');
+      expect(body).toContain('NOT FOUND');
+    });
+
+    it('Scenario 5: GitHub API failure', async () => {
+      vi.mocked(fetchGitHubContributions).mockRejectedValue(new Error('API Rate Limit Exceeded'));
+
+      const response = await GET(makeRequest({ user: 'octocat' }));
+      expect(response.status).toBe(429);
+      const body = await response.text();
+      expect(body).toContain('<svg');
+      expect(body).toContain('API RATE LIMIT');
+    });
+  });
+
   describe('cache-control header', () => {
     it('caches until UTC midnight by default, using the value from getSecondsUntilUTCMidnight', async () => {
       const response = await GET(makeRequest({ user: 'octocat' }));
@@ -826,6 +874,20 @@ describe('GET /api/streak', () => {
 
       expect(getSecondsUntilMidnightInTimezone).toHaveBeenCalledWith('Australia/Sydney');
     });
+
+    // =========================================================================
+    // ISSUE OBJECTIVE: Reject fictitious planetary timezone (Variation 4)
+    // =========================================================================
+    it('returns 400 when a fictitious planetary timezone Mars/Cyonia is supplied', async () => {
+      // Mars/Cyonia is structurally plausible (Region/City format) but does not
+      // exist in the IANA tz database — the schema must reject it before the
+      // request reaches the GitHub API.
+      const response = await GET(makeRequest({ user: 'octocat', tz: 'Mars/Cyonia' }));
+
+      expect(response.status).toBe(400);
+      const body = await response.json();
+      expect(body.details.fieldErrors.tz[0]).toContain('Invalid timezone');
+    });
   });
 
   describe('hide_background parameter', () => {

app/components/Footer.tsx

@@ -40,8 +40,8 @@ export function Footer() {
       </div>
 
       {/* BOTTOM */}
-      <div className="mt-6 border-t border-black/5 pt-3 text-center text-xs text-zinc-400 dark:border-white/5 dark:text-white/60">
-        © 2026 CommitPulse. All rights reserved.
+      <div className="mt-6 border-t border-black/5 pt-3 text-center text-xs text-zinc-500 dark:border-white/5 dark:text-zinc-500">
+        © {new Date().getFullYear()} CommitPulse. All rights reserved.
       </div>
     </footer>
   );

lib/calculate.test.ts

@@ -489,6 +489,35 @@ describe('calculateStreak', () => {
     expect(resultTuesday.longestStreak).toBe(2);
   });
 
+  it('verify streak formulas for different starting days of the week timeline (Variation 2)', () => {
+    // Week 1: 0, 0, 1, 1, 1, 1, 1 (Starts on Wednesday, 5 days)
+    // Week 2: 1, 1, 1, 1, 1, 1, 1 (7 days)
+    // Week 3: 1, 1, 1              // Ends on Wednesday (3 days)
+    // Total continuous streak = 15 days, ending on the last day.
+    const calendar = buildCalendar([
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1, // Week 1 (Starts Wed)
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1, // Week 2
+      1,
+      1,
+      1, // Week 3 (Ends Wed)
+    ]);
+    const result = calculateStreak(calendar);
+    expect(result.currentStreak).toBe(15);
+    expect(result.longestStreak).toBe(15);
+  });
+
   it('verify streak formulas for multiple weeks gaps timeline (Variation 3)', () => {
     // Streak 1: 5 days
     // Gap 1: 14 days (2 weeks of zeros)

lib/calculate.ts

@@ -28,8 +28,8 @@ export function calculateStreak(
   now: Date = new Date(),
   grace: number = 1
 ): StreakStats {
-  const weeks = calendar.weeks;
-  const days = weeks.flatMap((week) => week.contributionDays);
+  const weeks = calendar?.weeks || [];
+  const days = weeks.flatMap((week) => week?.contributionDays || []);
 
   let currentStreak = 0;
   let longestStreak = 0;
@@ -95,7 +95,8 @@ export function calculateMonthlyStats(
   timezone: string = 'UTC',
   now: Date = new Date()
 ): MonthlyStats {
-  const days = calendar.weeks.flatMap((week) => week.contributionDays);
+  const weeks = calendar?.weeks || [];
+  const days = weeks.flatMap((week) => week?.contributionDays || []);
 
   const localTodayStr = new Intl.DateTimeFormat('en-CA', { timeZone: timezone }).format(now);
   const [currentYearStr, currentMonthStr] = localTodayStr.split('-');
@@ -171,13 +172,13 @@ export function aggregateCalendars(calendars: ContributionCalendar[]): Contribut
   // Find the calendar with the most weeks to serve as our structural base
   let baseCalendar = calendars[0];
   for (const cal of calendars) {
-    if (cal.weeks.length > baseCalendar.weeks.length) {
+    if ((cal.weeks?.length || 0) > (baseCalendar.weeks?.length || 0)) {
       baseCalendar = cal;
     }
 
     // Populate the Map with all contributions from all calendars
-    cal.weeks.forEach((week) => {
-      week.contributionDays.forEach((day) => {
+    (cal.weeks || []).forEach((week) => {
+      (week?.contributionDays || []).forEach((day) => {
         const currentCount = dateMap.get(day.date) || 0;
         dateMap.set(day.date, currentCount + day.contributionCount);
       });
@@ -190,8 +191,8 @@ export function aggregateCalendars(calendars: ContributionCalendar[]): Contribut
   aggregatedBase.totalContributions = totalContributions;
 
   // Re-map the structural base using our aggregated date map
-  aggregatedBase.weeks.forEach((week) => {
-    week.contributionDays.forEach((day) => {
+  (aggregatedBase.weeks || []).forEach((week) => {
+    (week?.contributionDays || []).forEach((day) => {
       day.contributionCount = dateMap.get(day.date) || 0;
     });
   });
@@ -202,7 +203,8 @@ export function aggregateCalendars(calendars: ContributionCalendar[]): Contribut
  * Processes a calendar to generate deep insights for "GitHub Wrapped"
  */
 export function calculateWrappedStats(calendar: ContributionCalendar) {
-  const days = calendar.weeks.flatMap((w) => w.contributionDays);
+  const weeks = calendar?.weeks || [];
+  const days = weeks.flatMap((w) => w?.contributionDays || []);
 
   let mostActiveDay = { date: '', count: 0 };
   const monthCounts: Record<string, number> = {};

lib/github.ts

@@ -469,7 +469,16 @@ export async function fetchGitHubContributions(
       throw new Error(`GitHub user "${username}" not found`);
     }
 
-    let calendar = data.data.user.contributionsCollection.contributionCalendar;
+    let calendar = data.data.user.contributionsCollection?.contributionCalendar;
+    const repoContributions =
+      data.data.user.contributionsCollection?.commitContributionsByRepository || [];
+
+    if (!calendar || !calendar.weeks) {
+      calendar = {
+        totalContributions: 0,
+        weeks: [],
+      };
+    }
 
     if (isDeltaSync && cached) {
       calendar = mergeCalendars(cached.calendar, calendar);
@@ -514,14 +523,14 @@ export async function fetchGitHubContributions(
         key,
         {
           calendar,
-          repoContributions: data.data.user.contributionsCollection.commitContributionsByRepository,
+          repoContributions,
         },
         LONG_CACHE_TTL
       );
     }
     return {
       calendar,
-      repoContributions: data.data.user.contributionsCollection.commitContributionsByRepository,
+      repoContributions,
     };
   };
 

lib/mongodb.test.ts

@@ -2,12 +2,27 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import mongoose from 'mongoose';
 import dbConnect from './mongodb';
 
+const { mockMongooseConnection } = vi.hoisted(() => ({
+  mockMongooseConnection: {
+    readyState: 0,
+  },
+}));
+
 vi.mock('mongoose', () => ({
   default: {
     connect: vi.fn(),
+    disconnect: vi.fn(),
+    connection: mockMongooseConnection,
   },
 }));
 
+const setConnectedMongoose = (resolvedValue: typeof mongoose) => {
+  vi.mocked(mongoose.connect).mockImplementation(async () => {
+    mockMongooseConnection.readyState = 1;
+    return resolvedValue;
+  });
+};
+
 describe('dbConnect', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -17,10 +32,15 @@ describe('dbConnect', () => {
       global.mongoose.conn = null;
       global.mongoose.promise = null;
     }
+
+    delete process.env.NEXT_RUNTIME;
+    delete process.env.MONGODB_URI;
+    mockMongooseConnection.readyState = 0;
   });
 
   afterEach(() => {
     delete process.env.MONGODB_URI;
+    delete process.env.NEXT_RUNTIME;
   });
 
   it('throws an error if MONGODB_URI is not defined', async () => {
@@ -34,12 +54,16 @@ describe('dbConnect', () => {
   it('connects to mongoose and caches the connection', async () => {
     process.env.MONGODB_URI = 'mongodb://localhost:27017/test';
     const mockMongoose = { connection: 'mock' };
-    vi.mocked(mongoose.connect).mockResolvedValue(mockMongoose as unknown as typeof mongoose);
+    setConnectedMongoose(mockMongoose as unknown as typeof mongoose);
 
     const conn1 = await dbConnect();
     expect(mongoose.connect).toHaveBeenCalledTimes(1);
     expect(mongoose.connect).toHaveBeenCalledWith('mongodb://localhost:27017/test', {
       bufferCommands: false,
+      maxPoolSize: 10,
+      minPoolSize: 0,
+      maxIdleTimeMS: 30000,
+      serverSelectionTimeoutMS: 5000,
     });
     expect(conn1).toBe(mockMongoose);
 
@@ -64,12 +88,16 @@ describe('dbConnect', () => {
     process.env.MONGODB_URI = specificUri;
 
     const mockMongoose = { connection: 'mock' };
-    vi.mocked(mongoose.connect).mockResolvedValue(mockMongoose as unknown as typeof mongoose);
+    setConnectedMongoose(mockMongoose as unknown as typeof mongoose);
 
     await dbConnect();
 
     expect(mongoose.connect).toHaveBeenCalledWith(specificUri, {
       bufferCommands: false,
+      maxPoolSize: 10,
+      minPoolSize: 0,
+      maxIdleTimeMS: 30000,
+      serverSelectionTimeoutMS: 5000,
     });
   });
 
@@ -85,4 +113,29 @@ describe('dbConnect', () => {
     // The promise should be cleared so it can try again
     expect(global.mongoose.promise).toBeNull();
   });
+
+  it('throws when called from the Edge runtime', async () => {
+    vi.stubEnv('NEXT_RUNTIME', 'edge');
+    process.env.MONGODB_URI = 'mongodb://localhost:27017/test';
+
+    await expect(dbConnect()).rejects.toThrow(
+      'MongoDB is not supported in the Edge runtime. Use the Node.js runtime.'
+    );
+
+    expect(mongoose.connect).not.toHaveBeenCalled();
+  });
+
+  it('clears a stale cached connection before reconnecting', async () => {
+    process.env.MONGODB_URI = 'mongodb://localhost:27017/test';
+    global.mongoose.conn = {} as typeof mongoose;
+
+    const mockMongoose = { connection: 'mock' };
+    setConnectedMongoose(mockMongoose as unknown as typeof mongoose);
+
+    const conn = await dbConnect();
+
+    expect(mongoose.connect).toHaveBeenCalledTimes(1);
+    expect(global.mongoose.conn).toBe(mockMongoose);
+    expect(conn).toBe(mockMongoose);
+  });
 });

lib/mongodb.ts

@@ -1,6 +1,7 @@
 import mongoose from 'mongoose';
 
 declare global {
+  // Cached across hot reloads and repeated serverless invocations in the same process.
   var mongoose: {
     conn: typeof import('mongoose') | null;
     promise: Promise<typeof import('mongoose')> | null;
@@ -14,10 +15,19 @@ if (!cached) {
 }
 
 async function dbConnect() {
-  if (cached.conn) {
+  if (process.env.NEXT_RUNTIME === 'edge') {
+    throw new Error('MongoDB is not supported in the Edge runtime. Use the Node.js runtime.');
+  }
+
+  if (cached.conn && mongoose.connection.readyState === 1) {
     return cached.conn;
   }
 
+  if (cached.conn && mongoose.connection.readyState !== 1) {
+    cached.conn = null;
+    cached.promise = null;
+  }
+
   if (!cached.promise) {
     const MONGODB_URI = process.env.MONGODB_URI;
 
@@ -27,6 +37,10 @@ async function dbConnect() {
 
     const opts = {
       bufferCommands: false,
+      maxPoolSize: 10,
+      minPoolSize: 0,
+      maxIdleTimeMS: 30000,
+      serverSelectionTimeoutMS: 5000,
     };
 
     cached.promise = mongoose.connect(MONGODB_URI, opts).then((mongoose) => {

lib/validations.test.ts

@@ -756,3 +756,24 @@ describe('streakParamsSchema — Date Range Boundary Robustness (Variation 1)',
     }
   });
 });
+
+/* ==========================================================================
+ * TZ PARAMETER — IANA TIMEZONE VALIDATION (VARIATION 4)
+ * ========================================================================== */
+
+describe('streakParamsSchema — tz IANA timezone validation (Variation 4)', () => {
+  it('rejects a fictitious planetary timezone that is not a valid IANA zone', () => {
+    // Mars/Cyonia looks structurally plausible (Region/City format) but does not
+    // exist in the IANA tz database, so Intl.DateTimeFormat must throw and the
+    // schema must surface a field-level validation error.
+    const result = streakParamsSchema.safeParse({
+      user: 'octocat',
+      tz: 'Mars/Cyonia',
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toContain('Invalid timezone');
+    }
+  });
+});