@stats-organization/github-readme-stats-core 0.0.1

package/src/common/retryer.js

@@ -0,0 +1,104 @@
+// @ts-check
+
+import { getConfig } from "./config.js";
+import { CustomError } from "./error.js";
+import { logger } from "./log.js";
+
+/**
+ * Returns a random integer from 0 (inclusive) to `max` (exclusive).
+ *
+ * The value is generated using `Math.random()` and uniformly distributed
+ * across the range.
+ *
+ * @param {number} max The upper bound (exclusive). Must be a positive number.
+ *
+ * @returns {number} A random integer `n` such that `0 <= n < max`.
+ */
+function getRandomInt(max) {
+  return Math.floor(Math.random() * max);
+}
+
+/**
+ * @typedef {import("axios").AxiosResponse} AxiosResponse Axios response.
+ * @typedef {(variables: any, token: string, retriesForTests?: number) => Promise<AxiosResponse>} FetcherFunction Fetcher function.
+ */
+
+/**
+ * Try to execute the fetcher function until it succeeds or the max number of retries is reached.
+ *
+ * @param {FetcherFunction} fetcher The fetcher function.
+ * @param {any} variables Object with arguments to pass to the fetcher function.
+ * @param {string | null} pat Optional PAT override.
+ * @returns {Promise<any>} The response from the fetcher function.
+ */
+const retryer = async (fetcher, variables, pat = null) => {
+  let PATs;
+  if (pat) {
+    PATs = [{ name: "user PAT from database", value: pat }];
+  } else {
+    PATs = getConfig().pats;
+  }
+
+  if (!PATs.length) {
+    throw new CustomError("No GitHub API tokens found", CustomError.NO_TOKENS);
+  }
+  const startPAT = getRandomInt(PATs.length);
+
+  for (let retries = 0; retries < PATs.length; retries++) {
+    const currentPAT = PATs[(startPAT + retries) % PATs.length];
+
+    try {
+      let response = await fetcher(
+        variables,
+        // @ts-ignore
+        currentPAT.value,
+        // used in tests for faking rate limit
+        retries,
+      );
+
+      // react on both type and message-based rate-limit signals.
+      // https://github.com/anuraghazra/github-readme-stats/issues/4425
+      const errors = response?.data?.errors;
+      const errorType = errors?.[0]?.type;
+      const errorMsg = errors?.[0]?.message || "";
+      const isRateLimited =
+        (errors && errorType === "RATE_LIMITED") ||
+        /rate limit/i.test(errorMsg);
+
+      if (isRateLimited) {
+        logger.log(`${currentPAT.name} Failed due to rate limiting`);
+      } else {
+        return response;
+      }
+    } catch (err) {
+      /** @type {any} */
+      const e = err;
+
+      // network/unexpected error → let caller treat as failure
+      if (!e?.response) {
+        throw e;
+      }
+
+      // prettier-ignore
+      // also checking for bad credentials if any tokens gets invalidated
+      const isBadCredential =
+        e?.response?.data?.message === "Bad credentials";
+      const isAccountSuspended =
+        e?.response?.data?.message === "Sorry. Your account was suspended.";
+
+      if (isBadCredential || isAccountSuspended) {
+        logger.log(`${currentPAT.name} Failed due to bad credentials`);
+      } else {
+        // HTTP error with a response → return it for caller-side handling
+        return e.response;
+      }
+    }
+  }
+
+  throw new CustomError(
+    "Downtime due to GitHub API rate limiting",
+    CustomError.MAX_RETRY,
+  );
+};
+
+export { retryer };

package/src/fetchers/gist.js

@@ -0,0 +1,114 @@
+// @ts-check
+
+import { MissingParamError } from "../common/error.js";
+import { request } from "../common/http.js";
+import { retryer } from "../common/retryer.js";
+
+const QUERY = `
+query gistInfo($gistName: String!) {
+    viewer {
+        gist(name: $gistName) {
+            description
+            owner {
+                login
+            }
+            stargazerCount
+            forks {
+                totalCount
+            }
+            files {
+                name
+                language {
+                    name
+                }
+                size
+            }
+        }
+    }
+}
+`;
+
+/**
+ * Gist data fetcher.
+ *
+ * @param {object} variables Fetcher variables.
+ * @param {string} token GitHub token.
+ * @returns {Promise<import('axios').AxiosResponse>} The response.
+ */
+const fetcher = async (variables, token) => {
+  return await request(
+    { query: QUERY, variables },
+    { Authorization: `token ${token}` },
+  );
+};
+
+/**
+ * @typedef {{ name: string; language: { name: string; }, size: number }} GistFile Gist file.
+ */
+
+/**
+ * This function calculates the primary language of a gist by files size.
+ *
+ * @param {GistFile[]} files Files.
+ * @returns {string} Primary language.
+ */
+const calculatePrimaryLanguage = (files) => {
+  /** @type {Record<string, number>} */
+  const languages = {};
+
+  for (const file of files) {
+    if (file.language) {
+      if (languages[file.language.name]) {
+        languages[file.language.name] += file.size;
+      } else {
+        languages[file.language.name] = file.size;
+      }
+    }
+  }
+
+  let primaryLanguage = Object.keys(languages)[0];
+  for (const language in languages) {
+    if (languages[language] > languages[primaryLanguage]) {
+      primaryLanguage = language;
+    }
+  }
+
+  return primaryLanguage;
+};
+
+/**
+ * @typedef {import('./types').GistData} GistData Gist data.
+ */
+
+/**
+ * Fetch GitHub gist information by given username and ID.
+ *
+ * @param {string} id GitHub gist ID.
+ * @param {string | null} pat Optional PAT override.
+ * @returns {Promise<GistData>} Gist data.
+ */
+const fetchGist = async (id, pat = null) => {
+  if (!id) {
+    throw new MissingParamError(["id"], "/api/gist?id=GIST_ID");
+  }
+  const res = await retryer(fetcher, { gistName: id }, pat);
+  if (res.data.errors) {
+    throw new Error(res.data.errors[0].message);
+  }
+  if (!res.data.data.viewer.gist) {
+    throw new Error("Gist not found");
+  }
+  const data = res.data.data.viewer.gist;
+  return {
+    name: data.files[Object.keys(data.files)[0]].name,
+    nameWithOwner: `${data.owner.login}/${
+      data.files[Object.keys(data.files)[0]].name
+    }`,
+    description: data.description,
+    language: calculatePrimaryLanguage(data.files),
+    starsCount: data.stargazerCount,
+    forksCount: data.forks.totalCount,
+  };
+};
+
+export { fetchGist };

package/src/fetchers/repo.js

@@ -0,0 +1,165 @@
+// @ts-check
+
+import { MissingParamError } from "../common/error.js";
+import { request } from "../common/http.js";
+import { retryer } from "../common/retryer.js";
+
+import { fetchRepoUserStats } from "./stats.js";
+
+/**
+ * Repo data fetcher.
+ *
+ * @param {object} variables Fetcher variables.
+ * @param {string} token GitHub token.
+ * @returns {Promise<import('axios').AxiosResponse>} The response.
+ */
+const fetcher = (variables, token) => {
+  return request(
+    {
+      query: `
+      fragment RepoInfo on Repository {
+        name
+        nameWithOwner
+        isPrivate
+        isArchived
+        isTemplate
+        stargazers {
+          totalCount
+        }
+        description
+        primaryLanguage {
+          color
+          id
+          name
+        }
+        forkCount
+      }
+      query getRepo($login: String!, $repo: String!) {
+        user(login: $login) {
+          repository(name: $repo) {
+            ...RepoInfo
+          }
+        }
+        organization(login: $login) {
+          repository(name: $repo) {
+            ...RepoInfo
+          }
+        }
+      }
+    `,
+      variables,
+    },
+    {
+      Authorization: `token ${token}`,
+    },
+  );
+};
+
+const urlExample = "/api/pin?username=USERNAME&amp;repo=REPO_NAME";
+
+/**
+ * @typedef {import("./types").RepositoryData} RepositoryData Repository data.
+ */
+
+/**
+ * Fetch repository data.
+ *
+ * @param {string} username GitHub username.
+ * @param {string} reponame GitHub repository name.
+ * @returns {Promise<RepositoryData>} Repository data.
+ */
+const fetchRepo = async (
+  username,
+  reponame,
+  include_prs_authored = false,
+  include_prs_commented = false,
+  include_prs_reviewed = false,
+  include_issues_authored = false,
+  include_issues_commented = false,
+  pat = null,
+) => {
+  let owner = username;
+  if (reponame && reponame.includes("/")) {
+    const [parsed_owner, parsed_repo] = reponame.split("/");
+    owner = parsed_owner;
+    reponame = parsed_repo;
+  }
+
+  if (owner && !username) {
+    username = owner;
+  }
+  if (username && !owner) {
+    owner = username;
+  }
+  if (!username && !reponame) {
+    throw new MissingParamError(["username", "repo"], urlExample);
+  }
+  if (!username) {
+    throw new MissingParamError(["username"], urlExample);
+  }
+  if (!reponame) {
+    throw new MissingParamError(["repo"], urlExample);
+  }
+
+  let res = await retryer(fetcher, { login: owner, repo: reponame }, pat);
+
+  const data = res.data.data;
+
+  if (!data.user && !data.organization) {
+    throw new Error("Not found");
+  }
+
+  const isUser = data.organization === null && data.user;
+  const isOrg = data.user === null && data.organization;
+
+  if (isUser) {
+    if (!data.user.repository || data.user.repository.isPrivate) {
+      throw new Error("User Repository Not found");
+    }
+    let repoUserStats = await fetchRepoUserStats(
+      username,
+      [owner + "/" + reponame],
+      [],
+      include_prs_authored,
+      include_prs_commented,
+      include_prs_reviewed,
+      include_issues_authored,
+      include_issues_commented,
+      pat,
+    );
+    return {
+      ...repoUserStats,
+      ...data.user.repository,
+      starCount: data.user.repository.stargazers.totalCount,
+    };
+  }
+
+  if (isOrg) {
+    if (
+      !data.organization.repository ||
+      data.organization.repository.isPrivate
+    ) {
+      throw new Error("Organization Repository Not found");
+    }
+    let repoUserStats = await fetchRepoUserStats(
+      username,
+      [owner + "/" + reponame],
+      [],
+      include_prs_authored,
+      include_prs_commented,
+      include_prs_reviewed,
+      include_issues_authored,
+      include_issues_commented,
+      pat,
+    );
+    return {
+      ...repoUserStats,
+      ...data.organization.repository,
+      starCount: data.organization.repository.stargazers.totalCount,
+    };
+  }
+
+  throw new Error("Unexpected behavior");
+};
+
+export { fetchRepo };