@stats-organization/github-readme-stats-core 2.1.5 → 2.2.0

package/build/fetchers/stats.js

@@ -2,166 +2,106 @@ import axios from "axios";
 import githubUsernameRegex from "github-username-regex";
 import { calculateRank } from "../calculateRank.js";
 import { getConfig } from "../common/config.js";
+import { getGitHubYearRange, toGitHubDateTime } from "../common/date.js";
 import { CustomError, MissingParamError } from "../common/error.js";
 import { wrapTextMultiline } from "../common/fmt.js";
-import { request } from "../common/http.js";
+import { createGraphQLFetcher } from "../common/http.js";
 import { logger } from "../common/log.js";
 import { buildSearchFilter, parseOwnerAffiliations } from "../common/ops.js";
 import { retryer } from "../common/retryer.js";
-// GraphQL queries.
-const GRAPHQL_REPOS_FIELD = `
-  repositories(first: 100, after: $after, ownerAffiliations: $ownerAffiliations, orderBy: {direction: DESC, field: STARGAZERS}) {
-    totalCount
-    nodes {
-      name
-      stargazerCount
-    }
-    pageInfo {
-      hasNextPage
-      endCursor
-    }
-  }
-`;
-const GRAPHQL_REPOS_QUERY = `
-  query userInfo($login: String!, $after: String, $ownerAffiliations: [RepositoryAffiliation]) {
-    user(login: $login) {
-      ${GRAPHQL_REPOS_FIELD}
-    }
-  }
-`;
-const GRAPHQL_STATS_QUERY = `
-  query userInfo($login: String!, $after: String, $includeMergedPullRequests: Boolean!, $includeDiscussions: Boolean!, $includeDiscussionsAnswers: Boolean!, $startTime: DateTime = null, $ownerAffiliations: [RepositoryAffiliation]) {
-    user(login: $login) {
-      name
-      login
-      commits: contributionsCollection (from: $startTime) {
-        totalCommitContributions,
-      }
-      reviews: contributionsCollection {
-        totalPullRequestReviewContributions
-      }
-      repositoriesContributedTo(first: 1, contributionTypes: [COMMIT, ISSUE, PULL_REQUEST, REPOSITORY]) {
-        totalCount
-      }
-      pullRequests(first: 1) {
-        totalCount
-      }
-      mergedPullRequests: pullRequests(states: MERGED) @include(if: $includeMergedPullRequests) {
-        totalCount
-      }
-      openIssues: issues(states: OPEN) {
-        totalCount
-      }
-      closedIssues: issues(states: CLOSED) {
-        totalCount
-      }
-      followers {
-        totalCount
-      }
-      repositoryDiscussions @include(if: $includeDiscussions) {
-        totalCount
-      }
-      repositoryDiscussionComments(onlyAnswers: true) @include(if: $includeDiscussionsAnswers) {
-        totalCount
-      }
-      ${GRAPHQL_REPOS_FIELD}
-    }
-  }
-`;
-/**
- * Stats fetcher object.
- *
- * @param {object & { after: string | null }} variables Fetcher variables.
- * @param {string} token GitHub token.
- * @returns {Promise<import('axios').AxiosResponse>} Axios response.
- */
-const fetcher = (variables, token) => {
-    const query = variables.after ? GRAPHQL_REPOS_QUERY : GRAPHQL_STATS_QUERY;
-    return request({
-        query,
-        variables,
-    }, {
-        Authorization: `bearer ${token}`,
-    });
-};
+import { buildContributionsDocument } from "../graphql/contributionsDocument.js";
+import { UserInfoDocument, UserReposDocument, } from "../graphql/generated/stats.js";
+import { MAX_REPOSITORIES_LIMIT, buildReposContributedToDocument, } from "../graphql/reposContributedToDocument.js";
+const fetcher = createGraphQLFetcher(UserInfoDocument, "bearer");
+/** Fetcher for the pages after the first, which only need `repositories`. */
+const reposFetcher = createGraphQLFetcher(UserReposDocument, "bearer");
 /**
  * Fetch stats information for a given username.
  *
- * @param {object} variables Fetcher variables.
- * @param {string} variables.username GitHub username.
- * @param {boolean} variables.includeMergedPullRequests Include merged pull requests.
- * @param {boolean} variables.includeDiscussions Include discussions.
- * @param {boolean} variables.includeDiscussionsAnswers Include discussions answers.
- * @param {string|undefined} variables.startTime Time to start the count of total commits.
- * @param {string[]} variables.ownerAffiliations The owner affiliations to filter by. Default: OWNER.
- * @param {string | null} variables.pat PAT override or null.
- * @returns {Promise<import('axios').AxiosResponse>} Axios response.
+ * @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 variables.pat PAT override or null.
+ * @returns The stats response, with every fetched page's repos merged in.
  *
- * @description This function supports multi-page fetching if the 'FETCH_MULTI_PAGE_STARS' environment variable is set to true or a limit of fetches.
+ * @description Supports multi-page fetching when the `FETCH_MULTI_PAGE_STARS`
+ * env variable is `true` or a fetch limit.
  */
-const statsFetcher = async ({ username, includeMergedPullRequests, includeDiscussions, includeDiscussionsAnswers, startTime, ownerAffiliations, pat, }) => {
-    let stats;
-    let hasNextPage = true;
-    let endCursor = null;
-    let fetchedPages = 0;
-    while (hasNextPage) {
-        const variables = {
-            login: username,
-            first: 100,
-            after: endCursor,
-            includeMergedPullRequests,
-            includeDiscussions,
-            includeDiscussionsAnswers,
-            startTime,
-            ownerAffiliations,
-        };
-        let res = await retryer(fetcher, variables, pat);
-        if (res.data.errors) {
-            return res;
-        }
-        // Store stats data.
-        const repoNodes = res.data.data.user.repositories.nodes;
-        if (stats) {
-            if (fetchedPages === 1) {
-                // make deep copy of relevant stats fields to avoid altering the cached response object in frontend
-                stats = structuredClone({
-                    data: stats.data,
-                    statusText: stats.statusText,
-                });
-            }
-            stats.data.data.user.repositories.nodes.push(...repoNodes);
+const statsFetcher = async ({ username, includeMergedPullRequests, includeDiscussions, includeDiscussionsAnswers, startTime, ownerAffiliations, includeUserRepositories, pat, }) => {
+    // only the first request carries the stats themselves
+    let stats = await retryer(fetcher, {
+        login: username,
+        after: null,
+        includeMergedPullRequests,
+        includeDiscussions,
+        includeDiscussionsAnswers,
+        startTime,
+        ownerAffiliations,
+        includeUserRepositories,
+    }, pat);
+    if (stats.data.errors) {
+        return stats;
+    }
+    const pageLimit = getConfig().fetchMultiPageStars;
+    const extraRepoNodes = [];
+    let pageRepositories = stats.data.data.user?.repositories;
+    let previousCursor = null;
+    let fetchedPages = 1;
+    while (fetchedPages < pageLimit &&
+        // an unstarred repo on the page means the starred ones are exhausted
+        !pageRepositories?.nodes?.some((node) => node?.stargazerCount === 0) &&
+        pageRepositories?.pageInfo.hasNextPage) {
+        const after = pageRepositories.pageInfo.endCursor;
+        // a null or non-advancing cursor would refetch the same page forever
+        if (after === null || after === previousCursor) {
+            break;
         }
-        else {
-            stats = res;
+        previousCursor = after;
+        const page = await retryer(reposFetcher, { login: username, after, ownerAffiliations }, pat);
+        if (page.data.errors) {
+            return {
+                data: { ...stats.data, errors: page.data.errors },
+                statusText: page.statusText,
+            };
         }
+        pageRepositories = page.data.data.user?.repositories;
+        extraRepoNodes.push(...(pageRepositories?.nodes ?? []));
         fetchedPages++;
-        const repoNodesWithStars = repoNodes.filter((node) => node.stargazerCount !== 0);
-        hasNextPage =
-            (getConfig().fetchMultiPageStars === "true" ||
-                getConfig().fetchMultiPageStars > fetchedPages) &&
-                repoNodes.length === repoNodesWithStars.length &&
-                res.data.data.user.repositories.pageInfo.hasNextPage;
-        endCursor = res.data.data.user.repositories.pageInfo.endCursor;
+    }
+    if (extraRepoNodes.length > 0) {
+        // deep copy to avoid mutating the response cached by the frontend
+        stats = structuredClone({
+            data: stats.data,
+            statusText: stats.statusText,
+        });
+        stats.data.data.user?.repositories.nodes?.push(...extraRepoNodes);
     }
     return stats;
 };
 /**
- * Fetch total commits using the REST API.
+ * Fetch total items count using the REST search API.
  *
- * @param {object} variables Fetcher variables.
- * @param {string} token GitHub token.
- * @returns {Promise<import('axios').AxiosResponse>} Axios response.
+ * @param variables Fetcher variables.
+ * @param token GitHub token.
+ * @returns Axios response.
  *
  * @see https://developer.github.com/v3/search/#search-commits
  */
 const fetchTotalItems = (variables, token) => {
+    const type = String(variables["type"]);
+    const filter = String(variables["filter"]);
+    const repo = variables["repo"];
+    const owner = variables["owner"];
     return axios({
         method: "get",
-        url: `https://api.github.com/search/` +
-            variables.type +
-            `?per_page=1&q=` +
-            buildSearchFilter(variables.repo, variables.owner).replaceAll(" ", "+") +
-            variables.filter,
+        url: `https://api.github.com/search/${type}?per_page=1&q=` +
+            buildSearchFilter(repo, owner).replaceAll(" ", "+") +
+            filter,
         headers: {
             "Content-Type": "application/json",
             Accept: "application/vnd.github.cloak-preview",
@@ -170,13 +110,14 @@ const fetchTotalItems = (variables, token) => {
     });
 };
 /**
- * Fetch all the commits for all the repositories of a given username.
+ * Fetch a total count for a given username via the REST search API.
  *
- * @param {string} username GitHub username.
- * @returns {Promise<number>} Total commits.
+ * @param username GitHub username.
+ * @returns Total count.
  *
- * @description Done like this because the GitHub API does not provide a way to fetch all the commits. See
- * #92#issuecomment-661026467 and #211 for more information.
+ * 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
  */
 const totalItemsFetcher = async (username, repo, owner, type, filter, pat) => {
     if (!githubUsernameRegex.test(username)) {
@@ -185,27 +126,21 @@ const totalItemsFetcher = async (username, repo, owner, type, filter, pat) => {
     }
     let res;
     try {
-        res = await retryer(fetchTotalItems, {
-            login: username,
-            repo,
-            owner,
-            type,
-            filter,
-        }, pat);
+        res = await retryer(fetchTotalItems, { login: username, repo, owner, type, filter }, pat);
     }
     catch (err) {
         logger.log(err);
         throw err;
     }
     const totalCount = res.data.total_count;
-    if (isNaN(totalCount)) {
+    if (totalCount === undefined || isNaN(totalCount)) {
         logger.error("GitHub error: " + JSON.stringify(res.data));
         throw new CustomError("Could not fetch data from GitHub REST API.", CustomError.GITHUB_REST_API_ERROR);
     }
     return totalCount;
 };
 const fetchRepoUserStats = async (username, repo, owner, include_prs_authored, include_prs_commented, include_prs_reviewed, include_issues_authored, include_issues_commented, pat) => {
-    let stats = {};
+    const stats = {};
     if (include_prs_authored) {
         stats.totalPRsAuthored = await totalItemsFetcher(username, repo, owner, "issues", `author:${username}+type:pr`, pat);
     }
@@ -223,20 +158,192 @@ const fetchRepoUserStats = async (username, repo, owner, include_prs_authored, i
     }
     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, statusText, fallback) => {
+    logger.error(errors);
+    const message = errors[0]?.message;
+    return message
+        ? new CustomError(wrapTextMultiline(message, 525, 12)[0] ?? "", statusText)
+        : new CustomError(fallback, CustomError.GRAPHQL_ERROR);
+};
+/**
+ * Fetch all-time contributions by building a single GraphQL query
+ * for all the given years.
+ *
+ * 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
+ */
+const fetchTotalContributions = async (username, years, pat = null) => {
+    if (years.length === 0) {
+        return 0;
+    }
+    const contributionsFetcher = createGraphQLFetcher(buildContributionsDocument(years), "bearer");
+    const contribRes = await retryer(contributionsFetcher, { login: username }, pat);
+    if (contribRes.data.errors) {
+        throw graphqlError(contribRes.data.errors, contribRes.statusText, "Something went wrong while trying to retrieve the contributions data using the GraphQL API.");
+    }
+    const user = contribRes.data.data.user;
+    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;
+        }
+    }
+    return total;
+};
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/**
+ * Ranges per request.
+ * Each costs roughly `4 * MAX_REPOSITORIES_LIMIT` nodes,
+ * so an unchunked request for a heavily split account would breach GitHub's 500k node ceiling.
+ * GitHub can still reject a request of this size, in which case the chunk size is halved
+ * and the request retried; it is increased back up to this maximum after every success.
+ */
+const MAX_RANGES_PER_REQUEST = 400;
+const REPOS_CONTRIBUTED_TO_ERROR = "Something went wrong while trying to retrieve the repository contributions data using the GraphQL API.";
+/** GraphQL error type GitHub returns when a query exceeds its node/complexity budget. */
+const RESOURCE_LIMITS_EXCEEDED = "RESOURCE_LIMITS_EXCEEDED";
+/**
+ * Whether GitHub rejected the query for returning too many results.
+ *
+ * @see https://docs.github.com/en/graphql/overview/rate-limits-and-query-limits-for-the-graphql-api#other-resource-limits
+ *
+ * @param errors Errors from the response envelope.
+ * @returns True if the query has to be retried with fewer ranges.
+ */
+const isResourceLimitsExceeded = (errors) => errors.some((error) => error.type === RESOURCE_LIMITS_EXCEEDED);
+/**
+ * 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.
+ * Ranges are worked off a queue, multiple ranges at a time.
+ * A range returning `MAX_REPOSITORIES_LIMIT` results may have more,
+ * so it is halved and both halves are queued again.
+ * When GitHub rejects a request with `RESOURCE_LIMITS_EXCEEDED` or a timeout,
+ * it is retried with half as many ranges.
+ * When GitHub rejects a request with an empty response, it is retried up to 3 times.
+ *
+ * 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 pat Optional PAT override.
+ * @returns Count of repositories.
+ */
+const fetchAllTimeReposContributedTo = async (canonicalUsername, years, includeOwnRepos, pat) => {
+    const repos = new Set();
+    const pending = years.map(getGitHubYearRange);
+    // halved when GitHub rejects a request for exceeding its resource limits, increases on success
+    let rangesPerRequest = MAX_RANGES_PER_REQUEST;
+    let emptyResponseRetries = 0;
+    const MAX_EMPTY_RESPONSE_RETRIES = 3;
+    while (pending.length > 0) {
+        const chunk = pending.slice(0, rangesPerRequest);
+        const fetcher = createGraphQLFetcher(buildReposContributedToDocument(chunk, includeOwnRepos), "bearer");
+        const res = await retryer(fetcher, { login: canonicalUsername, maxRepositories: MAX_REPOSITORIES_LIMIT }, pat);
+        if (res.status === 502 || res.status === 504) {
+            if (chunk.length > 1) {
+                rangesPerRequest = Math.floor(chunk.length / 2);
+                logger.log(`Gateway timeout (${res.status}), retrying with ${rangesPerRequest} range(s) per request...`);
+                continue;
+            }
+            throw new CustomError(REPOS_CONTRIBUTED_TO_ERROR, CustomError.GRAPHQL_ERROR);
+        }
+        if (res.data.errors) {
+            if (isResourceLimitsExceeded(res.data.errors) && chunk.length > 1) {
+                rangesPerRequest = Math.floor(chunk.length / 2);
+                logger.log(`Resource limits exceeded, retrying with ${rangesPerRequest} range(s) per request...`);
+                continue;
+            }
+            throw graphqlError(res.data.errors, res.statusText, REPOS_CONTRIBUTED_TO_ERROR);
+        }
+        if (typeof res.data !== "object") {
+            if (emptyResponseRetries < MAX_EMPTY_RESPONSE_RETRIES) {
+                emptyResponseRetries++;
+                logger.log(`Empty response from GitHub, retrying (${emptyResponseRetries}/${MAX_EMPTY_RESPONSE_RETRIES})...`);
+                continue;
+            }
+            throw new CustomError(REPOS_CONTRIBUTED_TO_ERROR, CustomError.GRAPHQL_ERROR);
+        }
+        emptyResponseRetries = 0;
+        const user = res.data.data.user;
+        if (!user) {
+            throw new CustomError(REPOS_CONTRIBUTED_TO_ERROR, CustomError.GRAPHQL_ERROR);
+        }
+        pending.splice(0, chunk.length);
+        rangesPerRequest = Math.min(MAX_RANGES_PER_REQUEST, Math.ceil(rangesPerRequest * 1.25));
+        for (const [index, range] of chunk.entries()) {
+            const rangeResponse = user[`range_${index}`];
+            if (!rangeResponse) {
+                throw new CustomError(REPOS_CONTRIBUTED_TO_ERROR, CustomError.GRAPHQL_ERROR);
+            }
+            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);
+            if (isSaturated && rangeDays >= 2) {
+                const mid = new Date(range.from.getTime() + Math.floor(rangeDays / 2) * MS_PER_DAY);
+                logger.log(`Range ${range.from.toISOString()} - ${range.to.toISOString()} is saturated, splitting and retrying...`);
+                // GitHub only reads the date portion,
+                // so the first half ends 1 second before `mid` to keep the halves from sharing a day
+                pending.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);
+                }
+            }
+        }
+    }
+    return repos.size;
+};
 /**
  * Fetch stats for a given username.
  *
- * @param {string} username GitHub username.
- * @param {boolean} include_all_commits Include all commits.
- * @param {string[]} exclude_repo Repositories to exclude.
- * @param {boolean} include_merged_pull_requests Include merged pull requests.
- * @param {boolean} include_discussions Include discussions.
- * @param {boolean} include_discussions_answers Include discussions answers.
- * @param {number|undefined} commits_year Year to count total commits
- * @param {string[]} ownerAffiliations Owner affiliations. Default: OWNER.
- * @returns {Promise<import("./types").StatsData>} Stats data.
+ * @param username GitHub username.
+ * @param include_all_commits Include all commits.
+ * @param exclude_repo Repositories to exclude.
+ * @param include_merged_pull_requests Include merged pull requests.
+ * @param include_discussions Include discussions.
+ * @param include_discussions_answers Include discussions answers.
+ * @param commits_year Year to count total commits.
+ * @param repo Repositories to scope the REST search to.
+ * @param owner Owners to scope the REST search to.
+ * @param include_prs_authored Include count of PRs authored.
+ * @param include_prs_commented Include count of PRs commented.
+ * @param include_prs_reviewed Include count of PRs reviewed.
+ * @param include_issues_authored Include count of issues authored.
+ * @param include_issues_commented Include count of issues commented.
+ * @param ownerAffiliations Owner affiliations. Default: OWNER.
+ * @param include_contributions Include all-time contributions.
+ * @param include_all_time_contribs Include all-time count of repos contributed to.
+ * @param contribs_include_own_repos Include user-owned repos in contributed-to counts.
+ * @param pat Optional PAT override.
+ * @returns Stats data.
  */
-const fetchStats = async (username, include_all_commits = false, exclude_repo = [], include_merged_pull_requests = false, include_discussions = false, include_discussions_answers = false, commits_year, repo = [], owner = [], include_prs_authored = false, include_prs_commented = false, include_prs_reviewed = false, include_issues_authored = false, include_issues_commented = false, ownerAffiliations = [], pat = null) => {
+const fetchStats = async (username, include_all_commits = false, exclude_repo = [], include_merged_pull_requests = false, include_discussions = false, include_discussions_answers = false, commits_year, repo = [], owner = [], include_prs_authored = false, include_prs_commented = false, include_prs_reviewed = false, include_issues_authored = false, include_issues_commented = false, ownerAffiliations = [], include_contributions = false, include_all_time_contribs = false, contribs_include_own_repos = false, pat = null) => {
     if (!username) {
         throw new MissingParamError(["username"]);
     }
@@ -252,34 +359,44 @@ const fetchStats = async (username, include_all_commits = false, exclude_repo =
         totalDiscussionsStarted: 0,
         totalDiscussionsAnswered: 0,
         contributedTo: 0,
+        allTimeContributedTo: 0,
         totalPRsAuthored: 0,
         totalPRsCommented: 0,
         totalPRsReviewed: 0,
         totalIssuesAuthored: 0,
         totalIssuesCommented: 0,
+        totalContributions: 0,
         rank: { level: "C", percentile: 100 },
     };
-    ownerAffiliations = parseOwnerAffiliations(ownerAffiliations);
-    let res = await statsFetcher({
+    const affiliations = parseOwnerAffiliations(ownerAffiliations);
+    const res = await statsFetcher({
         username,
         includeMergedPullRequests: include_merged_pull_requests,
         includeDiscussions: include_discussions,
         includeDiscussionsAnswers: include_discussions_answers,
-        startTime: commits_year ? `${commits_year}-01-01T00:00:00Z` : undefined,
-        ownerAffiliations,
-    }, pat);
+        startTime: commits_year === undefined
+            ? undefined
+            : toGitHubDateTime(getGitHubYearRange(commits_year).from),
+        ownerAffiliations: affiliations,
+        includeUserRepositories: contribs_include_own_repos,
+        pat,
+    });
     // Catch GraphQL errors.
     if (res.data.errors) {
         logger.error(res.data.errors);
-        if (res.data.errors[0].type === "NOT_FOUND") {
-            throw new CustomError(res.data.errors[0].message || "Could not fetch user.", CustomError.USER_NOT_FOUND);
+        const firstError = res.data.errors[0];
+        if (firstError?.type === "NOT_FOUND") {
+            throw new CustomError(firstError.message || "Could not fetch user.", CustomError.USER_NOT_FOUND);
         }
-        if (res.data.errors[0].message) {
-            throw new CustomError(wrapTextMultiline(res.data.errors[0].message, 525, 12)[0], res.statusText);
+        if (firstError?.message) {
+            throw new CustomError(wrapTextMultiline(firstError.message, 525, 12)[0] ?? "", res.statusText);
         }
         throw new CustomError("Something went wrong while trying to retrieve the stats data using the GraphQL API.", CustomError.GRAPHQL_ERROR);
     }
     const user = res.data.data.user;
+    if (!user) {
+        throw new CustomError("Could not fetch user.", CustomError.USER_NOT_FOUND);
+    }
     stats.name = user.name || user.login;
     // if include_all_commits, fetch all commits using the REST API.
     if (include_all_commits) {
@@ -288,38 +405,40 @@ const fetchStats = async (username, include_all_commits = false, exclude_repo =
     else {
         stats.totalCommits = user.commits.totalCommitContributions;
     }
-    let repoUserStats = await fetchRepoUserStats(username, repo, owner, include_prs_authored, include_prs_commented, include_prs_reviewed, include_issues_authored, include_issues_commented, pat);
+    const repoUserStats = await fetchRepoUserStats(username, repo, owner, include_prs_authored, include_prs_commented, include_prs_reviewed, include_issues_authored, include_issues_commented, pat);
     Object.assign(stats, repoUserStats);
     stats.totalPRs = user.pullRequests.totalCount;
     if (include_merged_pull_requests) {
-        stats.totalPRsMerged = user.mergedPullRequests.totalCount;
+        const mergedCount = user.mergedPullRequests?.totalCount ?? 0;
+        stats.totalPRsMerged = mergedCount;
         stats.mergedPRsPercentage =
-            (user.mergedPullRequests.totalCount / user.pullRequests.totalCount) *
-                100 || 0;
+            (mergedCount / user.pullRequests.totalCount) * 100 || 0;
     }
     stats.totalReviews = user.reviews.totalPullRequestReviewContributions;
     stats.totalIssues = user.openIssues.totalCount + user.closedIssues.totalCount;
     if (include_discussions) {
-        stats.totalDiscussionsStarted = user.repositoryDiscussions.totalCount;
+        stats.totalDiscussionsStarted = user.repositoryDiscussions?.totalCount ?? 0;
     }
     if (include_discussions_answers) {
         stats.totalDiscussionsAnswered =
-            user.repositoryDiscussionComments.totalCount;
+            user.repositoryDiscussionComments?.totalCount ?? 0;
     }
     stats.contributedTo = user.repositoriesContributedTo.totalCount;
+    if (include_contributions) {
+        stats.totalContributions = await fetchTotalContributions(username, user.contributionsCollection.contributionYears, pat);
+    }
+    if (include_all_time_contribs) {
+        stats.allTimeContributedTo = await fetchAllTimeReposContributedTo(user.login, user.contributionsCollection.contributionYears, contribs_include_own_repos, pat);
+    }
     // Retrieve stars while filtering out repositories to be hidden.
     const allExcludedRepos = [
         ...exclude_repo,
         ...getConfig().excludeRepositories,
     ];
-    let repoToHide = new Set(allExcludedRepos);
-    stats.totalStars = user.repositories.nodes
-        .filter((data) => {
-        return !repoToHide.has(data.name);
-    })
-        .reduce((prev, curr) => {
-        return prev + curr.stargazerCount;
-    }, 0);
+    const repoToHide = new Set(allExcludedRepos);
+    stats.totalStars = (user.repositories.nodes ?? [])
+        .filter((data) => !!data && !repoToHide.has(data.name))
+        .reduce((prev, curr) => prev + (curr?.stargazerCount ?? 0), 0);
     stats.rank = calculateRank({
         all_commits: include_all_commits,
         commits: stats.totalCommits,

package/build/fetchers/top-languages.d.ts

@@ -1,20 +1,15 @@
-/**
- * Top languages data.
- */
-export type TopLangData = any;
-/**
- * @typedef {import("./types").TopLangData} TopLangData Top languages data.
- */
+import type { TopLangData } from "./types.js";
 /**
  * Fetch top languages for a given username.
  *
- * @param {string} username GitHub username.
- * @param {string[]} exclude_repo List of repositories to exclude. Default: [].
- * @param {number} size_weight Weightage to be given to size.
- * @param {number} count_weight Weightage to be given to count.
- * @param {string[]} ownerAffiliations The owner affiliations to filter by. Default: OWNER.
- * @param {string|null} pat Optional PAT override.
- * @returns {Promise<TopLangData>} Top languages data.
+ * @param username GitHub username.
+ * @param exclude_repo List of repositories to exclude. Default: [].
+ * @param size_weight Weightage to be given to size.
+ * @param count_weight Weightage to be given to count.
+ * @param ownerAffiliations The owner affiliations to filter by. Default: OWNER.
+ * @param pat Optional PAT override.
+ * @returns Top languages data.
  */
-export function fetchTopLanguages(username: string, exclude_repo?: string[], size_weight?: number, count_weight?: number, ownerAffiliations?: string[], pat?: string | null): Promise<TopLangData>;
+declare const fetchTopLanguages: (username: string, exclude_repo?: Array<string>, size_weight?: number, count_weight?: number, ownerAffiliations?: Array<string>, pat?: string | null) => Promise<TopLangData>;
+export { fetchTopLanguages };
 //# sourceMappingURL=top-languages.d.ts.map

package/build/fetchers/top-languages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"top-languages.d.ts","sourceRoot":"","sources":["../../src/fetchers/top-languages.js"],"names":[],"mappings":";;;;AA+CA;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,4CARW,MAAM,iBACN,MAAM,EAAE,gBACR,MAAM,iBACN,MAAM,sBACN,MAAM,EAAE,QACR,MAAM,GAAC,IAAI,GACT,OAAO,CAAC,WAAW,CAAC,CAgHhC"}
+{"version":3,"file":"top-languages.d.ts","sourceRoot":"","sources":["../../src/fetchers/top-languages.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAQ,WAAW,EAAE,MAAM,YAAY,CAAC;AAIpD;;;;;;;;;;GAUG;AACH,QAAA,MAAM,iBAAiB,GACrB,UAAU,MAAM,EAChB,eAAc,KAAK,CAAC,MAAM,CAAM,EAChC,oBAAe,EACf,qBAAgB,EAChB,oBAAmB,KAAK,CAAC,MAAM,CAAM,EACrC,MAAK,MAAM,GAAG,IAAW,KACxB,OAAO,CAAC,WAAW,CAiGrB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,CAAC"}