fix: use native fetch in production, normalize error payloads, lazy-load worker routes

- http.js: use native fetch for non-test envs to avoid axios adapter issues;
  add normalizeJsonPayload helper for consistent response parsing
- retryer.js: normalize non-GraphQL message payloads (e.g. Bad credentials)
  into GraphQL-like error shape in both success and catch paths
- repo.js: add missing imports and handle GraphQL errors from retryer response
- worker.js: lazy-load route handlers so process.env is populated before
  module evaluation; replace switch with route-map lookup; guard
  process.env from being undefined
- tests/pat-info.test.js: preserve NODE_ENV when resetting process.env in
  beforeAll so http.js continues to use axios mock adapter in tests

Author: BBleae

src/common/http.js

@@ -2,19 +2,80 @@
 
 import axios from "axios";
 
+/**
+ * Normalize response data to JSON object when possible.
+ *
+ * @param {unknown} payload The payload to normalize.
+ * @returns {any} Normalized payload.
+ */
+const normalizeJsonPayload = (payload) => {
+  if (typeof payload !== "string") {
+    return payload;
+  }
+
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return payload;
+  }
+};
+
 /**
  * Send GraphQL request to GitHub API.
  *
  * @param {import('axios').AxiosRequestConfig['data']} data Request data.
  * @param {import('axios').AxiosRequestConfig['headers']} headers Request headers.
  * @returns {Promise<any>} Request response.
  */
-const request = (data, headers) => {
+const request = async (data, headers) => {
+  const requestHeaders = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    "User-Agent": "github-readme-stats",
+    ...headers,
+  };
+
+  // Keep axios path only for tests where axios-mock-adapter is used.
+  // For runtime, use fetch to avoid adapter differences across environments.
+  if (process.env.NODE_ENV !== "test") {
+    const response = await fetch("https://api.github.com/graphql", {
+      method: "POST",
+      headers: requestHeaders,
+      body: JSON.stringify(data),
+    });
+
+    const rawBody = await response.text();
+    const parsedBody = normalizeJsonPayload(rawBody);
+
+    /** @type {any} */
+    const axiosLikeResponse = {
+      data: parsedBody,
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+    };
+
+    // Preserve axios-like rejection semantics for non-2xx status.
+    if (!response.ok) {
+      const err = new Error(
+        `Request failed with status code ${response.status}`,
+      );
+      // @ts-ignore
+      err.response = axiosLikeResponse;
+      throw err;
+    }
+
+    return axiosLikeResponse;
+  }
+
   return axios({
     url: "https://api.github.com/graphql",
     method: "post",
-    headers,
-    data,
+    headers: requestHeaders,
+    data: JSON.stringify(data),
+  }).then((response) => {
+    response.data = normalizeJsonPayload(response.data);
+    return response;
   });
 };
 

src/common/retryer.js

@@ -46,6 +46,29 @@ const retryer = async (fetcher, variables, retries = 0) => {
       retries,
     );
 
+    // normalize non-GraphQL payloads into GraphQL-like errors
+    // e.g. { message: "Bad credentials" } or API gateway messages.
+    if (
+      response?.data &&
+      !response.data.errors &&
+      !response.data.data &&
+      typeof response.data.message === "string"
+    ) {
+      response = {
+        ...response,
+        data: {
+          errors: [
+            {
+              type: String(
+                response.statusText || response.status || "HTTP_ERROR",
+              ),
+              message: response.data.message,
+            },
+          ],
+        },
+      };
+    }
+
     // react on both type and message-based rate-limit signals.
     // https://github.com/anuraghazra/github-readme-stats/issues/4425
     const errors = response?.data?.errors;
@@ -88,7 +111,23 @@ const retryer = async (fetcher, variables, retries = 0) => {
       return retryer(fetcher, variables, retries);
     }
 
-    // HTTP error with a response → return it for caller-side handling
+    // HTTP error with a response → normalize shape for caller-side handling
+    if (typeof e?.response?.data?.message === "string") {
+      return {
+        ...e.response,
+        data: {
+          errors: [
+            {
+              type: String(
+                e?.response?.statusText || e?.response?.status || "HTTP_ERROR",
+              ),
+              message: e.response.data.message,
+            },
+          ],
+        },
+      };
+    }
+
     return e.response;
   }
 };

src/fetchers/repo.js

@@ -3,6 +3,9 @@
 import { MissingParamError } from "../common/error.js";
 import { request } from "../common/http.js";
 import { retryer } from "../common/retryer.js";
+import { logger } from "../common/log.js";
+import { CustomError } from "../common/error.js";
+import { wrapTextMultiline } from "../common/fmt.js";
 
 /**
  * Repo data fetcher.
@@ -79,6 +82,20 @@ const fetchRepo = async (username, reponame) => {
 
   let res = await retryer(fetcher, { login: username, repo: reponame });
 
+  if (res.data.errors) {
+    logger.error(res.data.errors);
+    if (res.data.errors[0].message) {
+      throw new CustomError(
+        wrapTextMultiline(res.data.errors[0].message, 90, 1)[0],
+        res.statusText,
+      );
+    }
+    throw new CustomError(
+      "Something went wrong while trying to retrieve the repo data using the GraphQL API.",
+      CustomError.GRAPHQL_ERROR,
+    );
+  }
+
   const data = res.data.data;
 
   if (!data.user && !data.organization) {

src/worker.js

@@ -1,10 +1,34 @@
 // @ts-check
 import { workerAdapter } from "./common/adapter.js";
-import api from "../api/index.js";
-import pin from "../api/pin.js";
-import topLangs from "../api/top-langs.js";
-import wakatime from "../api/wakatime.js";
-import gist from "../api/gist.js";
+
+/** @type {Promise<Record<string, Function>> | null} */
+let routesPromise = null;
+
+/**
+ * Lazily loads route handlers after env variables are injected.
+ *
+ * @returns {Promise<Record<string, Function>>} Route handler map.
+ */
+const loadRoutes = async () => {
+  if (!routesPromise) {
+    routesPromise = Promise.all([
+      import("../api/index.js"),
+      import("../api/pin.js"),
+      import("../api/top-langs.js"),
+      import("../api/wakatime.js"),
+      import("../api/gist.js"),
+    ]).then(([api, pin, topLangs, wakatime, gist]) => ({
+      "/api": api.default,
+      "/api/index": api.default,
+      "/api/pin": pin.default,
+      "/api/top-langs": topLangs.default,
+      "/api/wakatime": wakatime.default,
+      "/api/gist": gist.default,
+    }));
+  }
+
+  return routesPromise;
+};
 
 export default {
   /**
@@ -19,25 +43,16 @@ export default {
   async fetch(request, env, ctx) {
     // Polyfill process.env for existing code accessing env vars
     globalThis.process = globalThis.process || {};
-    globalThis.process.env = { ...globalThis.process.env, ...env };
+    globalThis.process.env = { ...(globalThis.process.env || {}), ...env };
 
     const url = new URL(request.url);
     const path = url.pathname;
+    const routes = await loadRoutes();
 
-    switch (path) {
-      case "/api":
-      case "/api/index":
-        return workerAdapter(request, api);
-      case "/api/pin":
-        return workerAdapter(request, pin);
-      case "/api/top-langs":
-        return workerAdapter(request, topLangs);
-      case "/api/wakatime":
-        return workerAdapter(request, wakatime);
-      case "/api/gist":
-        return workerAdapter(request, gist);
-      default:
-        return new Response("Not Found", { status: 404 });
+    if (!routes[path]) {
+      return new Response("Not Found", { status: 404 });
     }
+
+    return workerAdapter(request, routes[path]);
   },
 };

tests/pat-info.test.js

@@ -73,7 +73,8 @@ afterEach(() => {
 describe("Test /api/status/pat-info", () => {
   beforeAll(() => {
     // reset patenv first so that dotenv doesn't populate them with local envs
-    process.env = {};
+    // preserve NODE_ENV so http.js continues to use axios (not fetch) in tests
+    process.env = { NODE_ENV: "test" };
     process.env.PAT_1 = "testPAT1";
     process.env.PAT_2 = "testPAT2";
     process.env.PAT_3 = "testPAT3";