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

package/src/common/retryer.ts

@@ -5,10 +5,11 @@ import { CustomError } from "./error.js";
 import { logger } from "./log.js";
 
 /**
- * Subset of the response payload the retryer inspects to detect
- * rate-limiting and credential failures.
+ * Error-detection fields the retryer inspects to detect rate-limiting and credential failures.
+ * Every fetcher's payload is intersected with
+ * this, so the retryer can read `errors`/`message` regardless of the payload's own shape.
  */
-interface ResponseData {
+interface ResponseErrors {
   errors?: Array<{ type?: string; message?: string }>;
   message?: string;
 }
@@ -27,27 +28,35 @@ function getRandomInt(max: number): number {
   return Math.floor(Math.random() * max);
 }
 
-type FetcherResponse = AxiosResponse<ResponseData>;
+/**
+ * A fetcher's Axios response. `TData` is the shape of `response.data`,
+ * which is intersected with {@link ResponseErrors} so the retryer can inspect
+ * `errors`/`message`.
+ * Defaults to `unknown` (error fields only) for callers that don't care about the payload.
+ */
+type FetcherResponse<TData = unknown> = AxiosResponse<TData & ResponseErrors>;
 
-type FetcherFunction = (
-  variables: Record<string, unknown>,
+type FetcherFunction<TData = unknown, TVariables = Record<string, unknown>> = (
+  variables: TVariables,
   token: string,
   retriesForTests?: number,
-) => Promise<FetcherResponse>;
+) => Promise<FetcherResponse<TData>>;
 
 /**
  * Try to execute the fetcher function until it succeeds or the max number of retries is reached.
  *
+ * @template TData Shape of `response.data` returned by the fetcher.
+ * @template TVariables Variables the fetcher accepts.
  * @param fetcher The fetcher function.
  * @param variables Object with arguments to pass to the fetcher function.
  * @param pat Optional PAT override.
  * @returns The response from the fetcher function.
  */
-const retryer = async (
-  fetcher: FetcherFunction,
-  variables: Record<string, unknown>,
+const retryer = async <TData = unknown, TVariables = Record<string, unknown>>(
+  fetcher: FetcherFunction<TData, TVariables>,
+  variables: TVariables,
   pat: string | null = null,
-): Promise<FetcherResponse> => {
+): Promise<FetcherResponse<TData>> => {
   const PATs = pat
     ? [{ name: "user PAT from database", value: pat }]
     : getConfig().pats;
@@ -86,7 +95,7 @@ const retryer = async (
         return response;
       }
     } catch (err) {
-      const e = err as { response?: FetcherResponse };
+      const e = err as { response?: FetcherResponse<TData> };
 
       // network/unexpected error → let caller treat as failure
       if (!e.response) {

package/src/fetchers/gist.ts

@@ -0,0 +1,79 @@
+import { MissingParamError } from "../common/error.js";
+import { createGraphQLFetcher } from "../common/http.js";
+import { retryer } from "../common/retryer.js";
+import { GistInfoDocument } from "../graphql/generated/gist.js";
+import type { GistFileInfoFragment } from "../graphql/generated/gist.js";
+
+import type { GistData } from "./types.js";
+
+const fetcher = createGraphQLFetcher(GistInfoDocument, "token");
+
+/**
+ * This function calculates the primary language of a gist by files size.
+ *
+ * @param files Files.
+ * @returns Primary language, or `null` when no file has a language.
+ */
+const calculatePrimaryLanguage = (
+  files: Array<GistFileInfoFragment>,
+): string | null => {
+  const languages: Record<string, number> = {};
+
+  for (const file of files) {
+    if (file.language) {
+      languages[file.language.name] =
+        (languages[file.language.name] ?? 0) + (file.size ?? 0);
+    }
+  }
+
+  let primaryLanguage: string | null = null;
+  let maxSize = -1;
+  for (const [language, size] of Object.entries(languages)) {
+    if (size > maxSize) {
+      maxSize = size;
+      primaryLanguage = language;
+    }
+  }
+
+  return primaryLanguage;
+};
+
+/**
+ * Fetch GitHub gist information by given username and ID.
+ *
+ * @param id GitHub gist ID.
+ * @param pat Optional PAT override.
+ * @returns Gist data.
+ */
+const fetchGist = async (
+  id: string,
+  pat: string | null = null,
+): Promise<GistData> => {
+  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);
+  }
+  const gist = res.data.data.viewer.gist;
+  if (!gist) {
+    throw new Error("Gist not found");
+  }
+  const firstFile = gist.files?.[0];
+  if (!firstFile?.name) {
+    throw new Error("Gist has no files");
+  }
+  return {
+    name: firstFile.name,
+    nameWithOwner: `${gist.owner?.login ?? ""}/${firstFile.name}`,
+    description: gist.description,
+    language: calculatePrimaryLanguage(
+      gist.files?.filter((file) => !!file) ?? [],
+    ),
+    starsCount: gist.stargazerCount,
+    forksCount: gist.forks.totalCount,
+  };
+};
+
+export { fetchGist };

package/src/fetchers/repo.ts

@@ -0,0 +1,114 @@
+import { MissingParamError } from "../common/error.js";
+import { createGraphQLFetcher } from "../common/http.js";
+import { retryer } from "../common/retryer.js";
+import { GetRepoDocument } from "../graphql/generated/repo.js";
+
+import { fetchRepoUserStats } from "./stats.js";
+import type { RepositoryData } from "./types.js";
+
+const fetcher = createGraphQLFetcher(GetRepoDocument, "token");
+
+const urlExample = "/api/pin?username=USERNAME&repo=REPO_NAME";
+
+/**
+ * Fetch repository data.
+ *
+ * @param username GitHub username.
+ * @param reponame GitHub repository name.
+ * @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 pat Optional PAT override.
+ * @returns Repository data.
+ */
+const fetchRepo = async (
+  username: string,
+  reponame: string,
+  include_prs_authored = false,
+  include_prs_commented = false,
+  include_prs_reviewed = false,
+  include_issues_authored = false,
+  include_issues_commented = false,
+  pat: string | null = null,
+): Promise<RepositoryData> => {
+  let owner = username;
+  if (reponame && reponame.includes("/")) {
+    const [parsedOwner, parsedRepo] = reponame.split("/");
+    owner = parsedOwner ?? "";
+    reponame = parsedRepo ?? "";
+  }
+
+  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);
+  }
+
+  const res = await retryer(fetcher, { login: owner, repo: reponame }, pat);
+
+  const data = res.data.data;
+
+  if (!data.user && !data.organization) {
+    throw new Error("Not found");
+  }
+
+  if (data.organization === null && data.user) {
+    const repository = data.user.repository;
+    if (!repository || repository.isPrivate) {
+      throw new Error("User Repository Not found");
+    }
+    const repoUserStats = await fetchRepoUserStats(
+      username,
+      [owner + "/" + reponame],
+      [],
+      include_prs_authored,
+      include_prs_commented,
+      include_prs_reviewed,
+      include_issues_authored,
+      include_issues_commented,
+      pat,
+    );
+    return {
+      ...repoUserStats,
+      ...repository,
+    };
+  }
+
+  if (data.user === null && data.organization) {
+    const repository = data.organization.repository;
+    if (!repository || repository.isPrivate) {
+      throw new Error("Organization Repository Not found");
+    }
+    const repoUserStats = await fetchRepoUserStats(
+      username,
+      [owner + "/" + reponame],
+      [],
+      include_prs_authored,
+      include_prs_commented,
+      include_prs_reviewed,
+      include_issues_authored,
+      include_issues_commented,
+      pat,
+    );
+    return {
+      ...repoUserStats,
+      ...repository,
+    };
+  }
+
+  throw new Error("Unexpected behavior");
+};
+
+export { fetchRepo };