@shiinasaku/github-card 4.1.0 → 5.0.0

package/src/gallery.ts

@@ -0,0 +1,37 @@
+import { renderCard, type CardOpts } from "./card";
+import type { LanguageStat, UserProfile, UserStats } from "./types";
+import { escapeXml, themes } from "./utils";
+
+/** Inline SVG cards so the preview also works through GitHub's image proxy. */
+export function renderThemeGallery(
+  user: UserProfile,
+  stats: UserStats,
+  languages: LanguageStat[],
+  options: CardOpts = {},
+): string {
+  const cards = Object.keys(themes).map((theme) => {
+    const svg = renderCard(user, stats, languages, { ...options, theme, idPrefix: theme });
+    // Dimensions come from our renderer, not user-supplied SVG.
+    const [, width, height] = svg.match(/^<svg\b[^>]*\bviewBox="0 0 (\d+) (\d+)"/) ?? [];
+    if (!width || !height) throw new Error("Card renderer returned an invalid viewBox");
+    return { theme, svg, width: Number(width), height: Number(height) };
+  });
+  const columns = 2;
+  const gap = 20;
+  const labelHeight = 22;
+  const cardWidth = Math.max(...cards.map((card) => card.width));
+  const cellHeight = Math.max(...cards.map((card) => card.height)) + labelHeight;
+  const rows = Math.ceil(cards.length / columns);
+  const width = columns * cardWidth + (columns + 1) * gap;
+  const height = rows * cellHeight + (rows + 1) * gap;
+
+  const blocks = cards.map(({ theme, svg }, index) => {
+    const x = gap + (index % columns) * (cardWidth + gap);
+    const y = gap + Math.floor(index / columns) * (cellHeight + gap) + labelHeight;
+    const card = svg.replace(/^<svg\b/, `<svg x="${x}" y="${y}"`);
+    const label = `<text x="${x + 4}" y="${y - 8}" fill="#e2e8f0" font-size="13" font-family="system-ui,sans-serif" font-weight="700">${escapeXml(theme)}</text>`;
+    return label + card;
+  });
+
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="GitHub Card themes for user"><rect width="100%" height="100%" fill="#0b1220"/>${blocks.join("")}</svg>`;
+}

package/src/github.ts

@@ -11,18 +11,18 @@ import {
 export { NotFoundError, RateLimitError, AuthError, UpstreamError };
 
 const githubClient = new GitHubClient({
-  token: Bun.env.GITHUB_TOKEN || process.env?.GITHUB_TOKEN || "",
+  token: Bun.env.GITHUB_TOKEN ?? "",
   userAgent: "github-card",
 });
 
 const CACHE_FRESH_MS = 30 * 60 * 1000;
 const CACHE_STALE_MS = 30 * 60 * 1000;
-const CACHE_VERSION = 7;
+const CACHE_VERSION = 9;
 const REDIS_TTL_SECONDS = Math.ceil((CACHE_FRESH_MS + CACHE_STALE_MS) / 1000);
 const FETCH_TIMEOUT_MS = 6000;
 const AVATAR_TIMEOUT_MS = 4000;
 const MAX_AVATAR_BYTES = 256 * 1024;
-const MAX_PAGES = 5;
+const MAX_PAGES = 100;
 const REPO_PAGE_SIZE = 100;
 const MAX_L1_ENTRIES = 1000;
 const REDIS_PROFILE_PREFIX = "profile:";
@@ -58,7 +58,7 @@ const refreshInFlight = new Set<string>();
 
 function evictL1IfNeeded() {
   if (memCache.size <= MAX_L1_ENTRIES) return;
-  const oldestKey = memCache.keys().next().value as string | undefined;
+  const oldestKey = memCache.keys().next().value;
   if (oldestKey) memCache.delete(oldestKey);
 }
 
@@ -123,8 +123,8 @@ export function getCacheMetrics() {
     fresh,
     stale,
     expired,
-    ttlFreshSeconds: 1800,
-    ttlStaleSeconds: 1800,
+    ttlFreshSeconds: CACHE_FRESH_MS / 1000,
+    ttlStaleSeconds: CACHE_STALE_MS / 1000,
   };
 }
 
@@ -133,18 +133,61 @@ function normalizeUsername(username: string): string {
 }
 
 function normalizeOrgFilters(orgs?: string[]): string[] {
-  return Array.from(new Set((orgs || []).map((o) => o.trim().toLowerCase()).filter(Boolean)));
+  return Array.from(
+    new Set((orgs || []).map((o) => o.trim().toLowerCase()).filter(Boolean)),
+  ).sort();
 }
 
 type FetchOptions = {
   includeLanguages?: boolean;
   langCount?: number;
+  hideLangs?: string[];
+  showLangs?: string[];
   scope?: "personal" | "org" | "all";
   orgs?: string[];
   affiliations?: "owner" | "affiliated";
   forceRefresh?: boolean;
 };
 
+type RepoNode = {
+  nameWithOwner: string;
+  isFork?: boolean;
+  stargazers: { totalCount: number };
+  owner?: { login: string; __typename: string } | null;
+  languages?: { edges: LangEdge[] | null } | null;
+};
+
+type PageInfo = { hasNextPage: boolean; endCursor: string | null };
+type RepoConnection = { pageInfo: PageInfo; nodes: RepoNode[] | null };
+
+type ProfileUser = {
+  login: string;
+  name: string | null;
+  avatarUrl: string;
+  bio: string | null;
+  pronouns: string | null;
+  twitterUsername: string | null;
+  openPRs: { totalCount: number };
+  closedPRs: { totalCount: number };
+  mergedPRs: { totalCount: number };
+  openIssues: { totalCount: number };
+  closedIssues: { totalCount: number };
+  contributionsCollection: {
+    totalCommitContributions: number;
+    commitContributionsByRepository?: ContributionEntry[] | null;
+    pullRequestContributionsByRepository?: ContributionEntry[] | null;
+    issueContributionsByRepository?: ContributionEntry[] | null;
+  };
+};
+
+type OrgProfile = {
+  login: string;
+  name: string | null;
+  avatarUrl: string;
+  description: string | null;
+  twitterUsername: string | null;
+};
+
 const QUERY_PROFILE = `
 query fullProfile($login: String!, $from: DateTime!, $to: DateTime!, $isOrg: Boolean!) {
   user(login: $login) {
@@ -186,9 +229,9 @@ query paginateRepos($login: String!, $cursor: String, $pageSize: Int!, $affiliat
 const QUERY_PAGINATE_ORG_CONTRIBS = `
 query paginateOrgContribs($login: String!, $cursor: String, $pageSize: Int!, $fetchLangs: Boolean!) {
   user(login: $login) {
-    repositoriesContributedTo(first: $pageSize, contributionTypes: [COMMIT, PULL_REQUEST, REPOSITORY], includeUserRepositories: false, after: $cursor) {
+    repositoriesContributedTo(first: $pageSize, contributionTypes: [COMMIT, ISSUE, PULL_REQUEST, REPOSITORY], includeUserRepositories: false, after: $cursor) {
       pageInfo { hasNextPage endCursor }
-      nodes { nameWithOwner owner { login __typename } stargazers { totalCount } languages(first: 10, orderBy: {field: SIZE, direction: DESC}) @include(if: $fetchLangs) { edges { size node { color name } } } }
+      nodes { nameWithOwner isFork owner { login __typename } stargazers { totalCount } languages(first: 10, orderBy: {field: SIZE, direction: DESC}) @include(if: $fetchLangs) { edges { size node { color name } } } }
     }
   }
 }
@@ -205,21 +248,23 @@ query paginateOrg($login: String!, $cursor: String, $pageSize: Int!, $fetchLangs
 }
 `;
 
-async function postGraphQL(query: string, variables: Record<string, unknown>) {
-  return githubClient.request(query, {
+async function postGraphQL<T>(query: string, variables: Record<string, unknown>): Promise<T> {
+  return githubClient.request<T>(query, {
     variables,
     timeoutMs: FETCH_TIMEOUT_MS,
   });
 }
 
 type LangMap = Map<string, { size: number; color: string }>;
-function accLangs(edges: any[], map: LangMap) {
-  if (!edges) return;
-  for (const e of edges) {
-    if (!e?.node?.name || !e.size) continue;
-    const cur = map.get(e.node.name);
-    if (cur) cur.size += e.size;
-    else map.set(e.node.name, { size: e.size, color: e.node.color || "#ccc" });
+type LangEdge = { size: number; node: { name: string; color: string | null } };
+
+function accLangs(edges: LangEdge[] | null | undefined, map: LangMap): void {
+  if (!edges?.length) return;
+  for (const edge of edges) {
+    if (!edge?.node?.name || !edge.size) continue;
+    const existing = map.get(edge.node.name);
+    if (existing) existing.size += edge.size;
+    else map.set(edge.node.name, { size: edge.size, color: edge.node.color ?? "#ccc" });
   }
 }
 
@@ -244,23 +289,33 @@ async function fetchAvatarAsBase64(url: string | null | undefined): Promise<stri
   }
 }
 
-function sumContributions(entries: any[], orgsSet: Set<string> | null) {
-  let tot = 0;
-  for (const e of entries || []) {
-    const owner = e?.repository?.owner;
+type ContributionEntry = {
+  repository?: { owner?: { login?: string; __typename?: string } | null } | null;
+  contributions?: { totalCount?: number } | null;
+};
+
+function sumContributions(
+  entries: ContributionEntry[] | null | undefined,
+  orgsSet: Set<string> | null,
+): number {
+  if (!entries?.length) return 0;
+  let total = 0;
+  for (const entry of entries) {
+    const owner = entry?.repository?.owner;
     if (owner?.__typename !== "Organization" || !owner?.login) continue;
     if (orgsSet && !orgsSet.has(owner.login.toLowerCase())) continue;
-    tot += e?.contributions?.totalCount || 0;
+    total += entry?.contributions?.totalCount ?? 0;
   }
-  return tot;
+  return total;
 }
 
-async function directFetch(username: string, opts: FetchOptions): Promise<ProfileData> {
+type EffectiveFetchOptions = Required<FetchOptions>;
+
+async function directFetch(username: string, opts: EffectiveFetchOptions): Promise<ProfileData> {
   const isPersonal = opts.scope !== "org";
   const isOrg = opts.scope === "org" || opts.scope === "all";
-  const fetchLangs = opts.includeLanguages ?? true;
-  const orgsArr = normalizeOrgFilters(opts.orgs);
-  const orgsSet = orgsArr.length > 0 ? new Set(orgsArr) : null;
+  const fetchLangs = opts.includeLanguages;
+  const orgsSet = opts.orgs.length > 0 ? new Set(opts.orgs) : null;
   const affiliations =
     opts.affiliations === "owner" ? ["OWNER"] : ["OWNER", "ORGANIZATION_MEMBER", "COLLABORATOR"];
 
@@ -268,20 +323,20 @@ async function directFetch(username: string, opts: FetchOptions): Promise<Profil
   const from = new Date(Date.UTC(now.getUTCFullYear(), 0, 1)).toISOString();
   const to = now.toISOString();
 
-  let user: any = null;
+  let user: ProfileUser | OrgProfile | null = null;
   let isOrgAccount = false;
   try {
-    const data = await postGraphQL(QUERY_PROFILE, {
+    const data = await postGraphQL<{ user: ProfileUser | null }>(QUERY_PROFILE, {
       login: username,
       from,
       to,
-      isOrg,
+      isOrg: opts.scope === "org",
     });
     user = data.user;
     if (!user) throw new NotFoundError();
   } catch (err) {
     if (err instanceof NotFoundError) {
-      const data = await postGraphQL(QUERY_ORG, {
+      const data = await postGraphQL<{ organization: OrgProfile | null }>(QUERY_ORG, {
         login: username,
       });
       user = data.organization;
@@ -295,35 +350,37 @@ async function directFetch(username: string, opts: FetchOptions): Promise<Profil
   let stars = 0;
   let reposCount = 0;
 
-  const processNode = (n: any, scopeCheck: boolean) => {
-    if (!n || !n.nameWithOwner || seenRepos.has(n.nameWithOwner)) return;
-    if (
-      scopeCheck &&
-      n.owner?.__typename === "Organization" &&
-      orgsSet &&
-      !orgsSet.has(n.owner.login.toLowerCase())
-    )
-      return;
-    seenRepos.add(n.nameWithOwner);
-    stars += n.stargazers?.totalCount || 0;
+  const processNode = (node: RepoNode, scopeCheck: boolean): void => {
+    if (!node?.nameWithOwner || node.isFork || seenRepos.has(node.nameWithOwner)) return;
+    if (scopeCheck) {
+      const owner = node.owner;
+      if (owner?.__typename !== "Organization" || !owner.login) return;
+      if (orgsSet && !orgsSet.has(owner.login.toLowerCase())) return;
+    }
+    seenRepos.add(node.nameWithOwner);
+    stars += node.stargazers?.totalCount ?? 0;
     reposCount++;
-    if (fetchLangs) accLangs(n.languages?.edges, langMap);
+    if (fetchLangs) accLangs(node.languages?.edges ?? null, langMap);
   };
 
-  const getConnection = (data: any, query: string) =>
+  type PaginateData = {
+    user?: { repositories?: RepoConnection; repositoriesContributedTo?: RepoConnection } | null;
+    organization?: { repositories: RepoConnection } | null;
+  };
+
+  const getConnection = (data: PaginateData, query: string): RepoConnection | undefined =>
     data.user
       ? query.includes("repositoriesContributedTo")
-        ? data.user.repositoriesContributedTo
-        : data.user.repositories
+        ? (data.user.repositoriesContributedTo ?? undefined)
+        : (data.user.repositories ?? undefined)
       : data.organization?.repositories;
 
-  const traversePages = async (query: string, scopeCheck: boolean) => {
+  const traversePages = async (query: string, scopeCheck: boolean): Promise<void> => {
     let cursor: string | null = null;
-    let page = 0;
-    let hasNext = true;
+    const seenCursors = new Set<string>();
 
-    while (hasNext && page++ < MAX_PAGES) {
-      const data = await postGraphQL(query, {
+    for (let page = 0; page < MAX_PAGES; page++) {
+      const data = await postGraphQL<PaginateData>(query, {
         login: username,
         cursor,
         pageSize: REPO_PAGE_SIZE,
@@ -331,11 +388,23 @@ async function directFetch(username: string, opts: FetchOptions): Promise<Profil
         affiliations,
       });
       const nextConn = getConnection(data, query);
-      for (const n of nextConn?.nodes || []) processNode(n, scopeCheck);
-      hasNext = nextConn?.pageInfo?.hasNextPage;
-      cursor = nextConn?.pageInfo?.endCursor;
-      if (hasNext && !cursor) break;
+      if (
+        !nextConn ||
+        !Array.isArray(nextConn.nodes) ||
+        typeof nextConn.pageInfo?.hasNextPage !== "boolean"
+      ) {
+        throw new UpstreamError("GitHub repository pagination connection is missing or invalid");
+      }
+      for (const node of nextConn.nodes) processNode(node, scopeCheck);
+      if (!nextConn.pageInfo.hasNextPage) return;
+      const nextCursor = nextConn.pageInfo.endCursor;
+      if (typeof nextCursor !== "string" || !nextCursor.trim() || seenCursors.has(nextCursor)) {
+        throw new UpstreamError("GitHub repository pagination cursor is missing or invalid");
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
     }
+    throw new UpstreamError(`GitHub repository pagination exceeded ${MAX_PAGES} pages`);
   };
 
   const tasks: Promise<void>[] = [];
@@ -348,39 +417,51 @@ async function directFetch(username: string, opts: FetchOptions): Promise<Profil
 
   const [avatarDataUrl] = await Promise.all([fetchAvatarAsBase64(user.avatarUrl), ...tasks]);
 
-  let commits = 0;
-  let prs = 0;
-  let issues = 0;
+  let commits: number | null = null;
+  let prs: number | null = null;
+  let issues: number | null = null;
 
   if (!isOrgAccount) {
-    const c = user.contributionsCollection;
+    const profile = user as ProfileUser;
+    const c = profile.contributionsCollection;
     if (opts.scope === "org") {
       commits = sumContributions(c?.commitContributionsByRepository, orgsSet);
       prs = sumContributions(c?.pullRequestContributionsByRepository, orgsSet);
       issues = sumContributions(c?.issueContributionsByRepository, orgsSet);
     } else {
-      commits = c?.totalCommitContributions || 0;
+      commits = c?.totalCommitContributions ?? 0;
       prs =
-        (user.openPRs?.totalCount || 0) +
-        (user.closedPRs?.totalCount || 0) +
-        (user.mergedPRs?.totalCount || 0);
-      issues = (user.openIssues?.totalCount || 0) + (user.closedIssues?.totalCount || 0);
+        (profile.openPRs?.totalCount ?? 0) +
+        (profile.closedPRs?.totalCount ?? 0) +
+        (profile.mergedPRs?.totalCount ?? 0);
+      issues = (profile.openIssues?.totalCount ?? 0) + (profile.closedIssues?.totalCount ?? 0);
     }
   }
 
+  const hiddenLanguages = new Set(opts.hideLangs);
+  const shownLanguages = new Set(opts.showLangs);
   const languages = Array.from(langMap.entries())
+    .filter(([name]) => {
+      const normalized = name.trim().toLowerCase();
+      return (
+        !hiddenLanguages.has(normalized) && (!shownLanguages.size || shownLanguages.has(normalized))
+      );
+    })
     .map(([name, { size, color }]) => ({ name, size, color }))
     .sort((a, b) => b.size - a.size)
-    .slice(0, opts.langCount || 5);
+    .slice(0, opts.langCount);
+
+  const profileUser = !isOrgAccount ? (user as ProfileUser) : null;
+  const orgUser = isOrgAccount ? (user as OrgProfile) : null;
 
   return {
     user: {
       login: user.login,
       name: user.name,
       avatarUrl: avatarDataUrl,
-      bio: user.bio || user.description,
-      pronouns: user.pronouns,
-      twitter: user.twitterUsername,
+      bio: isOrgAccount ? (orgUser?.description ?? null) : (profileUser?.bio ?? null),
+      pronouns: isOrgAccount ? null : (profileUser?.pronouns ?? null),
+      twitter: user.twitterUsername ?? null,
     },
     stats: { stars, repos: reposCount, prs, issues, commits },
     languages,
@@ -391,18 +472,39 @@ export async function getProfileData(
   username: string,
   opts: FetchOptions = {},
 ): Promise<ProfileData> {
-  const norm = normalizeUsername(username);
-  const orgs = normalizeOrgFilters(opts.orgs);
+  username = normalizeUsername(username);
+  const effectiveOpts: EffectiveFetchOptions = {
+    scope: opts.scope ?? "personal",
+    affiliations: opts.affiliations ?? "owner",
+    includeLanguages: opts.includeLanguages ?? true,
+    langCount: Number.isFinite(opts.langCount)
+      ? Math.max(1, Math.min(10, Math.floor(opts.langCount!)))
+      : 5,
+    hideLangs: normalizeOrgFilters(opts.hideLangs),
+    showLangs: normalizeOrgFilters(opts.showLangs),
+    orgs: normalizeOrgFilters(opts.orgs),
+    forceRefresh: opts.forceRefresh ?? false,
+  };
   const cacheKey = Bun.hash(
-    `v${CACHE_VERSION}:${norm}:${opts.scope || "personal"}:${opts.affiliations || "affiliated"}:${opts.includeLanguages !== false}:${opts.langCount || 5}:${orgs.join("|")}`,
+    JSON.stringify([
+      CACHE_VERSION,
+      username,
+      effectiveOpts.scope,
+      effectiveOpts.affiliations,
+      effectiveOpts.includeLanguages,
+      effectiveOpts.langCount,
+      effectiveOpts.orgs,
+      effectiveOpts.hideLangs,
+      effectiveOpts.showLangs,
+    ]),
   ).toString(36);
 
-  if (!opts.forceRefresh) {
+  if (!effectiveOpts.forceRefresh) {
     const mem = memCache.get(cacheKey);
     const now = Date.now();
     if (mem && mem.expiresAt > now) {
       if (mem.staleAt <= now && !refreshInFlight.has(cacheKey))
-        triggerBackgroundRefresh(username, opts, cacheKey);
+        triggerBackgroundRefresh(username, effectiveOpts, cacheKey);
       return mem.data;
     }
 
@@ -410,14 +512,14 @@ export async function getProfileData(
     if (cached) {
       setMemoryCache(cacheKey, cached);
       if (cached.staleAt <= now && !refreshInFlight.has(cacheKey))
-        triggerBackgroundRefresh(username, opts, cacheKey);
+        triggerBackgroundRefresh(username, effectiveOpts, cacheKey);
       return cached.data;
     }
   }
 
   if (inFlight.has(cacheKey)) return inFlight.get(cacheKey)!;
 
-  const promise = directFetch(username, opts)
+  const promise = directFetch(username, effectiveOpts)
     .then((data) => saveProfileCache(cacheKey, data))
     .finally(() => {
       inFlight.delete(cacheKey);
@@ -427,11 +529,11 @@ export async function getProfileData(
   return promise;
 }
 
-function triggerBackgroundRefresh(username: string, opts: FetchOptions, cacheKey: string) {
+function triggerBackgroundRefresh(username: string, opts: EffectiveFetchOptions, cacheKey: string) {
   if (refreshInFlight.has(cacheKey)) return;
   refreshInFlight.add(cacheKey);
 
-  void directFetch(username, { ...opts, forceRefresh: true })
+  void directFetch(username, opts)
     .then((data) => saveProfileCache(cacheKey, data))
     .catch(() => {})
     .finally(() => {