@tdanks2000/tmdb-wrapper 1.0.0

package/src/@types/types.ts

@@ -0,0 +1,199 @@
+export interface ErrorResponse {
+  status_code: number;
+  status_message: string;
+  success: boolean;
+}
+
+export type MediaType = 'movie' | 'tv' | 'person';
+
+export interface AuthorDetails {
+  name: string;
+  username: string;
+  avatar_path: string;
+  rating?: number;
+}
+
+export type KnownFor = MovieWithMediaType | TVWithMediaType;
+
+export interface Person {
+  id: number;
+  name: string;
+  known_for: KnownFor[];
+  profile_path: string;
+  adult: boolean;
+  known_for_department: string;
+  gender: number;
+  popularity: number;
+}
+
+export interface PersonWithMediaType extends Person {
+  media_type: 'person';
+}
+
+export interface Movie {
+  id: number;
+  poster_path: string;
+  adult: boolean;
+  overview: string;
+  release_date: string;
+  genre_ids: number[];
+  original_title: string;
+  original_language: string;
+  title: string;
+  backdrop_path: string;
+  popularity: number;
+  vote_count: number;
+  video: boolean;
+  vote_average: number;
+}
+
+export interface MovieWithMediaType extends Movie {
+  media_type: 'movie';
+}
+
+export interface Company {
+  id: number;
+  logo_path: string;
+  name: string;
+  origin_country: string;
+}
+
+export interface TV {
+  id: number;
+  name: string;
+  first_air_date: string;
+  backdrop_path: string;
+  genre_ids: number[];
+  origin_country: string[];
+  original_language: string;
+  original_name: string;
+  overview: string;
+  poster_path: string;
+  popularity: number;
+  vote_count: number;
+  vote_average: number;
+}
+
+export interface TVWithMediaType extends TV {
+  media_type: 'tv';
+}
+
+export interface Genre {
+  id: number;
+  name: string;
+}
+
+export interface ExternalIds {
+  imdb_id: string;
+  facebook_id: string;
+  instagram_id: string;
+  twitter_id: string;
+  id: number;
+}
+
+export interface ProductionCompany {
+  id: number;
+  logo_path: string;
+  name: string;
+  origin_country: string;
+}
+
+export interface ProductionCountry {
+  iso_3166_1: string;
+  name: string;
+}
+
+export interface SpokenLanguage {
+  english_name: string;
+  iso_639_1: string;
+  name: string;
+}
+
+export interface ContentRatings {
+  results: ContentRatingsResult[];
+  id: number;
+}
+
+export interface ContentRatingsResult {
+  descriptor: unknown[];
+  iso_3166_1: string;
+  rating: string;
+}
+
+export interface Recommendation {
+  adult: boolean;
+  backdrop_path?: string;
+  genre_ids: number[];
+  id: number;
+  original_language: string;
+  original_title: string;
+  overview: string;
+  release_date: string;
+  poster_path?: string;
+  popularity: number;
+  title: string;
+  video: boolean;
+  vote_average: number;
+  vote_count: number;
+}
+
+export interface Recommendations {
+  page: number;
+  results: Recommendation[];
+  total_pages: number;
+  total_results: number;
+}
+
+export interface Review {
+  author: string;
+  author_details: AuthorDetails;
+  content: string;
+  created_at: Date;
+  id: string;
+  updated_at: Date;
+  url: string;
+}
+
+export interface Reviews {
+  id: number;
+  page: number;
+  results: Review[];
+  total_pages: number;
+  total_results: number;
+}
+
+export interface TranslationData {
+  title: string;
+  overview: string;
+  homepage: string;
+}
+
+export interface Translation {
+  iso_3166_1: string;
+  iso_639_1: string;
+  name: string;
+  english_name: string;
+  data: TranslationData;
+}
+
+export interface Translations {
+  id: number;
+  translations: Translation[];
+}
+
+export interface Image {
+  aspect_ratio: number;
+  file_path: string;
+  height: number;
+  iso_639_1: string;
+  vote_average: number;
+  vote_count: number;
+  width: number;
+}
+
+export interface Images {
+  id: number;
+  backdrops: Image[];
+  logos: Image[];
+  posters: Image[];
+}

package/src/endpoints/account.ts

@@ -0,0 +1,11 @@
+import { AccountDetails, BaseEndpoint } from '@/@types';
+
+export class AccountEndpoint extends BaseEndpoint {
+  constructor(access_token: string) {
+    super(access_token);
+  }
+
+  async details(): Promise<AccountDetails> {
+    return await this.api.get('/account');
+  }
+}

package/src/endpoints/certification.ts

@@ -0,0 +1,15 @@
+import { BaseEndpoint, Certifications } from '@/@types';
+
+export class CertificationEndpoint extends BaseEndpoint {
+  constructor(protected readonly access_token: string) {
+    super(access_token);
+  }
+
+  async movies(): Promise<Certifications> {
+    return await this.api.get<Certifications>('/certification/movie/list');
+  }
+
+  async tv(): Promise<Certifications> {
+    return await this.api.get<Certifications>('/certification/tv/list');
+  }
+}

package/src/endpoints/changes.ts

@@ -0,0 +1,19 @@
+import { BaseEndpoint, ChangeOption, MediaChanges } from '@/@types';
+
+export class ChangeEndpoint extends BaseEndpoint {
+  constructor(protected readonly access_token: string) {
+    super(access_token);
+  }
+
+  async movies(options?: ChangeOption): Promise<MediaChanges> {
+    return await this.api.get<MediaChanges>(`/movie/changes`, options);
+  }
+
+  async tv(options?: ChangeOption): Promise<MediaChanges> {
+    return await this.api.get<MediaChanges>(`/tv/changes`, options);
+  }
+
+  async person(options?: ChangeOption): Promise<MediaChanges> {
+    return await this.api.get<MediaChanges>(`/person/change`, options);
+  }
+}

package/src/endpoints/collections.ts

@@ -0,0 +1,32 @@
+import {
+  BaseEndpoint,
+  CollectionImageOptions,
+  DetailedCollection,
+  ImageCollection,
+  LanguageOption,
+  Translations,
+} from '@/@types';
+
+const BASE_COLLECTION = '/collection';
+
+export class CollectionsEndpoint extends BaseEndpoint {
+  constructor(protected readonly access_token: string) {
+    super(access_token);
+  }
+
+  async details(id: number, options?: LanguageOption): Promise<DetailedCollection> {
+    return await this.api.get<DetailedCollection>(`${BASE_COLLECTION}/${id}`, options);
+  }
+
+  async images(id: number, options?: CollectionImageOptions): Promise<ImageCollection> {
+    const computedOptions = {
+      include_image_language: options?.include_image_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<ImageCollection>(`${BASE_COLLECTION}/${id}/images`, computedOptions);
+  }
+
+  async translations(id: number, options?: LanguageOption): Promise<Translations> {
+    return await this.api.get<Translations>(`${BASE_COLLECTION}/${id}/translations`, options);
+  }
+}

package/src/endpoints/companies.ts

@@ -0,0 +1,19 @@
+import { AlternativeNames, BaseEndpoint, CompanyDetails, CompanyImages } from '@/@types';
+
+export class CompaniesEndpoint extends BaseEndpoint {
+  constructor(protected readonly access_token: string) {
+    super(access_token);
+  }
+
+  async details(id: number): Promise<CompanyDetails> {
+    return await this.api.get<CompanyDetails>(`/company/${id}`);
+  }
+
+  async alternativeNames(id: number): Promise<AlternativeNames> {
+    return await this.api.get<AlternativeNames>(`/company/${id}/alternative_names`);
+  }
+
+  async images(id: number): Promise<CompanyImages> {
+    return await this.api.get<CompanyImages>(`/company/${id}/images`);
+  }
+}

package/src/endpoints/configuration.ts

@@ -0,0 +1,11 @@
+import { BaseEndpoint, Configuration } from '@/@types';
+
+export class ConfigurationEndpoint extends BaseEndpoint {
+  constructor(protected readonly access_token: string) {
+    super(access_token);
+  }
+
+  async getCurrent(): Promise<Configuration> {
+    return await this.api.get<Configuration>(`/configuration`);
+  }
+}

package/src/endpoints/credits.ts

@@ -0,0 +1,11 @@
+import { BaseEndpoint, CreditResponse } from '@/@types';
+
+export class CreditsEndpoint extends BaseEndpoint {
+  constructor(protected readonly access_token: string) {
+    super(access_token);
+  }
+
+  async getById(id: string): Promise<CreditResponse> {
+    return await this.api.get<CreditResponse>(`/credit/${id}`);
+  }
+}

package/src/endpoints/discover.ts

@@ -0,0 +1,73 @@
+import { BaseEndpoint, MovieDiscoverResult, SortOption, TvShowDiscoverResult } from '@/@types';
+
+const BASE_DISCOVER = '/discover';
+
+interface DiscoverQueryOptions {
+  language?: string;
+  sort_by?: SortOption;
+  page?: number;
+  'vote_average.gte'?: number;
+  'vote_count.gte'?: number;
+  'vote_count.lte'?: number;
+  'vote_average.lte'?: number;
+  with_watch_providers?: string;
+  watch_region?: string;
+  without_companies?: string;
+  with_watch_monetization_types?: 'flatrate' | 'free' | 'ads' | 'rent' | 'buy';
+  'with_runtime.gte'?: number;
+  'with_runtime.lte'?: number;
+  with_genres?: string;
+  without_genres?: string;
+  with_original_language?: string;
+  without_keywords?: string;
+  with_keywords?: string;
+  with_companies?: string;
+}
+
+interface MovieQueryOptions extends DiscoverQueryOptions {
+  region?: string;
+  certification_country?: string;
+  certification?: string;
+  'certification.lte'?: string;
+  'certification.gte'?: string;
+  include_adult?: boolean;
+  include_video?: boolean;
+  primary_release_year?: number;
+  'primary_release_date.gte'?: string;
+  'primary_release_date.lte'?: string;
+  'release_date.gte'?: string;
+  'release_date.lte'?: string;
+  with_release_type?: string;
+  year?: number;
+  with_cast?: string;
+  with_crew?: string;
+  with_people?: string;
+}
+
+interface TvShowQueryOptions extends DiscoverQueryOptions {
+  'air_date.gte'?: string;
+  'air_date.lte'?: string;
+  'first_air_date.gte'?: string;
+  'first_air_date.lte'?: string;
+  first_air_date_year?: number;
+  timezone?: string;
+  with_networks?: string;
+  include_null_first_air_dates?: boolean;
+  screened_theatrically?: boolean;
+  with_status?: string;
+  with_type?: string;
+}
+
+export class DiscoverEndpoint extends BaseEndpoint {
+  constructor(access_token: string) {
+    super(access_token);
+  }
+
+  async movie(options?: MovieQueryOptions): Promise<MovieDiscoverResult> {
+    return await this.api.get<MovieDiscoverResult>(`${BASE_DISCOVER}/movie`, options);
+  }
+
+  async tvShow(options?: TvShowQueryOptions): Promise<TvShowDiscoverResult> {
+    return await this.api.get<TvShowDiscoverResult>(`${BASE_DISCOVER}/tv`, options);
+  }
+}

package/src/endpoints/find.ts

@@ -0,0 +1,11 @@
+import { BaseEndpoint, ExternalIdOptions, FindResult } from '@/@types';
+
+export class FindEndpoint extends BaseEndpoint {
+  constructor(access_token: string) {
+    super(access_token);
+  }
+
+  async byId(externalId: string, options: ExternalIdOptions): Promise<FindResult> {
+    return await this.api.get<FindResult>(`/find/${externalId}`, options);
+  }
+}

package/src/endpoints/genre.ts

@@ -0,0 +1,19 @@
+import { BaseEndpoint, LanguageOption } from '@/@types';
+
+export interface Genres {
+  genres: Array<{ id: number; name: string }>;
+}
+
+export class GenreEndpoint extends BaseEndpoint {
+  constructor(protected readonly access_token: string) {
+    super(access_token);
+  }
+
+  async movies(options?: LanguageOption): Promise<Genres> {
+    return await this.api.get<Genres>('/genre/movie/list', options);
+  }
+
+  async tv(options?: LanguageOption): Promise<Genres> {
+    return await this.api.get<Genres>('/genre/tv/list', options);
+  }
+}

package/src/endpoints/index.ts

@@ -0,0 +1,18 @@
+export * from './account';
+export * from './certification';
+export * from './changes';
+export * from './collections';
+export * from './configuration';
+export * from './credits';
+export * from './discover';
+export * from './find';
+export * from './genre';
+export * from './keywords';
+export * from './movies';
+export * from './people';
+export * from './review';
+export * from './search';
+export * from './trending';
+export * from './tvEpisodes';
+export * from './tvSeasons';
+export * from './tvShows';

package/src/endpoints/keywords.ts

@@ -0,0 +1,17 @@
+import { BaseEndpoint, BelongingMovies, Keyword, KeywordsOptions } from '@/@types';
+
+const BASE_Keyword = '/keyword';
+
+export class KeywordsEndpoint extends BaseEndpoint {
+  constructor(access_token: string) {
+    super(access_token);
+  }
+
+  async details(keywordId: number): Promise<Keyword> {
+    return await this.api.get<Keyword>(`${BASE_Keyword}/${keywordId}`);
+  }
+
+  async belongingMovies(keywordId: number, options?: KeywordsOptions): Promise<BelongingMovies> {
+    return await this.api.get<BelongingMovies>(`${BASE_Keyword}/${keywordId}/movies`, options);
+  }
+}

package/src/endpoints/movies.ts

@@ -0,0 +1,138 @@
+import {
+  AlternativeTitles,
+  AppendToResponse,
+  AppendToResponseMovieKey,
+  BaseEndpoint,
+  ChangeOption,
+  Changes,
+  Credits,
+  ExternalIds,
+  Images,
+  Keywords,
+  LanguageOption,
+  LatestMovie,
+  MovieChangeValue,
+  MovieDetails,
+  MovieLists,
+  MoviesPlayingNow,
+  PageOption,
+  PopularMovies,
+  Recommendations,
+  RegionOption,
+  ReleaseDates,
+  Reviews,
+  SimilarMovies,
+  TopRatedMovies,
+  Translations,
+  UpcomingMovies,
+  Videos,
+  WatchProviders,
+} from '@/@types';
+
+const BASE_MOVIE = '/movie';
+
+export interface MoviesImageSearchOptions extends LanguageOption {
+  /**
+   * a list of ISO-639-1 values to query
+   */
+  include_image_language?: string[];
+}
+
+export class MoviesEndpoint extends BaseEndpoint {
+  constructor(protected readonly access_token: string) {
+    super(access_token);
+  }
+
+  async details<T extends AppendToResponseMovieKey[] | undefined>(id: number, appendToResponse?: T, language?: string) {
+    const options = {
+      append_to_response: appendToResponse ? appendToResponse.join(',') : undefined,
+      language: language,
+    };
+
+    return await this.api.get<AppendToResponse<MovieDetails, T, 'movie'>>(`${BASE_MOVIE}/${id}`, options);
+  }
+
+  async alternativeTitles(id: number): Promise<AlternativeTitles> {
+    return await this.api.get<AlternativeTitles>(`${BASE_MOVIE}/${id}/alternative_titles`);
+  }
+
+  async changes(id: number, options?: ChangeOption): Promise<Changes<MovieChangeValue>> {
+    return await this.api.get<Changes<MovieChangeValue>>(`${BASE_MOVIE}/${id}/changes`, options);
+  }
+
+  async credits(id: number, options?: LanguageOption): Promise<Credits> {
+    return await this.api.get<Credits>(`${BASE_MOVIE}/${id}/credits`, options);
+  }
+
+  async externalIds(id: number): Promise<ExternalIds> {
+    return await this.api.get<ExternalIds>(`${BASE_MOVIE}/${id}/external_ids`);
+  }
+
+  async images(id: number, options?: MoviesImageSearchOptions): Promise<Images> {
+    const computedOptions = {
+      include_image_language: options?.include_image_language?.join(','),
+      language: options?.language,
+    };
+    return await this.api.get<Images>(`${BASE_MOVIE}/${id}/images`, computedOptions);
+  }
+
+  async keywords(id: number): Promise<Keywords> {
+    return await this.api.get<Keywords>(`${BASE_MOVIE}/${id}/keywords`);
+  }
+
+  async lists(id: number, options?: LanguageOption & PageOption): Promise<MovieLists> {
+    return await this.api.get<MovieLists>(`${BASE_MOVIE}/${id}/lists`, options);
+  }
+
+  async recommendations(id: number, options?: LanguageOption & PageOption): Promise<Recommendations> {
+    return await this.api.get<Recommendations>(`${BASE_MOVIE}/${id}/recommendations`, options);
+  }
+
+  async releaseDates(id: number): Promise<ReleaseDates> {
+    return await this.api.get<ReleaseDates>(`${BASE_MOVIE}/${id}/release_dates`);
+  }
+
+  async reviews(id: number, options?: LanguageOption & PageOption): Promise<Reviews> {
+    return await this.api.get<Reviews>(`${BASE_MOVIE}/${id}/reviews`, options);
+  }
+
+  async similar(id: number, options?: LanguageOption & PageOption): Promise<SimilarMovies> {
+    return await this.api.get<SimilarMovies>(`${BASE_MOVIE}/${id}/similar`, options);
+  }
+
+  async translations(id: number): Promise<Translations> {
+    return await this.api.get<Translations>(`${BASE_MOVIE}/${id}/translations`);
+  }
+
+  async videos(id: number, options?: LanguageOption): Promise<Videos> {
+    return await this.api.get<Videos>(`${BASE_MOVIE}/${id}/videos`, options);
+  }
+
+  /**
+   * Powered by JustWatch
+   * @param id
+   */
+  async watchProviders(id: number): Promise<WatchProviders> {
+    return await this.api.get<WatchProviders>(`${BASE_MOVIE}/${id}/watch/providers`);
+  }
+
+  async latest(): Promise<LatestMovie> {
+    return await this.api.get<LatestMovie>(`${BASE_MOVIE}/latest`);
+  }
+
+  async nowPlaying(options?: PageOption & LanguageOption & RegionOption): Promise<MoviesPlayingNow> {
+    return await this.api.get<MoviesPlayingNow>(`${BASE_MOVIE}/now_playing`, options);
+  }
+
+  async popular(options?: LanguageOption & PageOption): Promise<PopularMovies> {
+    return await this.api.get<PopularMovies>(`${BASE_MOVIE}/popular`, options);
+  }
+
+  async topRated(options?: PageOption & LanguageOption & RegionOption): Promise<TopRatedMovies> {
+    return await this.api.get<TopRatedMovies>(`${BASE_MOVIE}/top_rated`, options);
+  }
+
+  async upcoming(options?: PageOption & LanguageOption & RegionOption): Promise<UpcomingMovies> {
+    return await this.api.get<UpcomingMovies>(`${BASE_MOVIE}/upcoming`, options);
+  }
+}

package/src/endpoints/networks.ts

@@ -0,0 +1,19 @@
+import { AlternativeNames, BaseEndpoint, NetworkDetails, NetworkImages } from '@/@types';
+
+export class NetworksEndpoint extends BaseEndpoint {
+  constructor(protected readonly access_token: string) {
+    super(access_token);
+  }
+
+  async details(id: number): Promise<NetworkDetails> {
+    return await this.api.get<NetworkDetails>(`/network/${id}`);
+  }
+
+  async alternativeNames(id: number): Promise<AlternativeNames> {
+    return await this.api.get<AlternativeNames>(`/network/${id}/alternative_names`);
+  }
+
+  async images(id: number): Promise<NetworkImages> {
+    return await this.api.get<NetworkImages>(`/network/${id}/images`);
+  }
+}