@tutkli/jikan-ts 0.5.2 → 0.5.4

package/src/__tests__/manga-client.spec.ts

@@ -1,33 +0,0 @@
-import { MangaClient } from '../clients';
-import { MangaSearchParams } from '../models/Params';
-import { JikanResponse, JikanUniqueResponse, Manga } from '../models';
-
-describe('test Manga Client', () => {
-  let client: MangaClient;
-  beforeAll(() => {
-    client = new MangaClient();
-  });
-  beforeEach(async () => {
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-  });
-
-  it('should get mangas filtered by params', async () => {
-    const params: MangaSearchParams = { limit: 3, score: 9 };
-    const data = await client.getMangaSearch(params).then((response: JikanResponse<Manga>) => response.data);
-
-    expect(data).toHaveLength(3);
-    for (const anime of data) {
-      expect(anime.score).toBeGreaterThanOrEqual(9);
-    }
-  });
-
-  it('should get a full manga by its ID', async () => {
-    const data = await client.getMangaFullById(1).then((response: JikanUniqueResponse<Manga>) => response.data);
-    expect(data.mal_id).toBe(1);
-  });
-
-  it('should get an manga by its ID', async () => {
-    const data = await client.getMangaById(1).then((response: JikanUniqueResponse<Manga>) => response.data);
-    expect(data.mal_id).toBe(1);
-  });
-});

package/src/__tests__/top-client.spec.ts

@@ -1,33 +0,0 @@
-import { AnimeTopParams, MangaTopParams, TopAnimeFilter, TopMangaFilter } from '../models/Params';
-import { Anime, AnimeStatus, JikanResponse, Manga, MangaStatus } from '../models';
-import { TopClient } from '../clients/top.client';
-
-describe('test Top Client', () => {
-  let client: TopClient;
-  beforeAll(() => {
-    client = new TopClient();
-  });
-  beforeEach(async () => {
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-  });
-
-  it('should get top animes filtered by params', async () => {
-    const params: AnimeTopParams = { limit: 3, filter: TopAnimeFilter.airing };
-    const data = await client.getTopAnime(params).then((response: JikanResponse<Anime>) => response.data);
-
-    expect(data).toHaveLength(3);
-    for (const anime of data) {
-      expect(anime.status).toBe(AnimeStatus.airing);
-    }
-  });
-
-  it('should get top mangas filtered by params', async () => {
-    const params: MangaTopParams = { limit: 3, filter: TopMangaFilter.publishing };
-    const data = await client.getTopManga(params).then((response: JikanResponse<Manga>) => response.data);
-
-    expect(data).toHaveLength(3);
-    for (const manga of data) {
-      expect(manga.status).toBe(MangaStatus.publishing);
-    }
-  });
-});

package/src/clients/anime.client.ts

@@ -1,233 +0,0 @@
-import { BaseClient, ClientArgs } from './base.client';
-import { AnimeEndpoints } from '../constants';
-import { CacheAxiosResponse } from 'axios-cache-interceptor';
-import { AxiosError } from 'axios';
-import {
-  Anime,
-  AnimeCharacter,
-  AnimeEpisode,
-  AnimePicture,
-  AnimeStaff,
-  AnimeStatistics,
-  AnimeVideo,
-  AnimeVideoEpisode,
-  JikanResponse,
-  JikanUniqueResponse,
-  Recommendation,
-} from '../models';
-import { AnimeSearchParams } from '../models/Params';
-
-/**
- * **Anime Client**
- *
- * Client used to access the Anime Endpoints:
- * - [AnimeSearch](https://docs.api.jikan.moe/#tag/anime)
- * - [AnimeFullById](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeFullById)
- * - [AnimeById](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeById)
- * - [AnimeCharacters](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeCharacters)
- * - [AnimeStaff](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeStaff)
- * - [AnimeEpisodes](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeEpisodes)
- * - [AnimeEpisodeById](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeEpisodeById)
- * - [AnimeVideos](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeVideos)
- * - [AnimeVideosEpisodes](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeVideosEpisodes)
- * - [AnimePictures](https://docs.api.jikan.moe/#tag/anime/operation/getAnimePictures)
- * - [AnimeStatistics](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeStatistics)
- * - [AnimeRecommendations](https://docs.api.jikan.moe/#tag/anime/operation/getAnimeRecommendations)
- *
- * See also: [JikanAPI](https://docs.api.jikan.moe/)
- */
-export class AnimeClient extends BaseClient {
-  /**
-   * @argument clientOptions Options for the client.
-   */
-  constructor(clientOptions?: ClientArgs) {
-    super(clientOptions);
-  }
-
-  /**
-   * Get all the filtered Animes. Returns all the Animes if no filters are given.
-   * @param searchParams Filter parameters
-   * @returns A JikanResponse with Anime data
-   */
-  public async getAnimeSearch(searchParams?: AnimeSearchParams): Promise<JikanResponse<Anime>> {
-    return new Promise<JikanResponse<Anime>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeSearch}`;
-      this.api
-        .get<JikanResponse<Anime>>(endpoint, { params: searchParams })
-        .then((response: CacheAxiosResponse<JikanResponse<Anime>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get a complete Anime resource data
-   * @param mal_id The Anime ID
-   * @returns A JikanUniqueResponse with Anime data
-   */
-  public async getAnimeFullById(mal_id: number): Promise<JikanUniqueResponse<Anime>> {
-    return new Promise<JikanUniqueResponse<Anime>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeFullById.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanUniqueResponse<Anime>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanUniqueResponse<Anime>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Anime resource data
-   * @param mal_id The Anime ID
-   * @returns A JikanUniqueResponse with Anime data
-   */
-  public async getAnimeById(mal_id: number): Promise<JikanUniqueResponse<Anime>> {
-    return new Promise<JikanUniqueResponse<Anime>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeById.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanUniqueResponse<Anime>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanUniqueResponse<Anime>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Characters of a specific Anime
-   * @param mal_id The Anime ID
-   * @returns A JikanResponse with AnimeCharacter data
-   */
-  public async getAnimeCharacters(mal_id: number): Promise<JikanResponse<AnimeCharacter>> {
-    return new Promise<JikanResponse<AnimeCharacter>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeCharacters.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanResponse<AnimeCharacter>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanResponse<AnimeCharacter>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Staff of a specific Anime
-   * @param mal_id The Anime ID
-   * @returns A JikanResponse with AnimeStaff data
-   */
-  public async getAnimeStaff(mal_id: number): Promise<JikanResponse<AnimeStaff>> {
-    return new Promise<JikanResponse<AnimeStaff>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeStaff.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanResponse<AnimeStaff>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanResponse<AnimeStaff>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get a list of all the episodes of a specific Anime
-   * @param mal_id The Anime ID
-   * @returns A JikanResponse with AnimeEpisode data
-   */
-  public async getAnimeEpisodes(mal_id: number): Promise<JikanResponse<AnimeEpisode>> {
-    return new Promise<JikanResponse<AnimeEpisode>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeEpisodes.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanResponse<AnimeEpisode>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanResponse<AnimeEpisode>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get a single Episode of a specific Anime by its ID
-   * @param anime_mal_id The Anime ID
-   * @param episode_mal_id The Episode ID
-   * @returns A JikanUniqueResponse with AnimeEpisode data
-   */
-  public async getAnimeEpisodeById(
-    anime_mal_id: number,
-    episode_mal_id: number
-  ): Promise<JikanUniqueResponse<AnimeEpisode>> {
-    return new Promise<JikanUniqueResponse<AnimeEpisode>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeEpisodeById.replace('{id}', String(anime_mal_id)).replace(
-        '{episode}',
-        String(episode_mal_id)
-      )}`;
-      this.api
-        .get<JikanUniqueResponse<AnimeEpisode>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanUniqueResponse<AnimeEpisode>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Videos related to a specific Anime
-   * @param mal_id The Anime ID
-   * @returns A JikanUniqueResponse with AnimeVideo data
-   */
-  public async getAnimeVideos(mal_id: number): Promise<JikanUniqueResponse<AnimeVideo>> {
-    return new Promise<JikanUniqueResponse<AnimeVideo>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeVideos.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanUniqueResponse<AnimeVideo>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanUniqueResponse<AnimeVideo>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Episode Videos related to a specific Anime
-   * @param mal_id The Anime ID
-   * @returns A JikanResponse with AnimeVideoEpisode data
-   */
-  public async getAnimeVideosEpisode(mal_id: number): Promise<JikanResponse<AnimeVideoEpisode>> {
-    return new Promise<JikanResponse<AnimeVideoEpisode>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeVideosEpisodes.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanResponse<AnimeVideoEpisode>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanResponse<AnimeVideoEpisode>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Pictures related to a specific Anime
-   * @param mal_id The Anime ID
-   * @returns A JikanResponse with AnimePicture data
-   */
-  public async getAnimePictures(mal_id: number): Promise<JikanResponse<AnimePicture>> {
-    return new Promise<JikanResponse<AnimePicture>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimePictures.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanResponse<AnimePicture>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanResponse<AnimePicture>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Statistics related to a specific Anime
-   * @param mal_id The Anime ID
-   * @returns A JikanUniqueResponse with AnimeStatistics data
-   */
-  public async getAnimeStatistics(mal_id: number): Promise<JikanUniqueResponse<AnimeStatistics>> {
-    return new Promise<JikanUniqueResponse<AnimeStatistics>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeStatistics.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanUniqueResponse<AnimeStatistics>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanUniqueResponse<AnimeStatistics>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Recommendations related to a specific Anime
-   * @param mal_id The Anime ID
-   * @returns A JikanResponse with Recommendation data
-   */
-  public async getAnimeRecommendation(mal_id: number): Promise<JikanResponse<Recommendation>> {
-    return new Promise<JikanResponse<Recommendation>>((resolve, reject) => {
-      const endpoint = `${AnimeEndpoints.AnimeRecommendations.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanResponse<Recommendation>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanResponse<Recommendation>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-}

package/src/clients/base.client.ts

@@ -1,82 +0,0 @@
-import { Logger, LoggerOptions } from 'pino';
-import {
-  AxiosCacheInstance,
-  CacheAxiosResponse,
-  CacheOptions,
-  CacheRequestConfig,
-  setupCache,
-} from 'axios-cache-interceptor';
-import axios, { AxiosError } from 'axios';
-import { BaseURL } from '../constants';
-import {
-  createLogger,
-  DEFAULT_CACHE_OPTIONS,
-  handleRequest,
-  handleRequestError,
-  handleResponse,
-  handleResponseError,
-} from '../config';
-
-/**
- * **Client Args**
- * Used to pass optional configuration for logging and cache to the clients.
- */
-export interface ClientArgs {
-  /**
-   * **Logger Options**
-   * Options for the client logger.
-   * @see https://getpino.io/#/docs/api?id=options
-   */
-  logOptions?: LoggerOptions;
-  /**
-   * **Axios Cache Options**
-   * Options for cache.
-   * @see https://axios-cache-interceptor.js.org/#/pages/configuration
-   */
-  cacheOptions?: CacheOptions;
-  /**
-   * **Base URL**
-   * Location of the JikanAPI. Leave empty to use the official JikanAPI instance.
-   */
-  baseURL?: string;
-}
-
-/**
- * **Base Client** This client is responsible for creating an Axios Instance and the cache and logging configurations
- */
-export abstract class BaseClient {
-  public api: AxiosCacheInstance;
-  public logger: Logger;
-
-  constructor(clientOptions?: ClientArgs) {
-    this.api = setupCache(
-      axios.create({
-        baseURL: clientOptions?.baseURL ?? BaseURL.REST,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      }),
-      {
-        storage: clientOptions?.cacheOptions?.storage ?? DEFAULT_CACHE_OPTIONS.storage,
-        generateKey: clientOptions?.cacheOptions?.generateKey ?? DEFAULT_CACHE_OPTIONS.generateKey,
-        headerInterpreter: clientOptions?.cacheOptions?.headerInterpreter ?? DEFAULT_CACHE_OPTIONS.headerInterpreter,
-        debug: clientOptions?.cacheOptions?.debug ?? DEFAULT_CACHE_OPTIONS.debug,
-      }
-    );
-
-    this.logger = createLogger({
-      enabled: !(clientOptions?.logOptions?.enabled === undefined || clientOptions?.logOptions.enabled === false),
-      ...clientOptions?.logOptions,
-    });
-
-    this.api.interceptors.request.use(
-      (config: CacheRequestConfig) => handleRequest(config, this.logger),
-      (error: AxiosError<string>) => handleRequestError(error, this.logger)
-    );
-
-    this.api.interceptors.response.use(
-      (response: CacheAxiosResponse) => handleResponse(response, this.logger),
-      (error: AxiosError<string>) => handleResponseError(error, this.logger)
-    );
-  }
-}

package/src/clients/index.ts

@@ -1,4 +0,0 @@
-export * from './base.client';
-export * from './anime.client';
-export * from './manga.client';
-export * from './jikan.client';

package/src/clients/jikan.client.ts

@@ -1,28 +0,0 @@
-import { BaseClient, ClientArgs } from './base.client';
-import { AnimeClient } from './anime.client';
-import { MangaClient } from './manga.client';
-import { TopClient } from './top.client';
-
-/**
- * **Jikan Client**
- *
- * The main client used to access all the JikanAPI Endpoints:
- * - [Anime](https://docs.api.jikan.moe/#tag/anime)
- * - [Manga](https://docs.api.jikan.moe/#tag/manga)
- * - [Top](https://docs.api.jikan.moe/#tag/top)
- *
- * See also: [JikanAPI Documentation](https://docs.api.jikan.moe/)
- */
-export class JikanClient extends BaseClient {
-  public anime: AnimeClient;
-  public manga: MangaClient;
-  public top: TopClient;
-
-  constructor(clientOptions?: ClientArgs) {
-    super(clientOptions);
-
-    this.anime = new AnimeClient(clientOptions);
-    this.manga = new MangaClient(clientOptions);
-    this.top = new TopClient(clientOptions);
-  }
-}

package/src/clients/manga.client.ts

@@ -1,142 +0,0 @@
-import { BaseClient, ClientArgs } from './base.client';
-import { MangaEndpoints } from '../constants';
-import { CacheAxiosResponse } from 'axios-cache-interceptor';
-import { AxiosError } from 'axios';
-import {
-  CommonCharacter,
-  JikanImages,
-  JikanResponse,
-  JikanUniqueResponse,
-  Manga,
-  MangaStatistics,
-  Recommendation,
-} from '../models';
-import { MangaSearchParams } from '../models/Params';
-
-/**
- * **Manga Client**
- *
- * Client used to access the Manga Endpoints:
- * - [MangaSearch](https://docs.api.jikan.moe/#tag/manga)
- * - [MangaFullById](https://docs.api.jikan.moe/#tag/manga/operation/getMangaFullById)
- * - [MangaById](https://docs.api.jikan.moe/#tag/manga/operation/getMangaById)
- * - [MangaCharacters](https://docs.api.jikan.moe/#tag/manga/operation/getMangaCharacters)
- * - [MangaPictures](https://docs.api.jikan.moe/#tag/manga/operation/getMangaPictures)
- * - [MangaStatistics](https://docs.api.jikan.moe/#tag/manga/operation/getMangaStatistics)
- * - [MangaRecommendations](https://docs.api.jikan.moe/#tag/manga/operation/getMangaRecommendations)
- *
- * See also: [JikanAPI Documentation](https://docs.api.jikan.moe/)
- */
-export class MangaClient extends BaseClient {
-  /**
-   * @argument clientOptions Options for the client.
-   */
-  constructor(clientOptions?: ClientArgs) {
-    super(clientOptions);
-  }
-
-  /**
-   * Get all the filtered Mangas. Returns all the Mangas if no filters are given.
-   * @param searchParams Filter parameters
-   * @returns A JikanResponse with Manga data
-   */
-  public async getMangaSearch(searchParams: MangaSearchParams): Promise<JikanResponse<Manga>> {
-    return new Promise<JikanResponse<Manga>>((resolve, reject) => {
-      const endpoint = `${MangaEndpoints.MangaSearch}`;
-      this.api
-        .get<JikanResponse<Manga>>(endpoint, { params: searchParams })
-        .then((response: CacheAxiosResponse<JikanResponse<Manga>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get a Manga with full information by its ID
-   * @param mal_id The Manga ID
-   * @returns A JikanUniqueResponse with Manga data
-   */
-  public async getMangaFullById(mal_id: number): Promise<JikanUniqueResponse<Manga>> {
-    return new Promise<JikanUniqueResponse<Manga>>((resolve, reject) => {
-      const endpoint = `${MangaEndpoints.MangaFullById.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanUniqueResponse<Manga>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanUniqueResponse<Manga>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get a Manga by its ID
-   * @param mal_id The Manga ID
-   * @returns A JikanUniqueResponse with Manga data
-   */
-  public async getMangaById(mal_id: number): Promise<JikanUniqueResponse<Manga>> {
-    return new Promise<JikanUniqueResponse<Manga>>((resolve, reject) => {
-      const endpoint = `${MangaEndpoints.MangaById.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanUniqueResponse<Manga>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanUniqueResponse<Manga>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Characters of a specific Manga
-   * @param mal_id The Manga ID
-   * @returns A JikanResponse with CommonCharacter data
-   */
-  public async getMangaCharacters(mal_id: number): Promise<JikanResponse<CommonCharacter>> {
-    return new Promise<JikanResponse<CommonCharacter>>((resolve, reject) => {
-      const endpoint = `${MangaEndpoints.MangaCharacters.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanResponse<CommonCharacter>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanResponse<CommonCharacter>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Pictures related to a specific Manga
-   * @param mal_id The Manga ID
-   * @returns A JikanResponse with JikanImages data
-   */
-  public async getMangaPictures(mal_id: number): Promise<JikanResponse<JikanImages>> {
-    return new Promise<JikanResponse<JikanImages>>((resolve, reject) => {
-      const endpoint = `${MangaEndpoints.MangaPictures.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanResponse<JikanImages>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanResponse<JikanImages>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Statistics related to a specific Manga
-   * @param mal_id The Manga ID
-   * @returns A JikanUniqueResponse with MangaStatistics data
-   */
-  public async getAnimeStatistics(mal_id: number): Promise<JikanUniqueResponse<MangaStatistics>> {
-    return new Promise<JikanUniqueResponse<MangaStatistics>>((resolve, reject) => {
-      const endpoint = `${MangaEndpoints.MangaStatistics.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanUniqueResponse<MangaStatistics>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanUniqueResponse<MangaStatistics>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get Recommendations related to a specific Manga
-   * @param mal_id The Manga ID
-   * @returns A JikanResponse with Recommendation data
-   */
-  public async getMangaRecommendation(mal_id: number): Promise<JikanResponse<Recommendation>> {
-    return new Promise<JikanResponse<Recommendation>>((resolve, reject) => {
-      const endpoint = `${MangaEndpoints.MangaRecommendations.replace('{id}', String(mal_id))}`;
-      this.api
-        .get<JikanResponse<Recommendation>>(endpoint)
-        .then((response: CacheAxiosResponse<JikanResponse<Recommendation>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-}

package/src/clients/top.client.ts

@@ -1,52 +0,0 @@
-import { BaseClient, ClientArgs } from './base.client';
-import { Anime, JikanResponse, Manga } from '../models';
-import { TopEndpoints } from '../constants';
-import { CacheAxiosResponse } from 'axios-cache-interceptor';
-import { AxiosError } from 'axios';
-import { AnimeTopParams, MangaTopParams } from '../models/Params';
-
-/**
- * **Anime Client**
- *
- * Client used to access the Top Endpoints:
- * - [TopAnime](https://docs.api.jikan.moe/#tag/top/operation/getTopAnime)
- * - [TopManga](https://docs.api.jikan.moe/#tag/top/operation/getTopManga)
- *
- * See also: [JikanAPI Documentation](https://docs.api.jikan.moe/)
- */
-export class TopClient extends BaseClient {
-  /**
-   * @argument clientOptions Options for the client.
-   */
-  constructor(clientOptions?: ClientArgs) {
-    super(clientOptions);
-  }
-
-  /**
-   * Get the top Animes
-   * @returns A JikanResponse with Anime data
-   */
-  public async getTopAnime(searchParams: AnimeTopParams): Promise<JikanResponse<Anime>> {
-    return new Promise<JikanResponse<Anime>>((resolve, reject) => {
-      const endpoint = `${TopEndpoints.TopAnime}`;
-      this.api
-        .get<JikanResponse<Anime>>(endpoint, { params: searchParams })
-        .then((response: CacheAxiosResponse<JikanResponse<Anime>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-
-  /**
-   * Get the top Mangas
-   * @returns A JikanResponse with Manga data
-   */
-  public async getTopManga(searchParams: MangaTopParams): Promise<JikanResponse<Manga>> {
-    return new Promise<JikanResponse<Manga>>((resolve, reject) => {
-      const endpoint = `${TopEndpoints.TopManga}`;
-      this.api
-        .get<JikanResponse<Manga>>(endpoint, { params: searchParams })
-        .then((response: CacheAxiosResponse<JikanResponse<Manga>>) => resolve(response.data))
-        .catch((error: AxiosError<string>) => reject(error));
-    });
-  }
-}

package/src/config/cache.config.ts

@@ -1,8 +0,0 @@
-import { buildMemoryStorage, defaultHeaderInterpreter, defaultKeyGenerator } from 'axios-cache-interceptor';
-
-export const DEFAULT_CACHE_OPTIONS = {
-  storage: buildMemoryStorage(),
-  generateKey: defaultKeyGenerator,
-  headerInterpreter: defaultHeaderInterpreter,
-  debug: undefined,
-};

package/src/config/index.ts

@@ -1,2 +0,0 @@
-export * from './cache.config';
-export * from './logger.config';

package/src/config/logger.config.ts

@@ -1,25 +0,0 @@
-import pino, { DestinationStream, Logger, LoggerOptions } from 'pino';
-import { AxiosError } from 'axios';
-import { CacheAxiosResponse, CacheRequestConfig } from 'axios-cache-interceptor';
-
-export const createLogger = (options: LoggerOptions | DestinationStream): Logger => pino(options);
-
-export const handleRequest = (config: CacheRequestConfig, logger: Logger): CacheRequestConfig => {
-  logger.info(`[ Request Config ] ${config.method?.toUpperCase() || ''} | ${config.url || ''}`);
-  return config;
-};
-
-export const handleRequestError = (error: AxiosError, logger: Logger): Promise<AxiosError> => {
-  logger.error(`[ Request Error] CODE ${error.code || 'UNKNOWN'} | ${error.message}`);
-  throw error;
-};
-
-export const handleResponse = (response: CacheAxiosResponse, logger: Logger): CacheAxiosResponse => {
-  logger.info(response.data);
-  return response;
-};
-
-export const handleResponseError = (error: AxiosError, logger: Logger): Promise<AxiosError> => {
-  logger.error(`[ Response Error ] CODE ${error.code || 'UNKNOWN'} | ${error.message}`);
-  throw error;
-};

package/src/constants/base.constant.ts

@@ -1,3 +0,0 @@
-export enum BaseURL {
-  REST = 'https://api.jikan.moe/v4',
-}