@stoked-ui/github 0.0.0-a.0 → 0.1.0-alpha.11.2

package/modern/GithubEvents/GithubEvents.js

@@ -1,5 +1,5 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
-var _div, _Chip, _SmalMi, _SmalMi2, _SmalMi3, _SmalMi4, _SmalMi5, _TableRow, _TableRow2;
+var _Chip, _SmalMi, _SmalMi2, _SmalMi3, _SmalMi4, _SmalMi5, _TableRow, _TableRow2;
 import * as React from 'react';
 import { RequestError } from '@octokit/request-error';
 import Box from "@mui/material/Box";
@@ -21,23 +21,16 @@ import { toZonedTime } from 'date-fns-tz';
 import { styled, useTheme } from '@mui/material/styles';
 import Autocomplete from '@mui/material/Autocomplete';
 import Pagination from '@mui/material/Pagination';
-import dynamic from 'next/dynamic';
 import PullRequestEvent from './EventTypes/PullRequest/PullRequestEvent';
 import PushEvent from './EventTypes/PushEvent';
 import DeleteEvent from './EventTypes/DeleteEvent';
 import CreateEvent from './EventTypes/CreateEvent';
 import IssuesEvent from './EventTypes/IssuesEvent';
 import IssueCommentEvent from './EventTypes/IssueCommentEvent';
+import { githubEventsQuery } from '../apiHandlers/getGithubEvents';
 import Chip from '@mui/material/Chip';
 // Extend the EventDetails interface for internal component use
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// Import react-json-view dynamically to avoid SSR issues
-const ReactJson = dynamic(() => import('react-json-view'), {
-  ssr: false,
-  loading: () => _div || (_div = /*#__PURE__*/_jsx("div", {
-    children: "Loading JSON viewer..."
-  }))
-});
 const MetadataDisplay = styled(Box)(({
   theme
 }) => {
@@ -55,176 +48,112 @@ const MetadataDisplay = styled(Box)(({
     overflow: 'auto'
   };
 });
-function parseLinkHeader(header) {
-  if (!header) return {};
-  return header.split(',').reduce((links, part) => {
-    const match = part.match(/<(.+)>;\s*rel="([\w]+)"/);
-    if (match) {
-      const [, url, rel] = match;
-      if (rel === 'next' || rel === 'last') {
-        links[rel] = url;
-      }
-    }
-    return links;
-  }, {});
+export { githubEventsQuery };
+const CACHE_PERSIST_LIMITS = [200, 150, 100, 50, 25];
+function isStorageQuotaError(error) {
+  return error instanceof DOMException && (error.name === 'QuotaExceededError' || error.name === 'NS_ERROR_DOM_QUOTA_REACHED');
 }
-export async function githubEventsQuery({
-  query,
-  githubUser,
-  githubToken
-}) {
+function getStorageItem(storage, key) {
   try {
-    const {
-      page = query.page || 1,
-      per_page = query.per_page || 100,
-      // Default to 100 per page to minimize API calls
-      repo,
-      action,
-      date,
-      description
-    } = query;
-    const queryParams = new URLSearchParams(_extends({
-      page: String(page),
-      per_page: String(per_page)
-    }, repo && {
-      repo
-    }, action && {
-      action
-    }, date && {
-      date
-    }, description && {
-      description
-    }));
-
-    // Get GitHub token from environment variables
-    console.log(`Fetching events for user: ${githubUser}, page: ${page}, per_page: ${per_page}`);
-
-    // Fetch all available pages from GitHub API
-    let allEvents = [];
-    let hasMore = true;
-    let githubPage = 1;
-    const maxPages = 30; // GitHub's maximum for events endpoint
-
-    while (hasMore && githubPage <= maxPages) {
-      console.log(`Fetching page ${githubPage}...`);
-      const fetchOptions = {
-        headers: {
-          'User-Agent': 'brianstoker.com-website'
-        }
-      };
-      if (githubToken) {
-        fetchOptions.headers.Authorization = `token ${githubToken}`;
-      }
-      const response = await fetch(`https://api.github.com/users/${githubUser}/events?${queryParams}`, fetchOptions);
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error(`GitHub API error: ${response.status}`, errorText);
-        throw new Error(`GitHub API error: ${response.status} - ${errorText}`);
-      }
-      const data = await response.json();
-      console.log(`Page ${githubPage}: Received ${data.length} events`);
-      if (data.length === 0) {
-        hasMore = false;
-      } else {
-        allEvents = [...allEvents, ...data];
-        console.log(`Total events so far: ${allEvents.length}`);
-
-        // Check Link header to see if there are more pages
-        const linkHeader = response.headers.get('Link');
-        const links = parseLinkHeader(linkHeader);
-        hasMore = !!links.next; // Simplified logic
-
-        githubPage++;
-      }
-    }
-    console.log(`Final total events: ${allEvents.length}`);
-
-    // Apply filters
-    let filteredEvents = allEvents;
-    if (repo) {
-      filteredEvents = filteredEvents.filter(event => event.repo.name === repo);
-    }
-    if (action) {
-      filteredEvents = filteredEvents.filter(event => {
-        const eventAction = event.type.replace('Event', '');
-        return eventAction === action;
-      });
-    }
-    if (date) {
-      const now = new Date();
-      let cutoffDate;
-      switch (date) {
-        case 'today':
-          cutoffDate = new Date(now.setHours(0, 0, 0, 0));
-          break;
-        case 'yesterday':
-          cutoffDate = new Date(now);
-          cutoffDate.setDate(cutoffDate.getDate() - 1);
-          cutoffDate.setHours(0, 0, 0, 0);
-          break;
-        case 'week':
-          cutoffDate = new Date(now);
-          cutoffDate.setDate(cutoffDate.getDate() - 7);
-          cutoffDate.setHours(0, 0, 0, 0);
-          break;
-        case 'month':
-          cutoffDate = new Date(now);
-          cutoffDate.setMonth(cutoffDate.getMonth() - 1);
-          cutoffDate.setHours(0, 0, 0, 0);
-          break;
-        default:
-          cutoffDate = new Date(0);
-      }
-      filteredEvents = filteredEvents.filter(event => {
-        const eventDate = new Date(event.created_at);
-        return eventDate >= cutoffDate;
-      });
-    }
-    if (description) {
-      filteredEvents = filteredEvents.filter(event => {
-        var _event$payload$commit, _event$payload$pull_r, _event$payload$issue, _event$payload$issue2;
-        let eventDescription = '';
-        if (event.type === 'PushEvent' && (_event$payload$commit = event.payload.commits) != null && _event$payload$commit.length) {
-          eventDescription = `Pushed ${event.payload.commits.length} commits`;
-        } else if (event.type === 'PullRequestEvent' && (_event$payload$pull_r = event.payload.pull_request) != null && _event$payload$pull_r.title) {
-          eventDescription = event.payload.pull_request.title;
-        } else if (event.type === 'IssuesEvent' && (_event$payload$issue = event.payload.issue) != null && _event$payload$issue.title) {
-          eventDescription = event.payload.issue.title;
-        } else if (event.type === 'IssueCommentEvent' && (_event$payload$issue2 = event.payload.issue) != null && _event$payload$issue2.title) {
-          eventDescription = `Commented on issue: ${event.payload.issue.title}`;
-        }
-        return eventDescription.toLowerCase().includes(description.toLowerCase());
-      });
-    }
-
-    // Calculate pagination
-    const pageNum = Number(page);
-    const perPage = Number(per_page);
-    const startIndex = (pageNum - 1) * perPage;
-    const endIndex = startIndex + perPage;
-    const paginatedEvents = filteredEvents.slice(startIndex, endIndex);
-
-    // Extract unique values for filters (only on first page)
-    const repositories = [...new Set(allEvents.map(event => event.repo.name))].sort();
-    const actionTypes = [...new Set(allEvents.map(event => event.type.replace('Event', '')))].sort();
-
-    // Return paginated results with metadata
+    return storage.getItem(key);
+  } catch (error) {
+    console.warn(`Failed to read storage key "${key}"`, error);
+    return null;
+  }
+}
+function setStorageItem(storage, key, value) {
+  try {
+    storage.setItem(key, value);
     return {
-      events: paginatedEvents,
-      total: filteredEvents.length,
-      repositories,
-      actionTypes,
-      page: pageNum,
-      per_page: perPage,
-      total_pages: Math.ceil(filteredEvents.length / perPage),
-      total_fetched_events: allEvents.length,
-      max_pages_fetched: githubPage - 1
+      ok: true,
+      quotaExceeded: false
     };
   } catch (error) {
-    console.error('Error fetching GitHub events:', error);
-    throw new Error(`${error instanceof Error ? error.message : String(error)}`);
+    console.warn(`Failed to write storage key "${key}"`, error);
+    return {
+      ok: false,
+      quotaExceeded: isStorageQuotaError(error)
+    };
+  }
+}
+function removeStorageItem(storage, key) {
+  try {
+    storage.removeItem(key);
+  } catch (error) {
+    console.warn(`Failed to remove storage key "${key}"`, error);
+  }
+}
+function getStorageKeys(storage) {
+  try {
+    return Object.keys(storage);
+  } catch (error) {
+    console.warn('Failed to enumerate storage keys', error);
+    return [];
+  }
+}
+function buildCachePayload(events, limit = events.length) {
+  const normalizedLimit = Math.max(0, Math.min(events.length, limit));
+  const cachedEvents = normalizedLimit === events.length ? events : events.slice(0, normalizedLimit);
+  return {
+    events: cachedEvents,
+    lastFetched: Date.now(),
+    totalCount: cachedEvents.length
+  };
+}
+function persistCachedEvents(cacheKey, events) {
+  const attempts = Array.from(new Set([Math.min(events.length, CACHE_PERSIST_LIMITS[0]), ...CACHE_PERSIST_LIMITS])).filter(limit => limit > 0 && limit <= events.length);
+  let removedExistingCache = false;
+  for (const limit of attempts) {
+    const payload = buildCachePayload(events, limit);
+    const result = setStorageItem(localStorage, cacheKey, JSON.stringify(payload));
+    if (result.ok) {
+      return payload;
+    }
+    if (result.quotaExceeded && !removedExistingCache) {
+      removeStorageItem(localStorage, cacheKey);
+      removedExistingCache = true;
+    }
+  }
+  return null;
+}
+function updateCachedEventsTimestamp(cacheKey, payload) {
+  if (!payload) {
+    return;
+  }
+  const result = setStorageItem(localStorage, cacheKey, JSON.stringify(_extends({}, payload, {
+    lastFetched: Date.now()
+  })));
+  if (!result.ok) {
+    console.warn(`Skipping timestamp update for "${cacheKey}"`);
   }
 }
+function JsonFallbackView({
+  value
+}) {
+  const json = React.useMemo(() => {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch (error) {
+      return `Failed to serialize event payload: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }, [value]);
+  return /*#__PURE__*/_jsx(Box, {
+    component: "pre",
+    sx: {
+      backgroundColor: 'transparent',
+      fontSize: '0.875rem',
+      fontFamily: 'monospace',
+      padding: '8px',
+      borderRadius: '4px',
+      overflow: 'auto',
+      maxHeight: 'calc(100vh - 200px)',
+      margin: 0,
+      whiteSpace: 'pre-wrap',
+      wordBreak: 'break-word'
+    },
+    children: json
+  });
+}
 async function getEvents({
   githubUser,
   githubToken,
@@ -253,6 +182,7 @@ async function getEvents({
     description
   }));
   if (apiUrl) {
+    queryParams.set('username', githubUser);
     const url = apiUrl;
     console.log(`Fetching from custom API URL: ${url}?${queryParams}`);
     const response = await fetch(`${url}?${queryParams}`);
@@ -422,14 +352,14 @@ export default function GithubEvents({
       uniqueRepos.add(event.repo.name);
       uniqueActions.add(event.type.replace('Event', ''));
       if (event.payload) {
-        var _event$payload$commit2, _event$payload$pull_r2, _event$payload$issue3, _event$payload$issue4;
-        if (event.type === 'PushEvent' && (_event$payload$commit2 = event.payload.commits) != null && _event$payload$commit2.length) {
+        var _event$payload$commit, _event$payload$pull_r, _event$payload$issue, _event$payload$issue2;
+        if (event.type === 'PushEvent' && (_event$payload$commit = event.payload.commits) != null && _event$payload$commit.length) {
           uniqueDescriptions.add(`Pushed ${event.payload.commits.length} commits`);
-        } else if (event.type === 'PullRequestEvent' && (_event$payload$pull_r2 = event.payload.pull_request) != null && _event$payload$pull_r2.title) {
+        } else if (event.type === 'PullRequestEvent' && (_event$payload$pull_r = event.payload.pull_request) != null && _event$payload$pull_r.title) {
           uniqueDescriptions.add(event.payload.pull_request.title);
-        } else if (event.type === 'IssuesEvent' && (_event$payload$issue3 = event.payload.issue) != null && _event$payload$issue3.title) {
+        } else if (event.type === 'IssuesEvent' && (_event$payload$issue = event.payload.issue) != null && _event$payload$issue.title) {
           uniqueDescriptions.add(event.payload.issue.title);
-        } else if (event.type === 'IssueCommentEvent' && (_event$payload$issue4 = event.payload.issue) != null && _event$payload$issue4.title) {
+        } else if (event.type === 'IssueCommentEvent' && (_event$payload$issue2 = event.payload.issue) != null && _event$payload$issue2.title) {
           uniqueDescriptions.add(`Commented on issue: ${event.payload.issue.title}`);
         }
       }
@@ -450,7 +380,7 @@ export default function GithubEvents({
         console.log('Sample raw event to process:', JSON.stringify(rawEvents[0]).substring(0, 500) + '...');
       }
       return rawEvents.map((event, index) => {
-        var _event$payload$commit3;
+        var _event$payload$commit2;
         try {
           var _event$repo2;
           if (!event) {
@@ -472,7 +402,7 @@ export default function GithubEvents({
             switch (event.type) {
               case 'PushEvent':
                 action = 'Push';
-                description = `Pushed ${((_event$payload$commit3 = event.payload.commits) == null ? void 0 : _event$payload$commit3.length) || 0} commits`;
+                description = `Pushed ${((_event$payload$commit2 = event.payload.commits) == null ? void 0 : _event$payload$commit2.length) || 0} commits`;
                 link = `https://github.com/${event.repo.name}/commit/${event.payload.head}`;
                 break;
               case 'PullRequestEvent':
@@ -574,8 +504,8 @@ export default function GithubEvents({
   };
   const getEventDescription = event => {
     if (event.type === 'PushEvent') {
-      var _event$payload$commit4;
-      return `Pushed ${((_event$payload$commit4 = event.payload.commits) == null ? void 0 : _event$payload$commit4.length) || 0} commits`;
+      var _event$payload$commit3;
+      return `Pushed ${((_event$payload$commit3 = event.payload.commits) == null ? void 0 : _event$payload$commit3.length) || 0} commits`;
     } else if (event.type === 'PullRequestEvent') {
       return event.payload.pull_request.title;
     } else if (event.type === 'IssuesEvent') {
@@ -670,15 +600,15 @@ export default function GithubEvents({
       if (allEvents.length > 0) {
         // Save all events to cache with user-specific key
         setCachedEvents(allEvents);
-        localStorage.setItem(cacheKey, JSON.stringify({
-          events: allEvents,
-          lastFetched: Date.now(),
-          totalCount: allEvents.length
-        }));
+        const persistedCache = persistCachedEvents(cacheKey, allEvents);
+        if (persistedCache && persistedCache.events.length < allEvents.length) {
+          console.warn(`Persisted a trimmed GitHub events cache for "${cacheKey}" (${persistedCache.events.length}/${allEvents.length} events)`);
+        }
 
         // Mark that we've fetched this session
-        sessionStorage.setItem(`${cacheKey}_session_fetched`, 'true');
+        setStorageItem(sessionStorage, `${cacheKey}_session_fetched`, 'true');
         fetchedThisSessionRef.current = true;
+        setLastUpdated(format(new Date(), 'MMM d, yyyy h:mm a'));
 
         // Update filter options with all data
         buildFilterOptionsFromEvents(allEvents);
@@ -794,16 +724,15 @@ export default function GithubEvents({
         updatedEvents.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
 
         // Mark that we've fetched this session
-        sessionStorage.setItem(`${cacheKey}_session_fetched`, 'true');
+        setStorageItem(sessionStorage, `${cacheKey}_session_fetched`, 'true');
         fetchedThisSessionRef.current = true;
 
         // Update cache with new events using user-specific key
         setCachedEvents(updatedEvents);
-        localStorage.setItem(cacheKey, JSON.stringify({
-          events: updatedEvents,
-          lastFetched: Date.now(),
-          totalCount: updatedEvents.length
-        }));
+        const persistedCache = persistCachedEvents(cacheKey, updatedEvents);
+        if (persistedCache && persistedCache.events.length < updatedEvents.length) {
+          console.warn(`Persisted a trimmed GitHub events cache for "${cacheKey}" (${persistedCache.events.length}/${updatedEvents.length} events)`);
+        }
 
         // Update UI
         buildFilterOptionsFromEvents(updatedEvents);
@@ -820,14 +749,21 @@ export default function GithubEvents({
         console.log('No new events found');
 
         // Mark that we've fetched this session even if no new events
-        sessionStorage.setItem(`${cacheKey}_session_fetched`, 'true');
+        setStorageItem(sessionStorage, `${cacheKey}_session_fetched`, 'true');
         fetchedThisSessionRef.current = true;
 
         // Just update the last fetched time with user-specific key
-        const currentCache = JSON.parse(localStorage.getItem(cacheKey) || '{}');
-        localStorage.setItem(cacheKey, JSON.stringify(_extends({}, currentCache, {
-          lastFetched: Date.now()
-        })));
+        const currentCache = getStorageItem(localStorage, cacheKey);
+        let parsedCache = null;
+        if (currentCache) {
+          try {
+            parsedCache = JSON.parse(currentCache);
+          } catch (parseError) {
+            console.warn(`Failed to parse cached GitHub events for "${cacheKey}"`, parseError);
+            removeStorageItem(localStorage, cacheKey);
+          }
+        }
+        updateCachedEventsTimestamp(cacheKey, parsedCache);
         setLastUpdated(format(new Date(), 'MMM d, yyyy h:mm a'));
 
         // Use existing cached data for display
@@ -919,13 +855,13 @@ export default function GithubEvents({
 
     // Check session storage to see if we've already fetched this session
     const sessionKey = `${cacheKey}_session_fetched`;
-    const fetchedThisSession = sessionStorage.getItem(sessionKey) === 'true';
+    const fetchedThisSession = getStorageItem(sessionStorage, sessionKey) === 'true';
     console.log('Already fetched this session:', fetchedThisSession);
     fetchedThisSessionRef.current = fetchedThisSession;
 
     // Debug all localStorage keys to make sure we're looking at the right one
-    console.log('All localStorage keys:', Object.keys(localStorage));
-    const cached = localStorage.getItem(cacheKey);
+    console.log('All localStorage keys:', getStorageKeys(localStorage));
+    const cached = getStorageItem(localStorage, cacheKey);
     console.log(`LocalStorage for "${cacheKey}" exists:`, !!cached);
     if (cached) {
       try {
@@ -968,7 +904,7 @@ export default function GithubEvents({
           setTimeout(() => {
             fetchNewEvents();
             // Mark that we've fetched this session
-            sessionStorage.setItem(sessionKey, 'true');
+            setStorageItem(sessionStorage, sessionKey, 'true');
             fetchedThisSessionRef.current = true;
           }, 100);
         } else {
@@ -989,6 +925,7 @@ export default function GithubEvents({
         }
       } catch (err) {
         console.error('Failed to parse cached events, fetching new data:', err);
+        removeStorageItem(localStorage, cacheKey);
         fetchAllGitHubEvents();
       }
     } else {
@@ -1429,24 +1366,8 @@ export default function GithubEvents({
           event: selectedEvent
         }) : selectedEvent.actionType === 'IssueCommentEvent' ? /*#__PURE__*/_jsx(IssueCommentEvent, {
           event: selectedEvent
-        }) : /*#__PURE__*/_jsx(ReactJson, {
-          src: selectedEvent,
-          name: false,
-          theme: "monokai",
-          displayDataTypes: false,
-          enableClipboard: false,
-          displayObjectSize: false,
-          collapsed: 1,
-          collapseStringsAfterLength: 50,
-          style: {
-            backgroundColor: 'transparent',
-            fontSize: '0.875rem',
-            fontFamily: 'monospace',
-            padding: '8px',
-            borderRadius: '4px',
-            overflow: 'auto',
-            maxHeight: 'calc(100vh - 200px)'
-          }
+        }) : /*#__PURE__*/_jsx(JsonFallbackView, {
+          value: selectedEvent
         })
       })]
     })]

package/modern/apiHandlers/createGithubBranchHandler.js

@@ -0,0 +1,41 @@
+import getBranchCompareDetails from './getBranchCompareDetails';
+function getQueryValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+export default function createGithubBranchHandler() {
+  return async function handler(req, res) {
+    if (req.method !== 'GET') {
+      var _res$setHeader;
+      (_res$setHeader = res.setHeader) == null || _res$setHeader.call(res, 'Allow', 'GET');
+      return res.status(405).json({
+        message: 'Method not allowed'
+      });
+    }
+    const owner = getQueryValue(req.query.owner);
+    const repo = getQueryValue(req.query.repo);
+    const base = getQueryValue(req.query.base);
+    const head = getQueryValue(req.query.head);
+    if (!owner || !repo || !base || !head) {
+      return res.status(400).json({
+        message: 'owner, repo, base, and head are required'
+      });
+    }
+    try {
+      var _res$setHeader2;
+      const data = await getBranchCompareDetails({
+        owner,
+        repo,
+        base,
+        head
+      });
+      (_res$setHeader2 = res.setHeader) == null || _res$setHeader2.call(res, 'Cache-Control', 's-maxage=300, stale-while-revalidate=3600');
+      return res.status(200).json(data);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = message.includes('Missing required parameters') ? 400 : 502;
+      return res.status(status).json({
+        message
+      });
+    }
+  };
+}

package/modern/apiHandlers/createGithubCommitHandler.js

@@ -0,0 +1,39 @@
+import getCommitDetails from './getCommitDetails';
+function getQueryValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+export default function createGithubCommitHandler() {
+  return async function handler(req, res) {
+    if (req.method !== 'GET') {
+      var _res$setHeader;
+      (_res$setHeader = res.setHeader) == null || _res$setHeader.call(res, 'Allow', 'GET');
+      return res.status(405).json({
+        message: 'Method not allowed'
+      });
+    }
+    const owner = getQueryValue(req.query.owner);
+    const repo = getQueryValue(req.query.repo);
+    const ref = getQueryValue(req.query.ref);
+    if (!owner || !repo || !ref) {
+      return res.status(400).json({
+        message: 'owner, repo, and ref are required'
+      });
+    }
+    try {
+      var _res$setHeader2;
+      const data = await getCommitDetails({
+        owner,
+        repo,
+        ref
+      });
+      (_res$setHeader2 = res.setHeader) == null || _res$setHeader2.call(res, 'Cache-Control', 's-maxage=300, stale-while-revalidate=3600');
+      return res.status(200).json(data);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = message.includes('Missing required parameters') ? 400 : 502;
+      return res.status(status).json({
+        message
+      });
+    }
+  };
+}

package/modern/apiHandlers/createGithubContributionsHandler.js

@@ -0,0 +1,41 @@
+import getGithubContributions from './getGithubContributions';
+function getQueryValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+export default function createGithubContributionsHandler(config = {}) {
+  return async function handler(req, res) {
+    if (req.method !== 'GET') {
+      var _res$setHeader;
+      (_res$setHeader = res.setHeader) == null || _res$setHeader.call(res, 'Allow', 'GET');
+      return res.status(405).json({
+        message: 'Method not allowed'
+      });
+    }
+    const githubUser = getQueryValue(req.query.username);
+    const from = getQueryValue(req.query.from);
+    const to = getQueryValue(req.query.to);
+    if (!githubUser) {
+      return res.status(400).json({
+        message: 'username is required'
+      });
+    }
+    try {
+      var _config$getGithubToke, _res$setHeader2;
+      const githubToken = ((_config$getGithubToke = config.getGithubToken) == null ? void 0 : _config$getGithubToke.call(config, req)) || process.env.GITHUB_TOKEN;
+      const data = await getGithubContributions({
+        githubUser,
+        githubToken,
+        from,
+        to
+      });
+      (_res$setHeader2 = res.setHeader) == null || _res$setHeader2.call(res, 'Cache-Control', 's-maxage=3600, stale-while-revalidate=86400');
+      return res.status(200).json(data);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = message.includes('username is required') ? 400 : message.includes('No contribution calendar returned') ? 404 : message.includes('GitHub token not configured') ? 500 : 502;
+      return res.status(status).json({
+        message
+      });
+    }
+  };
+}

package/modern/apiHandlers/createGithubEventsHandler.js

@@ -0,0 +1,50 @@
+import githubEventsQuery from './getGithubEvents';
+function getQueryValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function parseNumber(value, fallback) {
+  const parsed = Number(getQueryValue(value));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+export default function createGithubEventsHandler(config = {}) {
+  return async function handler(req, res) {
+    if (req.method !== 'GET') {
+      var _res$setHeader;
+      (_res$setHeader = res.setHeader) == null || _res$setHeader.call(res, 'Allow', 'GET');
+      return res.status(405).json({
+        message: 'Method not allowed'
+      });
+    }
+    const githubUser = getQueryValue(req.query.username);
+    if (!githubUser) {
+      return res.status(400).json({
+        message: 'username is required'
+      });
+    }
+    const query = {
+      page: parseNumber(req.query.page, 1),
+      per_page: parseNumber(req.query.per_page, 40),
+      repo: getQueryValue(req.query.repo) || undefined,
+      action: getQueryValue(req.query.action) || undefined,
+      date: getQueryValue(req.query.date) || undefined,
+      description: getQueryValue(req.query.description) || undefined
+    };
+    try {
+      var _config$getGithubToke, _res$setHeader2;
+      const githubToken = ((_config$getGithubToke = config.getGithubToken) == null ? void 0 : _config$getGithubToke.call(config, req)) || process.env.GITHUB_TOKEN;
+      const data = await githubEventsQuery({
+        query,
+        githubUser,
+        githubToken
+      });
+      (_res$setHeader2 = res.setHeader) == null || _res$setHeader2.call(res, 'Cache-Control', 's-maxage=300, stale-while-revalidate=3600');
+      return res.status(200).json(data);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = message.includes('username is required') ? 400 : 502;
+      return res.status(status).json({
+        message
+      });
+    }
+  };
+}