rivalsjs/dist/index.cjs

<h1 align="center"> Rivals JS </h1>

'use strict';

var axios = require('axios');
var axiosRetry = require('axios-retry');
var camelcaseKeys = require('camelcase-keys');
var constants = require('./constants-Cz2zS-Zn.cjs');
var pino = require('pino');

const logger = pino({
  name: "rivalsjs",
  level: process.env.NODE_ENV === "production" ? process.env.LOG_LEVEL || "info" : "debug",
  transport: process.env.NODE_ENV === "production" ? void 0 : {
    target: "pino-pretty",
    options: {
      colorize: true
    }
  }
});

function createRivalsClient(config) {
  if (!config.apiKey) {
    throw new Error("API key is required to create a client.");
  }
  if (config.retryOnRateLimit === void 0 || config.retryOnRateLimit === null) {
    logger.warn(
      "`retryOnRateLimit` is not set. Defaulting to `false`. Will throw an error on rate limit exceeded."
    );
    config.retryOnRateLimit = false;
  }
  if (config.verifyRateLimitHeader === void 0 || config.verifyRateLimitHeader === null) {
    logger.warn(
      "`verifyRateLimitHeader` is not set. Defaulting to `true`. Bad cache headers will throw error."
    );
    config.verifyRateLimitHeader = true;
  }
  const client = buildAxios(config);
  return client;
}
function buildAxios(config) {
  const version = "1.2.0";
  logger.debug("Using RivalsJS version %s", version);
  const client = axios.create({
    baseURL: constants.BASE_API_URL,
    headers: {
      "X-API-Key": config.apiKey,
      "Content-Type": "application/json",
      Accept: "application/json",
      "User-Agent": `RivalsJS/${version}`
    }
  });
  client.interceptors.request.use(
    (config2) => {
      logger.debug(
        "Requesting %s %s",
        config2.method?.toUpperCase(),
        config2.url
      );
      return config2;
    },
    (error) => {
      logger.error("Request error:", error);
      return Promise.reject(error);
    }
  );
  client.interceptors.response.use(
    (response) => {
      const rateLimitRemaining = response.headers["x-ratelimit-remaining"];
      if (!rateLimitRemaining) {
        return response;
      }
      logger.debug(
        "Received %d response from %s %s",
        response.status,
        response.config.method?.toUpperCase(),
        response.config.url
      );
      logger.debug("Rate limit remaining: %s", rateLimitRemaining);
      if (config.verifyRateLimitHeader) {
        if (String(rateLimitRemaining).toLowerCase() !== "cache" && Number.isNaN(Number(rateLimitRemaining))) {
          logger.error("Invalid rate limit header: %s", rateLimitRemaining);
          return Promise.reject("Invalid rate limit header");
        }
      }
      return response;
    },
    (error) => {
      if (error.response) {
        logger.error(
          "Response error: %s %d - %s",
          error.response.config.url,
          error.response.status,
          error.response.statusText
        );
        logger.debug("Response data:", error.response.data);
      } else {
        logger.error("Network or request error:", error.message);
      }
      return Promise.reject(error);
    }
  );
  client.interceptors.response.use(
    (response) => {
      const cleanedData = camelcaseKeys(response.data, { deep: true });
      return {
        ...response,
        data: cleanedData
      };
    },
    (error) => Promise.reject(error)
  );
  if (config.retryOnRateLimit) {
    axiosRetry(client, {
      retries: 2,
      retryCondition: (error) => {
        return axiosRetry.isNetworkOrIdempotentRequestError(error) || error.response?.status === 429;
      },
      retryDelay: (retryCount, error) => {
        const resetHeader = error.response?.headers["x-ratelimit-reset"];
        if (error.response?.status === 429 && resetHeader) {
          const resetTimestamp = parseInt(resetHeader, 10) * 1e3;
          const delay = Math.max(0, resetTimestamp - Date.now());
          logger.debug("Rate limit exceeded, retrying after %d ms", delay);
          return delay;
        }
        return axiosRetry.exponentialDelay(retryCount, error);
      }
    });
  }
  return client;
}

exports.createRivalsClient = createRivalsClient;
//# sourceMappingURL=index.cjs.map