@lorenzopant/tmdb 0.0.2 → 0.0.3

package/dist/endpoints/search.d.ts

@@ -1,6 +1,6 @@
 import { ApiClient } from "../client";
 import { MovieResultItem } from "../types/movies";
-import { PaginatedResponse } from "../types/params";
+import { PaginatedResponse, SearchMoviesParams } from "../types/params";
 export declare const SEARCH_ENDPOINTS: {
     MOVIE: string;
 };
@@ -21,5 +21,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

@@ -20,16 +20,7 @@ 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);
     }

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);
+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(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,40 @@
+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-US";
+        await moviesAPI.details(movie_id, append_to_response, language);
+        expect(clientMock.request).toHaveBeenCalledOnce();
+        expect(clientMock.request).toHaveBeenCalledWith("/movie/550", {
+            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", {
+            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(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,15 @@
+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");
+    });
+});

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/types/params.d.ts

@@ -4,3 +4,12 @@ export type PaginatedResponse<T> = {
     total_results: number;
     results: T[];
 };
+export type SearchMoviesParams = {
+    query: string;
+    include_adult?: boolean;
+    language?: string;
+    page?: number;
+    primary_release_year?: string;
+    region?: string;
+    year?: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lorenzopant/tmdb",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "A completely type-safe The Movie Database (TMDB) API wrapper for typescript applications.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,14 +8,6 @@
     "type": "git",
     "url": "git+https://github.com/lorenzopantano/tmdb-api-ts"
   },
-  "scripts": {
-    "build": "tsc",
-    "build:watch": "tsc --watch",
-    "test": "vitest",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest --coverage",
-    "prepare": "npm run build"
-  },
   "author": "Lorenzo Pantano",
   "license": "MIT",
   "keywords": [
@@ -32,6 +24,16 @@
     "release-it": "^19.0.3",
     "release-it-pnpm": "^4.6.6",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.2"
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "vite": "^7.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage"
   }
-}
+}