@stats-forge/github-stats-forge-core 0.0.2 → 0.2.0

package/src/fetchers/stats.ts

@@ -1,30 +1,33 @@
-import githubUsernameRegex from 'github-username-regex';
-
-import { calculateRank } from '../calculateRank.js';
-import type { CardConfig } from '../common/config.js';
-import type { GitHubDateRange } from '../common/date.js';
-import { getGitHubYearRange, toGitHubDateTime } from '../common/date.js';
-import { CardError, USER_NOT_FOUND } from '../common/error.js';
-import { wrapTextMultiline } from '../common/fmt.js';
-import { createGraphQLFetcher, httpRequest } from '../common/http.js';
-import type { FetcherContext, GraphQLResponse } from '../common/http.js';
-import { logger } from '../common/log.js';
-import { buildSearchFilter, chunkArray, parseOwnerAffiliations } from '../common/ops.js';
-import { retryer } from '../common/retryer.js';
-import type { FetcherResponse } from '../common/retryer.js';
-import { buildContributionsDocument } from '../graphql/contributionsDocument.js';
-import { UserInfoDocument, UserReposDocument } from '../graphql/generated/stats.js';
+import { calculateRank } from '../calculateRank.ts';
+import type { CardConfig } from '../common/config.ts';
+import { GITHUB_USERNAME_PATTERN } from '../common/constants.ts';
+import type { GitHubDateRange } from '../common/date.ts';
+import {
+  getWidestRange,
+  toContributionRanges,
+  toGitHubDateTime,
+  toRange,
+  toYearRanges,
+} from '../common/date.ts';
+import { CardError, USER_NOT_FOUND } from '../common/error.ts';
+import { createGraphQLFetcher, httpRequest } from '../common/http.ts';
+import type { FetcherContext, GraphQLResponse } from '../common/http.ts';
+import { logger } from '../common/log.ts';
+import { buildSearchFilter, parseOwnerAffiliations } from '../common/ops.ts';
+import { retryer } from '../common/retryer.ts';
+import type { FetcherResponse } from '../common/retryer.ts';
+import { buildContributionsDocument } from '../graphql/contributionsDocument.ts';
+import { UserInfoDocument, UserReposDocument } from '../graphql/generated/stats.ts';
 import type {
+  RangeContributionsFragment,
   RepoNodeFragment,
   UserInfoQuery,
   UserInfoQueryVariables,
-} from '../graphql/generated/stats.js';
-import {
-  MAX_REPOSITORIES_LIMIT,
-  buildReposContributedToDocument,
-} from '../graphql/reposContributedToDocument.js';
+} from '../graphql/generated/stats.ts';
 
-import type { RepoUserStats, StatsData } from './types.js';
+import { fetchReposContributedTo } from './contributed-to.ts';
+import { graphqlError } from './graphql-error.ts';
+import type { RepoUserStats, StatsData } from './types.ts';
 
 /** The subset of the stats response `statsFetcher` returns and threads on. */
 type StatsFetcherResponse = Pick<GraphQLResponse<UserInfoQuery>, 'data' | 'statusText'>;
@@ -36,19 +39,10 @@ const reposFetcher = createGraphQLFetcher(UserReposDocument, 'bearer');
 /**
  * Fetch stats information for a given username.
  *
- * @param variables Fetcher variables.
- * @param variables.username GitHub username.
- * @param variables.includeMergedPullRequests Include merged pull requests.
- * @param variables.includeDiscussions Include discussions.
- * @param variables.includeDiscussionsAnswers Include discussions answers.
- * @param variables.startTime Time to start the count of total commits.
- * @param variables.ownerAffiliations The owner affiliations to filter by. Default: OWNER.
- * @param variables.includeUserRepositories Whether to include the user's own repositories in the repos contributed to.
- * @param config Deployment config supplying the PAT pool.
- * @returns The stats response, with every fetched page's repos merged in.
- *
  * @description Supports multi-page fetching when the `FETCH_MULTI_PAGE_STARS`
  * env variable is `true` or a fetch limit.
+ *
+ * @returns The stats response, with every fetched page's repos merged in.
  */
 const statsFetcher = async (
   {
@@ -56,7 +50,7 @@ const statsFetcher = async (
     includeMergedPullRequests,
     includeDiscussions,
     includeDiscussionsAnswers,
-    startTime,
+    commitsRange,
     ownerAffiliations,
     includeUserRepositories,
   }: {
@@ -64,7 +58,8 @@ const statsFetcher = async (
     includeMergedPullRequests: boolean;
     includeDiscussions: boolean;
     includeDiscussionsAnswers: boolean;
-    startTime: string | undefined;
+    /** The range the commit count covers; the last year, as GitHub reckons it, when absent. */
+    commitsRange: GitHubDateRange | undefined;
     ownerAffiliations: UserInfoQueryVariables['ownerAffiliations'];
     includeUserRepositories: boolean;
   },
@@ -79,7 +74,9 @@ const statsFetcher = async (
       includeMergedPullRequests,
       includeDiscussions,
       includeDiscussionsAnswers,
-      startTime,
+      // both ends together: an open `to` would run the range into the next 1st of January
+      startTime: commitsRange && toGitHubDateTime(commitsRange.from),
+      endTime: commitsRange && toGitHubDateTime(commitsRange.to),
       ownerAffiliations,
       includeUserRepositories,
     },
@@ -118,11 +115,11 @@ const statsFetcher = async (
 
     pageRepositories = page.data.data.user?.repositories;
     extraRepoNodes.push(...(pageRepositories?.nodes ?? []));
-    fetchedPages++;
+    fetchedPages += 1;
   }
 
   if (extraRepoNodes.length > 0) {
-    // deep copy to avoid mutating the response cached by the frontend
+    // defensive: the merge below is the only place a parsed response is mutated
     stats = structuredClone({
       data: stats.data,
       statusText: stats.statusText,
@@ -133,31 +130,34 @@ const statsFetcher = async (
   return stats;
 };
 
+/** One REST search: which index, the qualifiers scoping it, and the ones naming what to count. */
+interface SearchVariables {
+  /** `commits` or `issues`, the latter covering pull requests too. */
+  type: string;
+  /** Qualifiers appended after the scope, already `+`-joined. */
+  filter: string;
+  repo: Array<string>;
+  owner: Array<string>;
+}
+
 /**
  * Fetch total items count using the REST search API.
  *
- * @param variables Fetcher variables.
- * @param token GitHub token.
- * @param context What the retryer supplies each attempt.
- * @param context.fetch Transport to send the request with.
- * @returns The search response, carrying `total_count`.
- *
  * @see https://developer.github.com/v3/search/#search-commits
+ *
+ * @returns The search response, carrying `total_count`.
  */
 const fetchTotalItems = (
-  variables: Record<string, unknown>,
+  { type, filter, repo, owner }: SearchVariables,
   token: string,
   { fetch }: FetcherContext,
-): Promise<FetcherResponse<{ total_count?: number }>> => {
-  const type = String(variables['type']);
-  const filter = String(variables['filter']);
-  const repo = variables['repo'] as Array<string> | string;
-  const owner = variables['owner'] as Array<string> | string;
-  return httpRequest(
+): Promise<FetcherResponse<{ total_count?: number }>> =>
+  httpRequest(
     fetch,
-    `https://api.github.com/search/${type}?per_page=1&q=` +
-      buildSearchFilter(repo, owner).replaceAll(' ', '+') +
-      filter,
+    `https://api.github.com/search/${type}?per_page=1&q=${buildSearchFilter(repo, owner).replaceAll(
+      ' ',
+      '+',
+    )}${filter}`,
     {
       method: 'GET',
       headers: {
@@ -167,41 +167,21 @@ const fetchTotalItems = (
       },
     },
   );
-};
 
 /**
  * Fetch a total count for a given username via the REST search API.
  *
- * @param props Fetcher props.
- * @param props.username GitHub username.
- * @param props.repo Repositories the search is scoped to.
- * @param props.owner Owners the search is scoped to.
- * @param props.type Search endpoint to hit, `issues` or `commits`.
- * @param props.filter Query fragment appended to the scope filter.
- * @param config Deployment config supplying the PAT pool.
- * @returns Total count.
- *
  * The GraphQL API can't return this.
  * @see https://github.com/anuraghazra/github-readme-stats/issues/92#issuecomment-661026467
  * @see https://github.com/anuraghazra/github-readme-stats/pull/211
+ *
+ * @returns Total count.
  */
 const totalItemsFetcher = async (
-  {
-    username,
-    repo,
-    owner,
-    type,
-    filter,
-  }: {
-    username: string;
-    repo: Array<string>;
-    owner: Array<string>;
-    type: string;
-    filter: string;
-  },
+  { username, ...search }: SearchVariables & { username: string },
   config: CardConfig,
 ): Promise<number> => {
-  if (!githubUsernameRegex.test(username)) {
+  if (!GITHUB_USERNAME_PATTERN.test(username)) {
     logger.log('Invalid username provided.');
     throw new CardError('Invalid username provided.', {
       code: 'invalid_param',
@@ -211,19 +191,15 @@ const totalItemsFetcher = async (
 
   let res: FetcherResponse<{ total_count?: number }>;
   try {
-    res = await retryer<{ total_count?: number }>(
-      fetchTotalItems,
-      { login: username, repo, owner, type, filter },
-      config,
-    );
-  } catch (err) {
-    logger.log(err);
-    throw err;
+    res = await retryer(fetchTotalItems, search, config);
+  } catch (error) {
+    logger.log(error);
+    throw error;
   }
 
   const totalCount = res.data.total_count;
-  if (totalCount === undefined || isNaN(totalCount)) {
-    logger.error('GitHub error: ' + JSON.stringify(res.data));
+  if (typeof totalCount !== 'number' || Number.isNaN(totalCount)) {
+    logger.error(`GitHub error: ${JSON.stringify(res.data)}`);
     throw new CardError('Could not fetch data from GitHub REST API.', {
       code: 'upstream',
     });
@@ -231,19 +207,41 @@ const totalItemsFetcher = async (
   return totalCount;
 };
 
+/** The flags that ask for a per-repository count, as the query names them. */
+interface RepoUserStatsFlags {
+  include_prs_authored?: boolean | undefined;
+  include_prs_commented?: boolean | undefined;
+  include_prs_reviewed?: boolean | undefined;
+  include_issues_authored?: boolean | undefined;
+  include_issues_commented?: boolean | undefined;
+}
+
+/** Each count the REST search API answers: the flag asking for it, and the qualifiers that find it. */
+const REPO_USER_SEARCHES: ReadonlyArray<
+  [flag: keyof RepoUserStatsFlags, stat: keyof RepoUserStats, filter: (username: string) => string]
+> = [
+  ['include_prs_authored', 'totalPRsAuthored', (username) => `author:${username}+type:pr`],
+  [
+    'include_prs_commented',
+    'totalPRsCommented',
+    (username) => `commenter:${username}+-author:${username}+type:pr`,
+  ],
+  [
+    'include_prs_reviewed',
+    'totalPRsReviewed',
+    (username) => `reviewed-by:${username}+-author:${username}+type:pr`,
+  ],
+  ['include_issues_authored', 'totalIssuesAuthored', (username) => `author:${username}+type:issue`],
+  [
+    'include_issues_commented',
+    'totalIssuesCommented',
+    (username) => `commenter:${username}+-author:${username}+type:issue`,
+  ],
+];
+
 /**
  * Fetch the per-repository counts the REST search API answers, one request each.
  *
- * @param props Fetcher props.
- * @param props.username GitHub username.
- * @param props.repo Repositories the search is scoped to.
- * @param props.owner Owners the search is scoped to.
- * @param props.include_prs_authored Include count of PRs authored.
- * @param props.include_prs_commented Include count of PRs commented.
- * @param props.include_prs_reviewed Include count of PRs reviewed.
- * @param props.include_issues_authored Include count of issues authored.
- * @param props.include_issues_commented Include count of issues commented.
- * @param config Deployment config supplying the PAT pool.
  * @returns Only the counts that were asked for.
  */
 const fetchRepoUserStats = async (
@@ -251,126 +249,46 @@ const fetchRepoUserStats = async (
     username,
     repo = [],
     owner = [],
-    include_prs_authored = false,
-    include_prs_commented = false,
-    include_prs_reviewed = false,
-    include_issues_authored = false,
-    include_issues_commented = false,
-  }: {
+    ...flags
+  }: RepoUserStatsFlags & {
     username: string;
     repo?: Array<string>;
     owner?: Array<string>;
-    include_prs_authored?: boolean | undefined;
-    include_prs_commented?: boolean | undefined;
-    include_prs_reviewed?: boolean | undefined;
-    include_issues_authored?: boolean | undefined;
-    include_issues_commented?: boolean | undefined;
   },
   config: CardConfig,
 ): Promise<RepoUserStats> => {
   const stats: RepoUserStats = {};
-  if (include_prs_authored) {
-    stats.totalPRsAuthored = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `author:${username}+type:pr`,
-      },
-      config,
-    );
-  }
-  if (include_prs_commented) {
-    stats.totalPRsCommented = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `commenter:${username}+-author:${username}+type:pr`,
-      },
-      config,
-    );
-  }
-  if (include_prs_reviewed) {
-    stats.totalPRsReviewed = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `reviewed-by:${username}+-author:${username}+type:pr`,
-      },
-      config,
-    );
-  }
-  if (include_issues_authored) {
-    stats.totalIssuesAuthored = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `author:${username}+type:issue`,
-      },
-      config,
-    );
-  }
-  if (include_issues_commented) {
-    stats.totalIssuesCommented = await totalItemsFetcher(
-      {
-        username,
-        repo,
-        owner,
-        type: 'issues',
-        filter: `commenter:${username}+-author:${username}+type:issue`,
-      },
-      config,
-    );
+  for (const [flag, stat, filter] of REPO_USER_SEARCHES) {
+    if (flags[flag]) {
+      stats[stat] = await totalItemsFetcher(
+        { username, repo, owner, type: 'issues', filter: filter(username) },
+        config,
+      );
+    }
   }
   return stats;
 };
 
 /**
- * Turn a GraphQL `errors` payload into the error to throw.
- *
- * @param errors Errors from the response envelope.
- * @param statusText HTTP status text, used as the error type when GitHub gave a message.
- * @param fallback Message when GitHub gave none.
- */
-const graphqlError = (
-  errors: NonNullable<GraphQLResponse<unknown>['data']['errors']>,
-  statusText: string,
-  fallback: string,
-): CardError => {
-  logger.error(errors);
-  const message = errors[0]?.message;
-  return message
-    ? new CardError(wrapTextMultiline(message, 525, 12)[0] ?? '', {
-        code: 'upstream',
-        secondaryMessage: statusText,
-      })
-    : new CardError(fallback, { code: 'upstream' });
-};
-
-/**
- * Fetch all-time contributions by building a single GraphQL query
- * for all the given years.
+ * Sum one figure over a set of ranges, fetched as aliased fields of a single query.
  *
  * Whether private contributions are included depends on the user's profile settings:
  * https://docs.github.com/en/account-and-profile/how-tos/contribution-settings/manage-visibility-settings-for-private-contributions-and-achievements#changing-the-visibility-of-your-private-contributions
+ *
+ * @returns The total over every range, and 0 when there are none.
  */
-const fetchTotalContributions = async (
+const sumOverRanges = async (
   username: string,
-  years: Array<number>,
+  ranges: Array<GitHubDateRange>,
+  /** What one range contributes to the total. */
+  pick: (block: RangeContributionsFragment) => number,
   config: CardConfig,
 ): Promise<number> => {
-  if (years.length === 0) {
+  if (ranges.length === 0) {
     return 0;
   }
 
-  const contributionsFetcher = createGraphQLFetcher(buildContributionsDocument(years), 'bearer');
+  const contributionsFetcher = createGraphQLFetcher(buildContributionsDocument(ranges), 'bearer');
 
   const contribRes = await retryer(contributionsFetcher, { login: username }, config);
 
@@ -382,159 +300,21 @@ const fetchTotalContributions = async (
     );
   }
 
-  const user = contribRes.data.data.user;
+  const { user } = contribRes.data.data;
   if (!user) {
     return 0;
   }
 
   let total = 0;
-  for (const year of years) {
-    const yearBlock = user[`year_${year}`];
-    if (yearBlock?.contributionCalendar.totalContributions) {
-      total += yearBlock.contributionCalendar.totalContributions;
-    }
+  for (const block of Object.values(user)) {
+    total += pick(block);
   }
   return total;
 };
 
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-
-/**
- * Ranges per request.
- * Each costs roughly `4 * MAX_REPOSITORIES_LIMIT` nodes,
- * so an unchunked round of a heavily split account would breach GitHub's 500k node ceiling
- * and lose the ranges that had already resolved along with it.
- */
-const MAX_RANGES_PER_REQUEST = 100;
-
-const REPOS_CONTRIBUTED_TO_ERROR =
-  'Something went wrong while trying to retrieve the repository contributions data using the GraphQL API.';
-
-/**
- * Count the repositories a user contributed to across every contribution year.
- *
- * `repositoriesContributedTo` spans at most one year,
- * so every year is fetched as an aliased `contributionsCollection(from, to)` in one request and the repos de-duplicated.
- * A range returning `MAX_REPOSITORIES_LIMIT` results may have more,
- * so it is halved and requeried in the next round.
- *
- * Whether private contributions are included depends on the used PAT.
- *
- * @param canonicalUsername Username as GitHub reports it; `nameWithOwner` uses its
- *        casing, which the raw query-string username need not match.
- * @param years Contribution years to walk.
- * @param includeOwnRepos Whether to count the user's own repositories.
- * @param config Deployment config supplying the PAT pool.
- * @returns Count of repositories.
- */
-const fetchAllTimeReposContributedTo = async (
-  canonicalUsername: string,
-  years: Array<number>,
-  includeOwnRepos: boolean,
-  config: CardConfig,
-): Promise<number> => {
-  const repos = new Set<string>();
-  let pending = years.map(getGitHubYearRange);
-
-  while (pending.length > 0) {
-    const nextPending: Array<GitHubDateRange> = [];
-
-    for (const chunk of chunkArray(pending, MAX_RANGES_PER_REQUEST)) {
-      const fetcher = createGraphQLFetcher(
-        buildReposContributedToDocument(chunk, includeOwnRepos),
-        'bearer',
-      );
-      const res = await retryer(
-        fetcher,
-        { login: canonicalUsername, maxRepositories: MAX_REPOSITORIES_LIMIT },
-        config,
-      );
-      if (res.data.errors) {
-        throw graphqlError(res.data.errors, res.statusText, REPOS_CONTRIBUTED_TO_ERROR);
-      }
-      const user = res.data.data.user;
-      if (!user) {
-        throw new CardError(REPOS_CONTRIBUTED_TO_ERROR, { code: 'upstream' });
-      }
-
-      for (const [index, range] of chunk.entries()) {
-        const rangeResponse = user[`range_${index}`];
-        if (!rangeResponse) {
-          throw new CardError(REPOS_CONTRIBUTED_TO_ERROR, {
-            code: 'upstream',
-          });
-        }
-
-        const lists = [
-          rangeResponse.commitContributionsByRepository,
-          rangeResponse.issueContributionsByRepository,
-          rangeResponse.pullRequestContributionsByRepository,
-          (rangeResponse.repositoryContributions?.nodes ?? []).filter((node) => node !== null),
-        ];
-        const isSaturated = lists.some((list) => list.length >= MAX_REPOSITORIES_LIMIT);
-
-        const rangeDays = Math.round((range.to.getTime() - range.from.getTime()) / MS_PER_DAY);
-        // a range of 1 day or less can't be split any further
-        if (isSaturated && rangeDays >= 2) {
-          // every `from` sits on UTC midnight, so the split lands on a day boundary too
-          const mid = new Date(range.from.getTime() + Math.floor(rangeDays / 2) * MS_PER_DAY);
-          // GitHub only reads the date portion,
-          // so the first half ends 1 second before `mid` to keep the halves from sharing a day
-          nextPending.push(
-            { from: range.from, to: new Date(mid.getTime() - 1000) },
-            { from: mid, to: range.to },
-          );
-          continue;
-        }
-        if (isSaturated) {
-          logger.log(
-            `Range ${range.from.toISOString()} - ${range.to.toISOString()} is saturated but cannot be split further.`,
-          );
-        }
-
-        for (const { repository } of lists.flat()) {
-          const name = repository.nameWithOwner;
-          if (includeOwnRepos || !name.startsWith(`${canonicalUsername}/`)) {
-            repos.add(name);
-          }
-        }
-      }
-    }
-
-    // each saturated range pushes both of its halves
-    const saturatedCount = nextPending.length / 2;
-    if (saturatedCount > 0) {
-      logger.log(`found ${saturatedCount} saturated ranges, splitting and retrying...`);
-    }
-    pending = nextPending;
-  }
-
-  return repos.size;
-};
-
 /**
  * Fetch stats for a given username.
  *
- * @param props Fetcher props.
- * @param props.username GitHub username.
- * @param props.include_all_commits Include all commits.
- * @param props.exclude_repo Repositories to exclude.
- * @param props.include_merged_pull_requests Include merged pull requests.
- * @param props.include_discussions Include discussions.
- * @param props.include_discussions_answers Include discussions answers.
- * @param props.commits_year Year to count total commits.
- * @param props.repo Repositories to scope the REST search to.
- * @param props.owner Owners to scope the REST search to.
- * @param props.include_prs_authored Include count of PRs authored.
- * @param props.include_prs_commented Include count of PRs commented.
- * @param props.include_prs_reviewed Include count of PRs reviewed.
- * @param props.include_issues_authored Include count of issues authored.
- * @param props.include_issues_commented Include count of issues commented.
- * @param props.ownerAffiliations Owner affiliations. Default: OWNER.
- * @param props.include_contributions Include all-time contributions.
- * @param props.include_all_time_contribs Include all-time count of repos contributed to.
- * @param props.contribs_include_own_repos Include user-owned repos in contributed-to counts.
- * @param config Deployment config supplying the PAT pool.
  * @returns Stats data.
  */
 const fetchStats = async (
@@ -545,7 +325,8 @@ const fetchStats = async (
     include_merged_pull_requests = false,
     include_discussions = false,
     include_discussions_answers = false,
-    commits_year,
+    from,
+    to,
     repo = [],
     owner = [],
     include_prs_authored = false,
@@ -564,7 +345,10 @@ const fetchStats = async (
     include_merged_pull_requests?: boolean;
     include_discussions?: boolean;
     include_discussions_answers?: boolean;
-    commits_year?: number | undefined;
+    /** Start of the range the commit count covers; GitHub's own last year when neither end is given. */
+    from?: Date | undefined;
+    /** End of that range. */
+    to?: Date | undefined;
     repo?: Array<string>;
     owner?: Array<string>;
     include_prs_authored?: boolean;
@@ -590,6 +374,7 @@ const fetchStats = async (
     mergedPRsPercentage: 0,
     totalReviews: 0,
     totalCommits: 0,
+    commitsRange: undefined,
     totalIssues: 0,
     totalStars: 0,
     totalDiscussionsStarted: 0,
@@ -606,45 +391,34 @@ const fetchStats = async (
   };
   const affiliations = parseOwnerAffiliations(ownerAffiliations);
 
+  // neither end given leaves GitHub's trailing year in place, which `userInfo` already carries
+  const commitsRange = from === undefined && to === undefined ? undefined : toRange(from, to);
+  const commitsYearRanges = commitsRange ? toYearRanges(commitsRange) : [];
+  // one calendar year is a range `userInfo` can ask for itself; anything else is summed separately
+  const inlineRange = commitsYearRanges.length === 1 ? commitsYearRanges[0] : undefined;
+
   const res = await statsFetcher(
     {
       username,
       includeMergedPullRequests: include_merged_pull_requests,
       includeDiscussions: include_discussions,
       includeDiscussionsAnswers: include_discussions_answers,
-      startTime:
-        commits_year === undefined
-          ? undefined
-          : toGitHubDateTime(getGitHubYearRange(commits_year).from),
+      commitsRange: inlineRange,
       ownerAffiliations: affiliations,
       includeUserRepositories: contribs_include_own_repos,
     },
     config,
   );
 
-  // Catch GraphQL errors.
   if (res.data.errors) {
-    logger.error(res.data.errors);
-    const firstError = res.data.errors[0];
-    if (firstError?.type === 'NOT_FOUND') {
-      throw new CardError(firstError.message || 'Could not fetch user.', {
-        code: 'not_found',
-        secondaryMessage: USER_NOT_FOUND,
-      });
-    }
-    if (firstError?.message) {
-      throw new CardError(wrapTextMultiline(firstError.message, 525, 12)[0] ?? '', {
-        code: 'upstream',
-        secondaryMessage: res.statusText,
-      });
-    }
-    throw new CardError(
+    throw graphqlError(
+      res.data.errors,
+      res.statusText,
       'Something went wrong while trying to retrieve the stats data using the GraphQL API.',
-      { code: 'upstream' },
     );
   }
 
-  const user = res.data.data.user;
+  const { user } = res.data.data;
   if (!user) {
     throw new CardError('Could not fetch user.', {
       code: 'not_found',
@@ -667,7 +441,17 @@ const fetchStats = async (
       config,
     );
   } else {
-    stats.totalCommits = user.commits.totalCommitContributions;
+    stats.commitsRange = commitsRange;
+    // an inverted range sums no years, which is no commits rather than GitHub's default year
+    stats.totalCommits =
+      commitsRange && !inlineRange
+        ? await sumOverRanges(
+            username,
+            commitsYearRanges,
+            (block) => block.totalCommitContributions,
+            config,
+          )
+        : user.commits.totalCommitContributions;
   }
   const repoUserStats = await fetchRepoUserStats(
     {
@@ -700,21 +484,28 @@ const fetchStats = async (
   }
   stats.contributedTo = user.repositoriesContributedTo.totalCount;
 
+  const contributionRanges = toContributionRanges(
+    user.contributionsCollection.contributionYears,
+    getWidestRange(),
+  );
+
   if (include_contributions) {
-    stats.totalContributions = await fetchTotalContributions(
+    stats.totalContributions = await sumOverRanges(
       username,
-      user.contributionsCollection.contributionYears,
+      contributionRanges,
+      (block) => block.contributionCalendar.totalContributions,
       config,
     );
   }
 
   if (include_all_time_contribs) {
-    stats.allTimeContributedTo = await fetchAllTimeReposContributedTo(
+    const reposContributedTo = await fetchReposContributedTo(
       user.login,
-      user.contributionsCollection.contributionYears,
+      contributionRanges,
       contribs_include_own_repos,
       config,
     );
+    stats.allTimeContributedTo = reposContributedTo.size;
   }
 
   // Retrieve stars while filtering out repositories to be hidden.