@lorenzopant/tmdb 1.17.0 → 1.17.1

package/dist/client.d.ts

@@ -3,10 +3,44 @@ export declare class ApiClient {
     private accessToken;
     private baseUrl;
     private logger?;
+    /**
+     * Tracks in-flight requests keyed by a deterministic string derived from the endpoint
+     * and its parameters. When two identical requests are fired concurrently, the second
+     * caller receives the same Promise as the first — only one fetch is made.
+     * Entries are removed via `.finally()` so the map never holds settled promises.
+     */
+    private inflightRequests;
+    private deduplication;
     constructor(accessToken: string, options?: {
         logger?: boolean | TMDBLoggerFn;
+        deduplication?: boolean;
     });
+    /**
+     * Builds a stable, order-independent cache key for a request.
+     *
+     * `undefined` values are excluded (they are never serialised into the URL),
+     * and the remaining entries are sorted alphabetically before joining so that
+     * `{ language, page }` and `{ page, language }` produce the same key.
+     */
+    private buildRequestKey;
+    /**
+     * Makes an authenticated GET request to the TMDB API, returning the parsed and
+     * null-sanitised response.
+     *
+     * **Deduplication:** when enabled (the default), concurrent calls with the same
+     * `endpoint` + `params` share a single in-flight fetch. The second (and any
+     * subsequent) caller receives the same `Promise` — no extra network request is made.
+     * Once the promise settles (success or error) it is evicted from the map so the next
+     * call triggers a fresh fetch. Deduplication can be disabled globally via
+     * `TMDBOptions.deduplication = false`.
+     */
     request<T>(endpoint: string, params?: Record<string, unknown | undefined>): Promise<T>;
+    /**
+     * The actual fetch + response-parsing pipeline. Called by `request()` only when no
+     * matching in-flight promise exists. Handles URL construction, auth headers, logging,
+     * error mapping, and null sanitisation.
+     */
+    private doRequest;
     /**
      * Recursively converts null values to undefined in API responses.
      * This allows optional properties to model fields that TMDB returns as nullable.

package/dist/client.js

@@ -5,11 +5,63 @@ export class ApiClient {
     accessToken;
     baseUrl = "https://api.themoviedb.org/3";
     logger;
+    /**
+     * Tracks in-flight requests keyed by a deterministic string derived from the endpoint
+     * and its parameters. When two identical requests are fired concurrently, the second
+     * caller receives the same Promise as the first — only one fetch is made.
+     * Entries are removed via `.finally()` so the map never holds settled promises.
+     */
+    inflightRequests = new Map();
+    deduplication;
     constructor(accessToken, options = {}) {
         this.accessToken = accessToken;
         this.logger = TMDBLogger.from(options.logger);
+        this.deduplication = options.deduplication !== false;
+    }
+    /**
+     * Builds a stable, order-independent cache key for a request.
+     *
+     * `undefined` values are excluded (they are never serialised into the URL),
+     * and the remaining entries are sorted alphabetically before joining so that
+     * `{ language, page }` and `{ page, language }` produce the same key.
+     */
+    buildRequestKey(endpoint, params) {
+        const definedEntries = Object.entries(params)
+            .filter(([, v]) => v !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => `${k}=${String(v)}`);
+        return definedEntries.length > 0 ? `${endpoint}?${definedEntries.join("&")}` : endpoint;
     }
+    /**
+     * Makes an authenticated GET request to the TMDB API, returning the parsed and
+     * null-sanitised response.
+     *
+     * **Deduplication:** when enabled (the default), concurrent calls with the same
+     * `endpoint` + `params` share a single in-flight fetch. The second (and any
+     * subsequent) caller receives the same `Promise` — no extra network request is made.
+     * Once the promise settles (success or error) it is evicted from the map so the next
+     * call triggers a fresh fetch. Deduplication can be disabled globally via
+     * `TMDBOptions.deduplication = false`.
+     */
     async request(endpoint, params = {}) {
+        if (!this.deduplication)
+            return this.doRequest(endpoint, params);
+        const key = this.buildRequestKey(endpoint, params);
+        const existing = this.inflightRequests.get(key);
+        if (existing)
+            return existing;
+        const promise = this.doRequest(endpoint, params).finally(() => {
+            this.inflightRequests.delete(key);
+        });
+        this.inflightRequests.set(key, promise);
+        return promise;
+    }
+    /**
+     * The actual fetch + response-parsing pipeline. Called by `request()` only when no
+     * matching in-flight promise exists. Handles URL construction, auth headers, logging,
+     * error mapping, and null sanitisation.
+     */
+    async doRequest(endpoint, params) {
         const url = new URL(`${this.baseUrl}${endpoint}`);
         const jwt = isJwt(this.accessToken);
         for (const [key, value] of Object.entries(params)) {

package/dist/tmdb.js

@@ -64,7 +64,7 @@ export class TMDB {
         if (!accessToken)
             throw new Error(Errors.NO_ACCESS_TOKEN);
         this.options = options;
-        this.client = new ApiClient(accessToken, { logger: options.logger });
+        this.client = new ApiClient(accessToken, { logger: options.logger, deduplication: options.deduplication });
         this.movies = new MoviesAPI(this.client, this.options);
         this.movie_lists = new MovieListsAPI(this.client, this.options);
         this.search = new SearchAPI(this.client, this.options);

package/dist/types/config/options.d.ts

@@ -33,4 +33,14 @@ export type TMDBOptions = {
      * - Pass a function to customize logging output.
      */
     logger?: boolean | TMDBLoggerFn;
+    /**
+     * Controls whether concurrent identical requests are deduplicated.
+     * When `true` (default), multiple in-flight calls with the same endpoint and
+     * parameters share a single fetch and resolve from the same Promise.
+     * Set to `false` to disable deduplication — every call always triggers its
+     * own fetch. Useful for polling loops, force-refreshes after mutations, or
+     * any scenario where stale in-flight data must not be reused.
+     * @default true
+     */
+    deduplication?: boolean;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lorenzopant/tmdb",
-	"version": "1.17.0",
+	"version": "1.17.1",
 	"description": "A completely type-safe The Movie Database (TMDB) API wrapper for typescript applications.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",