Function createRateLimitAwareGithub

actions/setup/js/github_rate_limit_logger.cjs:234–285

* Wrap a github object (as provided by actions/github-script) so that every * `github.rest.*.*()` call automatically logs rate-limit headers from the * response. * * Usage: * ```js * const { createRateLimitAwareGithub } = require('./github_rate_limit_logger.cjs'); * const gh = createRateLimit

(github)

 * @returns {any} A proxied github object with automatic rate-limit logging
 */
function createRateLimitAwareGithub(github) {
  /**
   * Wrap a single REST namespace (e.g. github.rest.issues) so each method
   * call intercepts the response and logs rate-limit headers.
   *
   * @param {any} namespace - The REST namespace object
   * @param {string} namespaceName - Name used for logging (e.g. "issues")
   * @returns {any}
   */
  function wrapNamespace(namespace, namespaceName) {
    return new Proxy(namespace, {
      get(target, method) {
        const fn = target[method];
        if (typeof fn !== "function") return fn;
        const wrapper = async (/** @type {any[]} */ ...args) => {
          const response = await fn.apply(target, args);
          logRateLimitFromResponse(response, `${namespaceName}.${String(method)}`);
          return response;
        };
        // Wrap the wrapper in a Proxy so that Octokit-specific property accesses
        // (e.g. .endpoint, used by github.paginate()) fall back to the original fn.
        // Without this, github.paginate(github.rest.checks.listForRef, ...) throws
        // "route.endpoint is not a function" because the wrapper does not have
        // the .endpoint decorator that Octokit endpoint methods carry.
        return new Proxy(wrapper, {
          get(wrapperTarget, prop) {
            const own = Reflect.get(wrapperTarget, prop);
            if (own !== undefined) return own;
            return Reflect.get(fn, prop);
          },
        });
      },
    });
  }

  // Wrap github.rest so every namespace access returns an instrumented proxy.
  const restProxy = new Proxy(github.rest, {
    get(target, namespaceName) {
      const ns = target[namespaceName];
      if (!ns || typeof ns !== "object") return ns;
      return wrapNamespace(ns, String(namespaceName));
    },
  });

  // Return a shallow proxy over github that replaces the `rest` property.
  return new Proxy(github, {
    get(target, prop) {
      if (prop === "rest") return restProxy;
      return target[prop];
    },
  });
}

module.exports = {
  logRateLimitFromResponse,