@lorenzopant/tmdb 0.0.2 → 0.0.4

package/dist/endpoints/movie_lists.d.ts

@@ -1,15 +1,21 @@
 import { ApiClient } from "../client";
 import { MovieResultItem } from "../types/movies";
-import { PaginatedResponse } from "../types/params";
+import { MovieListParams, PaginatedResponse } from "../types/params";
+import { TMDBOptions } from "../tmdb";
+export declare enum MovieListEndpoints {
+    NOW_PLAYING = "/now_playing",
+    POPULAR = "/popular",
+    TOP_RATED = "/top_rated",
+    UPCOMING = "/upcoming"
+}
 export declare class MovieListsAPI {
     private client;
-    constructor(client: ApiClient);
+    private defaultOptions;
+    constructor(client: ApiClient, defaultOptions?: TMDBOptions);
     /**
      * Fetch Movie List Wrapper
      * @param endpoint Endpoint to call
-     * @param language Language (Defaults to en-US)
-     * @param page Page (Defaults to 1)
-     * @param region ISO-3166-1 code
+     * @param params Params for the request (language, page, region, etc)
      * @returns Specific to endpoint (MovieListResult)
      */
     private fetch_movie_list;
@@ -18,39 +24,39 @@ export declare class MovieListsAPI {
      * GET - https://api.themoviedb.org/3/movie/now_playing
      *
      * Get a list of movies that are currently in theatres.
-     * @param language Language (Defaults to en-US)
+     * @param language Language (Defaults to en-US or TMDB default)
      * @param page Page (Defaults to 1)
      * @param region ISO-3166-1 code
      */
-    now_playing(language?: string, page?: number, region?: string): Promise<PaginatedResponse<MovieResultItem>>;
+    now_playing(params?: MovieListParams): Promise<PaginatedResponse<MovieResultItem>>;
     /**
      * Popular
      * GET - https://api.themoviedb.org/3/movie/popular
      *
      * Get a list of movies ordered by popularity.
-     * @param language Language (Defaults to en-US)
+     * @param language Language (Defaults to en-US or TMDB default)
      * @param page Page (Defaults to 1)
      * @param region ISO-3166-1 code
      */
-    popular(language?: string, page?: number, region?: string): Promise<PaginatedResponse<MovieResultItem>>;
+    popular(params?: MovieListParams): Promise<PaginatedResponse<MovieResultItem>>;
     /**
      * Top Rated
      * GET - https://api.themoviedb.org/3/movie/top_rated
      *
      * Get a list of movies ordered by rating.
-     * @param language Language (Defaults to en-US)
+     * @param language Language (Defaults to en-US or TMDB default)
      * @param page Page (Defaults to 1)
      * @param region ISO-3166-1 code
      */
-    top_rated(language?: string, page?: number, region?: string): Promise<PaginatedResponse<MovieResultItem>>;
+    top_rated(params?: MovieListParams): Promise<PaginatedResponse<MovieResultItem>>;
     /**
      * Upcoming
      * GET - https://api.themoviedb.org/3/movie/upcoming
      *
      * Get a list of movies that are being released soon.
-     * @param language Language (Defaults to en-US)
+     * @param language Language (Defaults to en-US or TMDB default)
      * @param page Page (Defaults to 1)
      * @param region ISO-3166-1 code
      */
-    upcoming(language?: string, page?: number, region?: string): Promise<PaginatedResponse<MovieResultItem>>;
+    upcoming(params?: MovieListParams): Promise<PaginatedResponse<MovieResultItem>>;
 }

package/dist/endpoints/movie_lists.js

@@ -1,73 +1,74 @@
 import { MOVIE_ENDPOINTS } from "./movies";
-const MOVIE_LISTS_ENDPOINTS = {
-    NOW_PLAYING: "/now_playing",
-    POPULAR: "/popular",
-    TOP_RATED: "/top_rated",
-    UPCOMING: "/upcoming",
-};
+export var MovieListEndpoints;
+(function (MovieListEndpoints) {
+    MovieListEndpoints["NOW_PLAYING"] = "/now_playing";
+    MovieListEndpoints["POPULAR"] = "/popular";
+    MovieListEndpoints["TOP_RATED"] = "/top_rated";
+    MovieListEndpoints["UPCOMING"] = "/upcoming";
+})(MovieListEndpoints || (MovieListEndpoints = {}));
 export class MovieListsAPI {
     client;
-    constructor(client) {
+    defaultOptions;
+    constructor(client, defaultOptions = {}) {
         this.client = client;
+        this.defaultOptions = defaultOptions;
     }
     /**
      * Fetch Movie List Wrapper
      * @param endpoint Endpoint to call
-     * @param language Language (Defaults to en-US)
-     * @param page Page (Defaults to 1)
-     * @param region ISO-3166-1 code
+     * @param params Params for the request (language, page, region, etc)
      * @returns Specific to endpoint (MovieListResult)
      */
-    fetch_movie_list(endpoint, language, page, region) {
-        const params = { page, language, region };
-        return this.client.request(MOVIE_ENDPOINTS.MOVIE + endpoint, params);
+    fetch_movie_list(endpoint, params = {}) {
+        const mergedParams = { ...this.defaultOptions, ...params };
+        return this.client.request(MOVIE_ENDPOINTS.MOVIE + endpoint, mergedParams);
     }
     /**
      * Now Playing
      * GET - https://api.themoviedb.org/3/movie/now_playing
      *
      * Get a list of movies that are currently in theatres.
-     * @param language Language (Defaults to en-US)
+     * @param language Language (Defaults to en-US or TMDB default)
      * @param page Page (Defaults to 1)
      * @param region ISO-3166-1 code
      */
-    async now_playing(language = "en-US", page = 1, region) {
-        return this.fetch_movie_list(MOVIE_LISTS_ENDPOINTS.NOW_PLAYING, language, page, region);
+    async now_playing(params = {}) {
+        return this.fetch_movie_list(MovieListEndpoints.NOW_PLAYING, params);
     }
     /**
      * Popular
      * GET - https://api.themoviedb.org/3/movie/popular
      *
      * Get a list of movies ordered by popularity.
-     * @param language Language (Defaults to en-US)
+     * @param language Language (Defaults to en-US or TMDB default)
      * @param page Page (Defaults to 1)
      * @param region ISO-3166-1 code
      */
-    async popular(language = "en-US", page = 1, region) {
-        return this.fetch_movie_list(MOVIE_LISTS_ENDPOINTS.POPULAR, language, page, region);
+    async popular(params = {}) {
+        return this.fetch_movie_list(MovieListEndpoints.POPULAR, params);
     }
     /**
      * Top Rated
      * GET - https://api.themoviedb.org/3/movie/top_rated
      *
      * Get a list of movies ordered by rating.
-     * @param language Language (Defaults to en-US)
+     * @param language Language (Defaults to en-US or TMDB default)
      * @param page Page (Defaults to 1)
      * @param region ISO-3166-1 code
      */
-    async top_rated(language = "en-US", page = 1, region) {
-        return this.fetch_movie_list(MOVIE_LISTS_ENDPOINTS.TOP_RATED, language, page, region);
+    async top_rated(params = {}) {
+        return this.fetch_movie_list(MovieListEndpoints.TOP_RATED, params);
     }
     /**
      * Upcoming
      * GET - https://api.themoviedb.org/3/movie/upcoming
      *
      * Get a list of movies that are being released soon.
-     * @param language Language (Defaults to en-US)
+     * @param language Language (Defaults to en-US or TMDB default)
      * @param page Page (Defaults to 1)
      * @param region ISO-3166-1 code
      */
-    async upcoming(language = "en-US", page = 1, region) {
-        return this.fetch_movie_list(MOVIE_LISTS_ENDPOINTS.UPCOMING, language, page, region);
+    async upcoming(params = {}) {
+        return this.fetch_movie_list(MovieListEndpoints.UPCOMING, params);
     }
 }

package/dist/endpoints/movies.d.ts

@@ -1,7 +1,8 @@
 import { ApiClient } from "../client";
+import { TMDBOptions } from "../tmdb";
 import { Changes } from "../types/common";
 import { MovieAlternativeTitles, MovieCredits, MovieDetails, MovieExternalIDs, MovieImages, MovieKeywords, MovieReleaseDates, MovieResultItem, MovieTranslations, MovieVideos, MovieWatchProvider } from "../types/movies";
-import { PaginatedResponse } from "../types/params";
+import { MovieAlternativeTitlesParams, MovieDetailsParams, PaginatedResponse } from "../types/params";
 export declare const MOVIE_ENDPOINTS: {
     MOVIE: string;
     ALTERNATIVE_TITLES: string;
@@ -20,7 +21,8 @@ export declare const MOVIE_ENDPOINTS: {
 };
 export declare class MoviesAPI {
     private client;
-    constructor(client: ApiClient);
+    private defaultOptions;
+    constructor(client: ApiClient, options?: TMDBOptions);
     /**
      * Details
      * GET - https://api.themoviedb.org/3/movie/{movie_id}
@@ -32,7 +34,7 @@ export declare class MoviesAPI {
      * @returns A promise that resolves to the movie details.
      * @reference https://developer.themoviedb.org/reference/movie-details
      */
-    details(movie_id: number, append_to_response?: string[], language?: string): Promise<MovieDetails>;
+    details(params: MovieDetailsParams): Promise<MovieDetails>;
     /**
      * Alternative Titles
      * GET - https://api.themoviedb.org/3/movie/{movie_id}/alternative_titles
@@ -43,7 +45,7 @@ export declare class MoviesAPI {
      * @returns A promise that resolves to the movie alternative titles.
      * @reference https://developer.themoviedb.org/reference/movie-alternative-titles
      */
-    alternative_titles(movie_id: number, country?: string): Promise<MovieAlternativeTitles>;
+    alternative_titles(params: MovieAlternativeTitlesParams): Promise<MovieAlternativeTitles>;
     /**
      * Credits
      * GET - https://api.themoviedb.org/3/movie/{movie_id}/credits

package/dist/endpoints/movies.js

@@ -1,3 +1,4 @@
+import { mergeParams } from "../utils/params";
 export const MOVIE_ENDPOINTS = {
     MOVIE: "/movie",
     ALTERNATIVE_TITLES: "/alternative_titles",
@@ -22,8 +23,10 @@ export const MOVIE_ENDPOINTS = {
 };
 export class MoviesAPI {
     client;
-    constructor(client) {
+    defaultOptions;
+    constructor(client, options = {}) {
         this.client = client;
+        this.defaultOptions = options;
     }
     /**
      * Details
@@ -36,10 +39,10 @@ export class MoviesAPI {
      * @returns A promise that resolves to the movie details.
      * @reference https://developer.themoviedb.org/reference/movie-details
      */
-    async details(movie_id, append_to_response, language) {
-        const params = { append_to_response, language };
-        const endpoint = `${MOVIE_ENDPOINTS.MOVIE}/${movie_id}`;
-        return this.client.request(endpoint, params);
+    async details(params) {
+        const mergedParams = { ...this.defaultOptions, ...params };
+        const endpoint = `${MOVIE_ENDPOINTS.MOVIE}/${mergedParams.movie_id}`;
+        return this.client.request(endpoint, mergedParams);
     }
     /**
      * Alternative Titles
@@ -51,10 +54,10 @@ export class MoviesAPI {
      * @returns A promise that resolves to the movie alternative titles.
      * @reference https://developer.themoviedb.org/reference/movie-alternative-titles
      */
-    async alternative_titles(movie_id, country) {
-        const params = { country: country || "" };
-        const endpoint = `${MOVIE_ENDPOINTS.MOVIE}/${movie_id}${MOVIE_ENDPOINTS.ALTERNATIVE_TITLES}`;
-        return this.client.request(endpoint, params);
+    async alternative_titles(params) {
+        const mergedParams = mergeParams(this.defaultOptions, params);
+        const endpoint = `${MOVIE_ENDPOINTS.MOVIE}/${mergedParams.movie_id}${MOVIE_ENDPOINTS.ALTERNATIVE_TITLES}`;
+        return this.client.request(endpoint, mergedParams);
     }
     /**
      * Credits

package/dist/endpoints/search.d.ts

@@ -1,12 +1,14 @@
 import { ApiClient } from "../client";
 import { MovieResultItem } from "../types/movies";
-import { PaginatedResponse } from "../types/params";
+import { PaginatedResponse, SearchMoviesParams } from "../types/params";
+import { TMDBOptions } from "../tmdb";
 export declare const SEARCH_ENDPOINTS: {
     MOVIE: string;
 };
 export declare class SearchAPI {
     private client;
-    constructor(client: ApiClient);
+    private defaultOptions;
+    constructor(client: ApiClient, defaultOptions?: TMDBOptions);
     /**
      * Search
      * GET - https://api.themoviedb.org/3/search/movie
@@ -21,5 +23,5 @@ export declare class SearchAPI {
      * @param year Year
      * @reference https://developer.themoviedb.org/reference/search-movie
      */
-    movies(query: string, include_adult?: boolean, language?: string, page?: number, primary_release_year?: string, region?: string, year?: string): Promise<PaginatedResponse<MovieResultItem>>;
+    movies(params: SearchMoviesParams): Promise<PaginatedResponse<MovieResultItem>>;
 }

package/dist/endpoints/search.js

@@ -3,8 +3,10 @@ export const SEARCH_ENDPOINTS = {
 };
 export class SearchAPI {
     client;
-    constructor(client) {
+    defaultOptions; // ** Default options for all requests
+    constructor(client, defaultOptions = {}) {
         this.client = client;
+        this.defaultOptions = defaultOptions;
     }
     /**
      * Search
@@ -20,17 +22,10 @@ export class SearchAPI {
      * @param year Year
      * @reference https://developer.themoviedb.org/reference/search-movie
      */
-    async movies(query, include_adult = false, language = "en-US", page = 1, primary_release_year, region, year) {
-        const params = {
-            query,
-            include_adult,
-            language,
-            page,
-            primary_release_year,
-            year,
-            region,
-        };
+    async movies(params) {
         const endpoint = `${SEARCH_ENDPOINTS.MOVIE}`;
-        return this.client.request(endpoint, params);
+        // Merge defaultOptions with params, giving precedence to params
+        const mergedParams = { ...this.defaultOptions, ...params };
+        return this.client.request(endpoint, mergedParams);
     }
 }

package/dist/tests/movie_list/movie_list.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/movie_list/movie_list.integration.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { TMDB } from "../../tmdb";
+const token = process.env.TMDB_ACCESS_TOKEN;
+if (!token)
+    throw new Error("TMDB_ACCESS_TOKEN is not set, plaase set it in your enviroment variables.");
+const tmdb = new TMDB(token, { language: "it-IT", region: "IT", country: "IT" });
+describe("Movie List (integration)", () => {
+    it("(NOW PLAYING) should get now playing movies", async () => {
+        const now_playing = await tmdb.movie_lists.now_playing();
+        expect(now_playing.page).toBe(1);
+        expect(now_playing.total_results).toBeGreaterThan(0);
+        expect(now_playing.results.length).toBeGreaterThan(0);
+    });
+    it("(POPULAR) should get popular movies", async () => {
+        const popular = await tmdb.movie_lists.popular();
+        expect(popular.page).toBe(1);
+        expect(popular.total_results).toBeGreaterThan(0);
+        expect(popular.results.length).toBeGreaterThan(0);
+    });
+    it("(TOP RATED) should get top rated movies", async () => {
+        const top_rated = await tmdb.movie_lists.top_rated();
+        expect(top_rated.page).toBe(1);
+        expect(top_rated.total_results).toBeGreaterThan(0);
+        expect(top_rated.results.length).toBeGreaterThan(0);
+    });
+    it("(UPCOMING) should get upcoming movies", async () => {
+        const upcoming = await tmdb.movie_lists.upcoming();
+        expect(upcoming.page).toBe(1);
+        expect(upcoming.total_results).toBeGreaterThan(0);
+        expect(upcoming.results.length).toBeGreaterThan(0);
+    });
+});

package/dist/tests/movies/movies.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/movies/movies.integration.test.js

@@ -0,0 +1,145 @@
+import { describe, expect, it } from "vitest";
+import { TMDB } from "../../tmdb";
+import { TMDBError } from "../../errors/tmdb";
+import { ISO3166Country } from "../../types/utility";
+const token = process.env.TMDB_ACCESS_TOKEN;
+if (!token)
+    throw new Error("TMDB_ACCESS_TOKEN is not set, plaase set it in your enviroment variables.");
+const tmdb = new TMDB(token);
+describe("Movies (integration)", () => {
+    it("(MOVIE DETAILS) should get movie details", async () => {
+        const movie_id = 550; // Fight Club
+        const movie = await tmdb.movies.details({ movie_id });
+        expect(movie).toBeDefined();
+        expect(movie.id).toBe(movie_id);
+        expect(movie.title).toBe("Fight Club");
+    });
+    it("(MOVIE DETAILS) should throw an error for not found movie ID", async () => {
+        const invalid_movie_id = -1; // Invalid movie ID
+        // ** Can't test the specific error because API is not returning the same error for the same request
+        try {
+            await tmdb.movies.details({ movie_id: invalid_movie_id });
+            throw new Error("Expected TMDBError was not thrown");
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(TMDBError);
+        }
+    });
+    it("(MOVIE ALTERNATIVE TITLES) should get movie alternative titles", async () => {
+        const movie_id = 550; // Fight Club
+        const movie_titles = await tmdb.movies.alternative_titles({ movie_id });
+        expect(movie_titles).toBeDefined();
+        expect(movie_titles.id).toBe(movie_id);
+        expect(movie_titles.titles.length).toBeGreaterThan(0);
+    });
+    it("(MOVIE CREDITS) should get movie credits", async () => {
+        const movie_id = 550; // Fight Club
+        const credits = await tmdb.movies.credits(movie_id);
+        expect(credits).toBeDefined();
+        expect(credits.id).toBe(movie_id);
+        expect(credits.cast.length).toBeGreaterThan(0);
+        expect(credits.crew.length).toBeGreaterThan(0);
+        expect(credits.cast[0].name).toBe("Edward Norton");
+    });
+    it("(MOVIE EXTERNAL IDS) should get movie external IDs", async () => {
+        const movie_id = 550; // Fight Club
+        const external_ids = await tmdb.movies.external_ids(movie_id);
+        expect(external_ids).toBeDefined();
+        expect(external_ids.id).toBe(movie_id);
+        expect(external_ids.imdb_id).toBe("tt0137523");
+    });
+    it("(MOVIE KEYWORDS) should get movie keywords", async () => {
+        const movie_id = 550; // Fight Club
+        const keywords = await tmdb.movies.keywords(movie_id);
+        expect(keywords).toBeDefined();
+        expect(keywords.id).toBe(movie_id);
+        expect(keywords.keywords.length).toBeGreaterThan(0);
+    });
+    it("(MOVIE CHANGES) should get movie changes", async () => {
+        const movie_id = 550; // Fight Club
+        const start_date = "2024-12-20";
+        const end_date = "2024-12-24";
+        const changes = await tmdb.movies.changes(movie_id, 1, start_date, end_date);
+        expect(changes).toBeDefined();
+        expect(changes.changes).toBeDefined();
+        expect(changes.changes[0].key).toBe("images");
+        expect(changes.changes[0].items.length).toBeGreaterThan(0);
+    });
+    it("(MOVIE IMAGES) should get movie images", async () => {
+        const movie_id = 550; // Fight Club
+        const images = await tmdb.movies.images(movie_id);
+        expect(images).toBeDefined();
+        expect(images.id).toBe(movie_id);
+        expect(images.backdrops.length).toBeGreaterThan(0);
+        expect(images.posters.length).toBeGreaterThan(0);
+    });
+    it("(MOVIE IMAGES) should get movie images for a specific language", async () => {
+        const movie_id = 550; // Fight Club
+        const images = await tmdb.movies.images(movie_id, "en");
+        expect(images).toBeDefined();
+        expect(images.id).toBe(movie_id);
+        expect(images.backdrops.length).toBeGreaterThan(0);
+        expect(images.posters.length).toBeGreaterThan(0);
+    });
+    it("(MOVIE LATEST) should get the latest movie details", async () => {
+        const latestMovie = await tmdb.movies.latest();
+        expect(latestMovie).toBeDefined();
+        expect(latestMovie.id).toBeDefined();
+        expect(latestMovie.title).toBeDefined();
+    });
+    it("(MOVIE RECOMMENDATIONS) should get movie recommendations", async () => {
+        const movie_id = 550; // Fight Club
+        const recommendations = await tmdb.movies.recommendations(movie_id);
+        expect(recommendations).toBeDefined();
+        expect(recommendations.results.length).toBeGreaterThan(0);
+        expect(recommendations.results[0].id).toBeDefined();
+        expect(recommendations.page).toBe(1);
+        expect(recommendations.total_results).toBeGreaterThan(0);
+        expect(recommendations.total_pages).toBeGreaterThan(0);
+    });
+    it("(MOVIE RELEASE DATES) should get movie release dates", async () => {
+        const movie_id = 550; // Fight Club
+        const release_dates = await tmdb.movies.release_dates(movie_id);
+        expect(release_dates).toBeDefined();
+        expect(release_dates.id).toBe(movie_id);
+        expect(release_dates.results.length).toBeGreaterThan(0);
+        expect(release_dates.results[0].iso_3166_1).toBeDefined();
+        expect(release_dates.results[0].release_dates.length).toBeGreaterThan(0);
+    });
+    it("(MOVIE SIMILAR) should get similar movies", async () => {
+        const movie_id = 550;
+        const similar = await tmdb.movies.similar(movie_id);
+        expect(similar).toBeDefined();
+        expect(similar.results.length).toBeGreaterThan(0);
+        expect(similar.results[0].id).toBeDefined();
+        expect(similar.page).toBe(1);
+        expect(similar.total_results).toBeGreaterThan(0);
+        expect(similar.total_pages).toBeGreaterThan(0);
+    });
+    it("(MOVIE TRANSLATIONS) should get translations for a movie", async () => {
+        const movie_id = 550;
+        const translations = await tmdb.movies.translations(movie_id);
+        expect(translations).toBeDefined();
+        expect(translations.id).toBe(movie_id);
+        expect(translations.translations).toBeDefined();
+        expect(translations.translations.length).toBeGreaterThan(0);
+        expect(translations.translations[0].data).toBeDefined();
+    });
+    it("(MOVIE VIDEOS) should get videos for a movie", async () => {
+        const movie_id = 550;
+        const videos = await tmdb.movies.videos(movie_id);
+        expect(videos).toBeDefined();
+        expect(videos.id).toBe(movie_id);
+        expect(videos.results).toBeDefined();
+        expect(videos.results.length).toBeGreaterThan(0);
+        expect(videos.results[0].id).toBeDefined();
+    });
+    it("(MOVIE WATCH PROVIDERS) should get watch providers for a movie", async () => {
+        const movie_id = 550;
+        const watch_providers = await tmdb.movies.watch_providers(movie_id);
+        expect(watch_providers).toBeDefined();
+        expect(watch_providers.id).toBe(movie_id);
+        expect(watch_providers.results).toBeDefined();
+        expect(watch_providers.results[ISO3166Country.US]).toBeDefined();
+    });
+});

package/dist/tests/movies/movies.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/movies/movies.test.js

@@ -0,0 +1,42 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ApiClient } from "../../client";
+import { MoviesAPI } from "../../endpoints/movies";
+import { TMDB } from "../../tmdb";
+let tmdb = new TMDB("valid_access_token");
+describe("MoviesAPI", () => {
+    let clientMock;
+    let moviesAPI;
+    beforeEach(() => {
+        clientMock = new ApiClient("valid_access_token");
+        clientMock.request = vi.fn();
+        moviesAPI = new MoviesAPI(clientMock);
+    });
+    it("should call client.request with the correct parameters", async () => {
+        const movie_id = 550;
+        const append_to_response = ["credits", "images"];
+        const language = "en";
+        await moviesAPI.details({ movie_id, append_to_response, language });
+        expect(clientMock.request).toHaveBeenCalledOnce();
+        expect(clientMock.request).toHaveBeenCalledWith("/movie/550", {
+            movie_id,
+            append_to_response,
+            language,
+        });
+    });
+    it("should work correctly without optional parameters", async () => {
+        const movie_id = 550;
+        await moviesAPI.details({ movie_id });
+        expect(clientMock.request).toHaveBeenCalledOnce();
+        expect(clientMock.request).toHaveBeenCalledWith("/movie/550", {
+            movie_id,
+            append_to_response: undefined,
+            language: undefined,
+        });
+    });
+    it("should return the result from client.request", async () => {
+        const fakeResponse = { id: 550, title: "Fight Club" };
+        clientMock.request.mockResolvedValue(fakeResponse);
+        const result = await moviesAPI.details({ movie_id: 550 });
+        expect(result).toEqual(fakeResponse);
+    });
+});

package/dist/tests/search/search.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/search/search.integration.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { TMDB } from "../../tmdb";
+const token = process.env.TMDB_ACCESS_TOKEN;
+if (!token)
+    throw new Error("TMDB_ACCESS_TOKEN is not set, plaase set it in your enviroment variables.");
+const tmdb = new TMDB(token);
+describe("Search (integration)", () => {
+    it("(SEARCH MOVIE) should search for a particular movie", async () => {
+        const movies = await tmdb.search.movies({ query: "Fight Club" });
+        expect(movies.page).toBe(1);
+        expect(movies.total_results).toBeGreaterThan(0);
+        expect(movies.results.length).toBeGreaterThan(0);
+        expect(movies.results[0].title).toBe("Fight Club");
+    });
+    it("(SEARCH MOVIE) should search for a movie with default options", async () => {
+        const tmdb = new TMDB(token, { language: "it-IT", region: "IT" });
+        const movies = await tmdb.search.movies({ query: "Fight Club" });
+        expect(movies.page).toBe(1);
+        expect(movies.total_results).toBeGreaterThan(0);
+        expect(movies.results.length).toBeGreaterThan(0);
+        expect(movies.results[0].title).toBe("Fight Club");
+    });
+});

package/dist/tests/tmdb.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/tmdb.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { TMDB } from "../tmdb";
+import { Errors } from "../errors/messages";
+describe("TMDB API Client", () => {
+    it("should throw an error if no access token is provided", () => {
+        expect(() => new TMDB("")).toThrowError(Errors.NO_ACCESS_TOKEN);
+    });
+    it("should create an instance of TMDB with a valid access token", () => {
+        const tmdb = new TMDB("valid_access_token");
+        expect(tmdb).toBeInstanceOf(TMDB);
+    });
+});

package/dist/tmdb.d.ts

@@ -1,10 +1,26 @@
 import { MovieListsAPI } from "./endpoints/movie_lists";
 import { MoviesAPI } from "./endpoints/movies";
 import { SearchAPI } from "./endpoints/search";
+export type TMDBOptions = {
+    language?: string;
+    region?: string;
+    country?: string;
+};
 export declare class TMDB {
     private client;
+    private options;
     movies: MoviesAPI;
     movie_lists: MovieListsAPI;
     search: SearchAPI;
-    constructor(accessToken: string);
+    /**
+     * Creates a new TMDB instance.
+     * @param accessToken The TMDB API access token.
+     * @param options Optional default options (e.g., language) for all requests.
+     */
+    constructor(accessToken: string, options?: TMDBOptions);
+    /**
+     * Helper to merge default options with method-specific params.
+     * Method-level params override defaults.
+     */
+    withDefaults<T extends object>(params?: T): T & TMDBOptions;
 }

package/dist/tmdb.js

@@ -6,16 +6,30 @@ import { SearchAPI } from "./endpoints/search";
 import { Errors } from "./errors/messages";
 export class TMDB {
     client;
+    options; // ** Default options for all requests
     movies;
     movie_lists;
     search;
     // etc...
-    constructor(accessToken) {
+    /**
+     * Creates a new TMDB instance.
+     * @param accessToken The TMDB API access token.
+     * @param options Optional default options (e.g., language) for all requests.
+     */
+    constructor(accessToken, options = {}) {
         if (!accessToken)
             throw new Error(Errors.NO_ACCESS_TOKEN);
+        this.options = options;
         this.client = new ApiClient(accessToken);
-        this.movies = new MoviesAPI(this.client);
-        this.movie_lists = new MovieListsAPI(this.client);
-        this.search = new SearchAPI(this.client);
+        this.movies = new MoviesAPI(this.client, options);
+        this.movie_lists = new MovieListsAPI(this.client, options);
+        this.search = new SearchAPI(this.client, options);
+    }
+    /**
+     * Helper to merge default options with method-specific params.
+     * Method-level params override defaults.
+     */
+    withDefaults(params) {
+        return { ...this.options, ...params };
     }
 }