feat: limit calendar fetch concurrency to 5 in getOrgDashboardData to prevent 429 rate limits (JhaSourav07#2150)

## Description
Fixes JhaSourav07#2106

`getOrgDashboardData` was firing all member calendar fetches
simultaneously via an
uncapped `Promise.all`, creating a 1:1 ratio between org size and
parallel HTTP
requests. For large orgs (up to 200 members post-pagination fix), this
risks Vercel
serverless timeouts and GitHub secondary rate limits (429s).

This PR introduces a dependency-free `runCappedConcurrency` helper that
enforces a
maximum of 5 concurrent requests at any time, draining the queue as
slots free up.

**Changes made:**
- `lib/github.ts` — replaced uncapped `Promise.all` with
`runCappedConcurrency(tasks, 5)`;
  appended the `runCappedConcurrency` helper at the end of the file
- `lib/github.test.ts` — imported `runCappedConcurrency`; added 3 unit
tests covering
result order preservation, strict concurrency cap enforcement, and
graceful
  per-task failure recovery

## Pillar
- [ ] 🎨 Pillar 1 — New Theme Design
- [ ] 📐 Pillar 2 — Geometric SVG Improvement
- [ ] 🕐 Pillar 3 — Timezone Logic Optimization
- [x] 🛠️ Other (Bug fix, refactoring, docs)

## Visual Preview
N/A — internal data-fetching logic, no SVG output change.

## Checklist before requesting a review:
- [x] I have read the `CONTRIBUTING.md` file.
- [x] I have tested these changes locally
(`localhost:3000/api/streak?user=Pranav-IIITM`).
- [x] I have run `npm run format` and `npm run lint` locally and
resolved all errors.
- [x] My commits follow the Conventional Commits format (`feat: limit
calendar fetch concurrency to 5 in getOrgDashboardData to prevent 429
rate limits`).
- [ ] I have updated `README.md` if I added a new theme or URL
parameter. *(not applicable)*
- [x] I have started the repo.
- [x] I have made sure that i have only one commit to merge in this PR.
- [x] The SVG output matches the CommitPulse "premium quality" aesthetic
standard. *(not applicable — no SVG changes)*
- [x] (Recommended) I joined the CommitPulse Discord community for
contributor discussions, mentorship, and faster PR support.

Author: JhaSourav07

lib/github.test.ts

@@ -16,6 +16,7 @@ import {
   getOrgDashboardData,
   getWrappedData,
   computeDeveloperScore,
+  runCappedConcurrency,
   buildProfileData,
   aggregateLanguages,
   buildInsights,
@@ -2106,3 +2107,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

@@ -710,17 +710,18 @@ export async function getOrgDashboardData(orgName: string, options: FetchOptions
     throw new Error('This endpoint is strictly for organizations.');
   if (membersOrError instanceof Error) throw membersOrError;
 
-  const members: string[] = membersOrError;
+  const members = membersOrError;
+
+  // Fetch calendars for all members concurrently with capped concurrency to avoid 429s/timeouts
   const calendars = (
-    await Promise.all(
-      members.map((m) =>
-        fetchGitHubContributions(m, options)
-          .then((d) => d.calendar)
-          .catch(() => null)
-      )
+    await runCappedConcurrency(members, 5, (member) =>
+      fetchGitHubContributions(member, options)
+        .then((data) => data.calendar)
+        .catch(() => null)
     )
-  ).filter((c): c is ContributionCalendar => c !== null);
+  ).filter((c: ContributionCalendar | null) => c !== null) as ContributionCalendar[];
 
+  // Create the Mega-City
   const aggregatedCalendar = aggregateCalendars(calendars);
   const streakStats = calculateStreak(aggregatedCalendar);
   const totalStars = reposData.reduce((acc, r) => acc + r.stargazers_count, 0);
@@ -1225,3 +1226,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;
+}