feat: limit calendar fetch concurrency to 5 in getOrgDashboardData to prevent 429 rate limits

Author: Pranav-IIITM

lib/github.test.ts

@@ -18,6 +18,7 @@ import {
   getOrgDashboardData,
   getWrappedData,
   computeDeveloperScore,
+  runCappedConcurrency,
 } from './github';
 import type { ContributionCalendar } from '../types';
 
@@ -1678,3 +1679,44 @@ describe('computeDeveloperScore', () => {
     ).toBe(2);
   });
 });
+
+describe('runCappedConcurrency', () => {
+  it('should process all items and return their results in order', async () => {
+    const items = [1, 2, 3, 4, 5];
+    const results = await runCappedConcurrency(items, 2, async (x) => {
+      return x * 10;
+    });
+
+    expect(results).toEqual([10, 20, 30, 40, 50]);
+  });
+
+  it('should strictly limit the concurrency to the specified limit', async () => {
+    const items = [1, 2, 3, 4, 5];
+    let activePromises = 0;
+    let maxConcurrentPromises = 0;
+
+    await runCappedConcurrency(items, 2, async (x) => {
+      activePromises++;
+      maxConcurrentPromises = Math.max(maxConcurrentPromises, activePromises);
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      activePromises--;
+      return x;
+    });
+
+    expect(maxConcurrentPromises).toBeLessThanOrEqual(2);
+  });
+
+  it('should handle errors inside tasks gracefully without aborting the entire sequence', async () => {
+    const items = [1, 2, 3, 4, 5];
+    const results = await runCappedConcurrency(items, 2, async (x) => {
+      if (x === 3) throw new Error('Task 3 failed');
+      return x * 10;
+    });
+
+    expect(results[0]).toBe(10);
+    expect(results[1]).toBe(20);
+    expect(results[2]).toBeNull();
+    expect(results[3]).toBe(40);
+    expect(results[4]).toBe(50);
+  });
+});

lib/github.ts

@@ -705,16 +705,14 @@ export async function getOrgDashboardData(orgName: string, options: FetchOptions
 
   const members = membersOrError;
 
-  // Fetch calendars for all members concurrently (Capped by member limit to avoid 429)
-  const memberCalendarsPromises = members.map((member: string) =>
-    fetchGitHubContributions(member, options)
-      .then((data) => data.calendar)
-      .catch(() => null)
-  );
-
-  const calendars = (await Promise.all(memberCalendarsPromises)).filter(
-    (c: ContributionCalendar | null) => c !== null
-  ) as ContributionCalendar[];
+  // Fetch calendars for all members concurrently with capped concurrency to avoid 429s/timeouts
+  const calendars = (
+    await runCappedConcurrency(members, 5, (member) =>
+      fetchGitHubContributions(member, options)
+        .then((data) => data.calendar)
+        .catch(() => null)
+    )
+  ).filter((c: ContributionCalendar | null) => c !== null) as ContributionCalendar[];
 
   // Create the Mega-City
   const aggregatedCalendar = aggregateCalendars(calendars);
@@ -1227,3 +1225,35 @@ export async function getWrappedData(
     topLanguage,
   };
 }
+
+/**
+ * Run tasks concurrently with a maximum limit on active promises.
+ */
+export async function runCappedConcurrency<T, R>(
+  items: T[],
+  limit: number,
+  fn: (item: T) => Promise<R>
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  let currentIndex = 0;
+
+  async function worker(): Promise<void> {
+    while (currentIndex < items.length) {
+      const index = currentIndex++;
+      try {
+        results[index] = await fn(items[index]);
+      } catch (err) {
+        results[index] = null as unknown as R;
+      }
+    }
+  }
+
+  const workers: Promise<void>[] = [];
+  const workerCount = Math.min(limit, items.length);
+  for (let i = 0; i < workerCount; i++) {
+    workers.push(worker());
+  }
+
+  await Promise.all(workers);
+  return results;
+}