connector-tmdb

Movie and TV data with tmdb-client

Motoko bindings for The Movie Database API, generated from TMDb's OpenAPI spec. 124 operations in one module (Apis/DefaultApi) — the spec carries no tags, so there is nothing to split on and no nested facade.

Read this before planning the app: the read surface works, the write surface does not. Of the 124 operations, 111 are usable and 13 are broken:

• 12 carry a request body — 11 of the 12 POSTs plus authenticationDeleteSession

— and go out double-wrapped (§6).

• 1 read, movieRecommendations, throws on every successful response (§6).

Plan features around catalog reads (search, details, trending, discover, now-playing) and keep favorites, ratings and watchlists out of scope unless you are prepared to fix the generator first. Use tvSeriesRecommendations if you need a "more like this" row; its movie counterpart is the broken one.

Backend

1. Add the dependency

mops add tmdb-client

2. The credential

Use the v4 read-access token and `?#bearer`. That is the only credential this client supports.

auth = ?#bearer "eyJhbGciOi…"   // v4 read-access token, themoviedb.org/settings/api

TMDb also issues a v3 API key (32 hex chars) that normally travels as an ?api_key=… query parameter. This client cannot send it. The spec declares exactly one security scheme — apiKey in a header named Authorization, tagged x-bearer-format: bearer — so no generated operation ever appends api_key to the URL (api_key occurs zero times in DefaultApi.mo).

And do not reach for the ?#apiKey variant that Config.Auth happens to offer: it emits Authorization: <key> without the Bearer prefix, which TMDb rejects with 401. It is a generic generator variant, wrong for this API. ?#bearer is the one wired correctly.

The v4 token is minted off-chain and never expires — no OAuth flow, no refresh to implement for the read surface.

Where the credential lives

The actor in §3 takes the token as a parameter, which keeps the example self-contained. For a real app you do not want the frontend holding the credential — put it in actor state, set by an authorized update call:

• Declare the field type-only. Caffeine actors get their stable state from

the migration chain, so var tmdbToken : Text; — without an initializer. Writing var tmdbToken : Text = ""; is M0250 the moment it is compiled in a real project.

• Gate the setter with MixinAuthorization and read the field only inside the

actor when building Config.

• Never return it from a query method, never log it, never include it in an

error surfaced to the caller.

connector-googlemail is the worked example of that shape — a gmailConfig record of type-only var fields, an authorization mixin over the setter, and the migration head that supplies the initial values. Follow it if the app needs admin-managed credentials; the parameter form above is fine for a prototype or when the caller is already trusted.

3. Canonical layout

The actor below is the whole backend for a movie-search feature. It maps TMDb's wide optional-everything response into a narrow record the frontend can consume without null-checking fourteen fields.

import Tmdb "mo:tmdb-client/Apis/DefaultApi";
import { defaultConfig; type Config } "mo:tmdb-client/Config";
import Array "mo:core/Array";

persistent actor {

    /// Narrow, frontend-friendly shape. TMDb marks almost every field
    /// optional, so collapse the optionals here once instead of in the UI.
    public type Movie = {
        id : Int;
        title : Text;
        overview : Text;
        releaseDate : Text;
        posterUrl : Text;
        voteAverage : Float;
    };

    /// The v4 read-access token is passed in rather than stored here — see
    /// "Where the credential lives" below for the admin-set variant.
    func config(token : Text) : Config = {
        defaultConfig with
        auth = ?#bearer token;
        // search and discover payloads run large; the default cap is too
        // small for a 20-result page with overviews.
        max_response_bytes = ?300_000;
    };

    /// Poster paths come back relative (`/abc.jpg`); prepend an image base.
    /// w500 is the usual card size. An empty path yields an empty string so
    /// the frontend can fall back to a placeholder.
    func posterUrl(path : ?Text) : Text {
        switch (path) {
            case (?p) "https://image.tmdb.org/t/p/w500" # p;
            case null "";
        };
    };

    /// One mapper for every list endpoint. The parameter type is written
    /// STRUCTURALLY rather than naming a generated model, because each
    /// endpoint has its own `…ResultsInner` type with the same fields —
    /// `SearchMovie200ResponseResultsInner`,
    /// `MovieNowPlayingList200ResponseResultsInner`, and so on. One structural
    /// signature accepts all of them.
    func toMovie(
        m : {
            id : ?Int;
            title : ?Text;
            overview : ?Text;
            release_date : ?Text;
            poster_path : ?Text;
            vote_average : ?Float;
        }
    ) : Movie = {
        id = m.id ?? 0;
        title = m.title ?? "";
        overview = m.overview ?? "";
        releaseDate = m.release_date ?? "";
        posterUrl = posterUrl(m.poster_path);
        voteAverage = m.vote_average ?? 0.0;
    };

    // `query` is a reserved word in Motoko — hence `term` here, and `query_`
    // in the generated signature.
    public func searchMovies(token : Text, term : Text, page : Int) : async [Movie] {
        // searchMovie(config, query_, includeAdult, language,
        //             primaryReleaseYear, page, region_, year)
        // Text and Bool parameters are positional and NOT optional: pass ""
        // and false to omit them. Only `page` is 1-indexed.
        let response = await* Tmdb.searchMovie(
            config(token), term, false, "en-US", "", page, "", "",
        );
        let results = switch (response.results) {
            case (?r) r;
            case null [];
        };
        Array.map(results, toMovie);
    };

    /// Full detail for one title. `appendToResponse` embeds sub-resources in
    /// the SAME outcall — "credits,images,videos" costs one call, not four.
    public func movieOverview(token : Text, movieId : Int) : async Text {
        let movie = await* Tmdb.movieDetails(config(token), movieId, "", "en-US");
        movie.overview ?? "";
    };

    /// "In cinemas now" feed, for a landing page.
    public func nowPlaying(token : Text) : async [Movie] {
        let response = await* Tmdb.movieNowPlayingList(config(token), "en-US", 1, "US");
        let results = switch (response.results) {
            case (?r) r;
            case null [];
        };
        Array.map(results, toMovie);
    };
}

4. The read surface

All 124 operations live in mo:tmdb-client/Apis/DefaultApi as free functions taking Config first. The generated names are camelCase of TMDb's hyphenated operationIds (movie-now-playing-list → movieNowPlayingList). The useful groups:

Everything in a response is optional (?T), because TMDb omits fields rather than nulling them. Collapse the optionals at the actor boundary as §3 does.

Sort-by parameters are typed variants, not strings — pick from the generated *SortByParameter modules (e.g. #created_at_desc). Passing an arbitrary string will not type-check.

5. Calls are non-replicated by default

defaultConfig ships is_replicated = ?false, so one node performs each outcall and the response is not put to consensus. That is right in both directions here, and it is a change from 0.1.1, which shipped null (= replicated):

• Reads — catalog responses are stable, so replication buys nothing and

costs roughly 13× the cycles.

• Writes — listCreate and the three authenticationCreateSession*

operations are not idempotent. Replicated, each call would create ~13 lists or ~13 sessions, and the credential would leave every replica.

Correction to earlier guidance. The in-package SKILL.md that shipped inside tmdb-client@0.1.1 said: "for mutations leave `is_replicated = null` — consensus replication guards against single-node tampering." That is backwards. Consensus does not de-duplicate an outcall, it multiplies it; for a non-idempotent write, replication is the bug rather than the safeguard. If you find that pattern in existing code, ?false is the fix.

Override per call site with record update when a specific endpoint wants the other mode — but for TMDb there is no endpoint that does.

6. What is broken, and why

movieRecommendations throws on every success

It is generated as : async* Any, and its 2xx path accepts only a Candid integer:

case (#Int i__) i__;
case _ throw Error.reject(… "Unexpected primitive shape");

TMDb answers with a paginated object, so this rejects every successful response. The cause is a generator gap rather than a bad spec: TMDb declares the 200 body as {"type": "object", "properties": {}} — an object with no declared properties — and the plugin renders that as Any with a primitive-only decoder instead of passing the Candid value through. It is the only operation in the package with that shape. tvSeriesRecommendations is typed normally and works.

The write surface

All 12 body-carrying operations will be rejected by TMDb. Do not build features on them and do not report them as working:

Note the last row: `authenticationDeleteSession` is a DELETE, not a POST — TMDb puts the session id in its body. It is the one DELETE affected; the other four take query parameters and work.

The cause is in the spec, faithfully reproduced by the generator. TMDb models every POST body as a placeholder rather than a real schema:

{ "type": "object", "required": ["RAW_BODY"],
  "properties": { "RAW_BODY": { "type": "string", "format": "json" } } }

So the generated model has a single RAW_BODY : Text field, and the API module encodes it as a JSON object with that field in it. The wire body becomes

{"RAW_BODY":"{\"name\":\"My list\"}"}

where TMDb expects {"name":"My list"}. The payload is double-wrapped: correct against the spec, wrong against the service.

Two consequences worth knowing:

• Because the placeholder is shared, every body-carrying operation takes one

of the same two generated types (AccountAddFavoriteRequest, ListAddMovieRequest), so listCreate asks for an AccountAddFavoriteRequest. That is not a naming bug to work around; it is the same placeholder under two names.

• listClear is the one POST with no body, so it is unaffected and works.
• This is also why the sessions row is unusable end to end: you cannot create a

session, so the user-scoped GETs (accountGetFavorites, accountLists, …) have no sessionId to be called with, even though those GETs are themselves correctly generated.

What would fix all twelve at once: one generator change — recognise a request schema whose only property is a format: json string and pass that string through as the body verbatim, instead of encoding the wrapper object. The machinery already exists for the x-body-is-text / passthrough cases. Until then, the account-write surface is out of scope.

7. Response sizes and cycles

• max_response_bytes defaults to the platform maximum, which is both slower

and more expensive than needed. Set it to what the endpoint actually returns: ~300 KB for a 20-result search or discover page with overviews, ~50 KB for a single movieDetails without appendToResponse, more if you append sub-resources.

• Prefer appendToResponse over several outcalls. "credits,images,videos" on

movieDetails is one call and one cycle charge instead of four.

• configurationDetails is effectively static — fetch it once, keep it in a

var, and do not call it per request.

8. Things that will bite you

• Empty string and zero mean "omit". Text and Bool query parameters are

positional and not ?T: pass "" / false to leave one out. Only the enum query parameters are ?T.

• IDs are `Int`, not `Text`. movieId, tvSeriesId, personId,

accountId are all integers in the generated signatures. Coerce before calling.

• `page` is 1-indexed, 20 items per page, and page > 500 returns 422 —

clamp before calling rather than surfacing TMDb's error.

• Image paths are relative. poster_path / backdrop_path look like

/abc123.jpg; prepend https://image.tmdb.org/t/p/w500 (or another size from configurationDetails). A bare path renders nothing.

• Rate limit ~50 requests/second per IP, and TMDb sends no Retry-After. On

429, back off at least a second. Never retry inside a tight loop in a canister.

• `searchMulti` results are heterogeneous — each entry carries a

media_type of movie, tv or person, and the fields present differ accordingly (title for movies, name for TV and people). Branch on media_type before reading.

• 28 of TMDb's 152 operations are pruned out — but check before assuming.

focusApis keeps every operationId starting with tv, movie, account, person, search, list, lists, authentication, configuration, trending or discover. That means the movie- and tv-scoped variants of a resource are in while the standalone endpoint for the same resource is out. movieWatchProviders, movieKeywords, movieReviews, movieTranslations, movieChanges, searchCompany, searchCollection and authenticationCreateGuestSession are all present; it is watchProvidersMovieList, keywordDetails, reviewDetails, translations, changesMovieList, companyDetails, collectionDetails and guestSessionRatedMovies that are not. The full dropped set, measured against the spec:

  alternative-names-copy      certification-movie-list    certifications-tv-list
  changes-movie-list          changes-people-list         changes-tv-list
  collection-details          collection-images           collection-translations
  company-alternative-names   company-details             company-images
  credit-details              details-copy                find-by-id
  genre-movie-list            genre-tv-list               guest-session-rated-movies
  guest-session-rated-tv      guest-session-rated-tv-episodes
  keyword-details             keyword-movies              network-details
  review-details              translations                watch-provider-tv-list
  watch-providers-available-regions                       watch-providers-movie-list

If a feature needs one of those, add its prefix to focusApis and regenerate and republish the package. Search DefaultApi.mo for the camelCase name before concluding an operation is missing.

Related

• connector-weatherapi — the same generated-client shape at a much smaller

scale (9 operations), useful as a second example of the Config pattern.