index.ts

Filename	Percent	Threshold	Total	Covered	Uncovered
src/requests/index.ts	97.44%	80%	273	266	7

import { API_ROOT, BACKUP_API_ROOT } from 'constants/locations.js';
import axios, { type AxiosInstance, type AxiosRequestConfig } from 'axios';

import { APIError } from '../exceptions/errors.js';
import { Filters } from '../filters/index.js';
import type { Logger } from 'winston';
import { MAX_RETRIES } from 'constants/requests.js';
import { defaultLogger } from 'utils/logger.js';

type Config = {
  apiKey: string;
  logger?: Logger;
};

/**
 * Class for making ElectionTonight API requests.
 */
export class Requests extends Filters {
  api: AxiosInstance;
  logger: Logger;
  constructor({ apiKey, logger }: Config) {
    super();
    /**
     * @TODO - This isn't my favourite way to handle this. Should probably make config passed to client instance for 2024...
     */
    let baseURL = API_ROOT;
    // Custom root
    if (process.env.ELECTION_TONIGHT_CLIENT_API_ROOT) {
      baseURL = process.env.ELECTION_TONIGHT_CLIENT_API_ROOT;
      // Backup API root
    } else if (process.env.ELECTION_TONIGHT_CLIENT_BACKUP_API) {
      baseURL = BACKUP_API_ROOT;
    }
    this.api = axios.create({
      baseURL,
      timeout: 30000,
      headers: { 'x-api-key': apiKey },
      responseType: 'json',
    });
    this.logger = logger || defaultLogger;
  }

  /**
   * Returns response data from an API request. If the request fails, it will retry the request up to `MAX_RETRIES` times.
   *
   * @param path Request path
   * @param opts Request options
   * @param retries Number of retries of this request
   * @return Response data
   */
  async getRequest<ResponseType>(
    path: string,
    opts: AxiosRequestConfig,
    retries: number = 0
  ): Promise<ResponseType> {
    // Throws an error if we've retried this request more than `MAX_RETRIES` times.
    if (retries > MAX_RETRIES) {
      throw new APIError(
        `Max retries exceeded for path: ${path} with opts: ${JSON.stringify(
          opts
        )}`
      );
    }
    try {
      // Makes the request and gets the response data.
      const response = await this.api.get<ResponseType>(path, opts);
      return response.data;
    } catch (error: unknown) {
      if (axios.isAxiosError(error)) {
        if (error.response) {
          const { status } = error.response;
          if (status === 400) {
            throw new APIError(
              `API 400 BAD REQUEST error for path: ${path} with opts: ${JSON.stringify(
                opts
              )}`
            );
          }
          if (status === 403) {
            throw new APIError(
              `API 403 Forbidden error for path: ${path} with opts: ${JSON.stringify(
                opts
              )}`
            );
          }
          if (status === 429) {
            this.logger.warning(
              `API 429 Too Many Requests error for path: ${path}: Backing off and retrying...`
            );
            // This code SLEEPS for a period based on the number of times we've retried this request...
            await new Promise((resolve) =>
              setTimeout(resolve, 2 ** (retries + 1) * 100)
            );
            // ... then it retries the same request.
            return this.getRequest(path, opts, retries + 1);
          }
          if (status >= 400 && status < 500) {
            throw new APIError(
              `API ${status} error for path: ${path} with opts: ${JSON.stringify(
                opts
              )}`
            );
          }
          if (status >= 500) {
            this.logger.warning(
              `API ${status} error for path: ${path}: Backing off and retrying...`
            );
            // Edison recommends retrying 500+ errors
            await new Promise((resolve) =>
              setTimeout(resolve, 2 ** (retries + 1) * 100)
            );
            return this.getRequest(path, opts, retries + 1);
          }

          // Generic status code error
          throw new APIError(
            `API ${status} error for path: ${path} with opts: ${JSON.stringify(
              opts
            )}`
          );
        } else if (error.request) {
          throw new APIError(
            `API request error: No response to request for path: ${path} with opts: ${JSON.stringify(opts)}`
          );
        } else {
          throw new APIError(`API error: ${error.message}`);
        }
      } else {
        throw new APIError(
          `API unspecified error: ${error} for path: ${path} with opts: ${JSON.stringify(opts)}`
        );
      }
    }
  }

  /**
   * Get documents
   *
   * @param path Request path
   * @param opts Request options
   * @return Documents
   */
  async getDocuments<DocumentType>(path: string, opts: AxiosRequestConfig) {
    const data = await this.getRequest<{ Documents: DocumentType[] }>(
      path,
      opts
    );
    const { Documents: documents } = data;
    return documents;
  }

  /**
   * Get paginated documents
   *
   * @param path Request path
   * @param opts Request options
   * @return Documents
   */
  async getPaginatedDocuments<DocumentType>(
    path: string,
    opts: AxiosRequestConfig
  ) {
    opts.params = { ...opts.params, nextPage: 0 };
    let data = await this.getRequest<{
      Documents: DocumentType[];
      NextPage: string;
    }>(path, opts);
    let documents = data.Documents;

    while (data.NextPage) {
      opts.params = { ...opts.params, nextPage: data.NextPage };
      data = await this.getRequest<{
        Documents: DocumentType[];
        NextPage: string;
      }>(path, opts);
      documents = [...documents, ...data.Documents];
    }
    return documents;
  }

  /**
   * Get positioned documents
   */
  async getPositionedDocuments<DocumentType>(
    path: string,
    opts: AxiosRequestConfig,
    maxRequests: number = Infinity
  ) {
    let data = await this.getRequest<{
      Documents: DocumentType[];
      NextPosition: number;
    }>(path, opts);
    let requests = 1;
    let { Documents: allDocuments, NextPosition: position } = data;
    let continueStream = allDocuments.length > 0;
    while (continueStream && requests < maxRequests) {
      opts.params = { ...opts.params, position };
      data = await this.getRequest<{
        Documents: DocumentType[];
        NextPosition: number;
      }>(path, opts);
      requests += 1;
      allDocuments = [...allDocuments, ...data.Documents];
      continueStream = position !== data.NextPosition;
      position = data.NextPosition;
    }
    return {
      documents: allDocuments,
      position,
      maxed: requests >= maxRequests,
    };
  }
}

[{"file":"src/requests/index.ts","line":120,"character":25,"text":"request","kind":1},{"file":"src/requests/index.ts","line":162,"character":9,"text":"params","kind":1},{"file":"src/requests/index.ts","line":162,"character":28,"text":"params","kind":1},{"file":"src/requests/index.ts","line":170,"character":11,"text":"params","kind":1},{"file":"src/requests/index.ts","line":170,"character":30,"text":"params","kind":1},{"file":"src/requests/index.ts","line":196,"character":11,"text":"params","kind":1},{"file":"src/requests/index.ts","line":196,"character":30,"text":"params","kind":1}]

TypeScript coverage report