kmcom-nuxt-layers 2.5.1 → 2.6.2

package/layers/metadata/providers/openlibrary/server/utils/metadata-openlibrary/normalise.ts

@@ -1,15 +1,21 @@
-import type { MetadataRecord, MetadataCreator } from '#layers/metadata/shared/types'
-import type { OpenLibrarySearchDoc, OpenLibraryWork, OpenLibraryEdition } from './types'
+import type { MetadataCreator, MetadataRecord } from '#layers/metadata/shared/types'
+
+import type { OpenLibraryEdition, OpenLibrarySearchDoc, OpenLibraryWork } from './types'
 
 // fallow-ignore-next-line complexity
 export function normaliseOpenLibrarySearchDoc(doc: OpenLibrarySearchDoc): MetadataRecord {
-  const creators: MetadataCreator[] = (doc.author_name ?? []).map((name, i) => ({
-    name,
-    role: 'author',
-    providerId: doc.author_key?.[i]?.replace('/authors/', '') ?? undefined,
-  }))
+  const creators: MetadataCreator[] = (doc.author_name ?? []).map((name, i) => {
+    const providerId = doc.author_key?.[i]?.replace('/authors/', '')
+    return {
+      name,
+      role: 'author',
+      ...(providerId && { providerId }),
+    }
+  })
 
   const id = doc.key.replace('/works/', '')
+  const isbn10 = doc.isbn?.find((i) => i.length === 10)
+  const isbn13 = doc.isbn?.find((i) => i.length === 13)
 
   return {
     id: `openlibrary:work:${id}`,
@@ -17,14 +23,14 @@ export function normaliseOpenLibrarySearchDoc(doc: OpenLibrarySearchDoc): Metada
     providerId: id,
     mediaType: 'book',
     title: doc.title,
-    subtitle: doc.subtitle,
-    creators: creators.length ? creators : undefined,
-    publisher: doc.publisher?.[0] ?? undefined,
-    publishedAt: doc.first_publish_year ? String(doc.first_publish_year) : undefined,
-    coverUrl: doc.cover_i ? openLibraryCoverUrl(doc.cover_i) : undefined,
+    ...(doc.subtitle && { subtitle: doc.subtitle }),
+    ...(creators.length && { creators }),
+    ...(doc.publisher?.[0] && { publisher: doc.publisher[0] }),
+    ...(doc.first_publish_year && { publishedAt: String(doc.first_publish_year) }),
+    ...(doc.cover_i && { coverUrl: openLibraryCoverUrl(doc.cover_i) }),
     identifiers: {
-      isbn10: doc.isbn?.find((i) => i.length === 10),
-      isbn13: doc.isbn?.find((i) => i.length === 13),
+      ...(isbn10 && { isbn10 }),
+      ...(isbn13 && { isbn13 }),
       openLibraryId: id,
     },
     sourceUrl: `https://openlibrary.org${doc.key}`,
@@ -44,10 +50,10 @@ export function normaliseOpenLibraryWork(work: OpenLibraryWork): MetadataRecord
     providerId: id,
     mediaType: 'book',
     title: work.title,
-    subtitle: work.subtitle,
-    description: desc,
-    coverUrl: work.covers?.[0] ? openLibraryCoverUrl(work.covers[0]) : undefined,
-    publishedAt: work.first_publish_date,
+    ...(work.subtitle && { subtitle: work.subtitle }),
+    ...(desc && { description: desc }),
+    ...(work.covers?.[0] && { coverUrl: openLibraryCoverUrl(work.covers[0]) }),
+    ...(work.first_publish_date && { publishedAt: work.first_publish_date }),
     identifiers: { openLibraryId: id },
     sourceUrl: `https://openlibrary.org${work.key}`,
     raw: work,
@@ -65,13 +71,13 @@ export function normaliseOpenLibraryEdition(edition: OpenLibraryEdition): Metada
     providerId: id,
     mediaType: 'book',
     title: edition.title,
-    subtitle: edition.subtitle,
-    publisher: edition.publishers?.[0] ?? undefined,
-    publishedAt: edition.publish_date,
-    coverUrl: edition.covers?.[0] ? openLibraryCoverUrl(edition.covers[0]) : undefined,
+    ...(edition.subtitle && { subtitle: edition.subtitle }),
+    ...(edition.publishers?.[0] && { publisher: edition.publishers[0] }),
+    ...(edition.publish_date && { publishedAt: edition.publish_date }),
+    ...(edition.covers?.[0] && { coverUrl: openLibraryCoverUrl(edition.covers[0]) }),
     identifiers: {
-      isbn10: edition.isbn_10?.[0],
-      isbn13: edition.isbn_13?.[0],
+      ...(edition.isbn_10?.[0] && { isbn10: edition.isbn_10[0] }),
+      ...(edition.isbn_13?.[0] && { isbn13: edition.isbn_13[0] }),
       openLibraryId: id,
     },
     sourceUrl: `https://openlibrary.org${edition.key}`,

package/layers/metadata/providers/openlibrary/server/utils/metadata-openlibrary/provider.ts

@@ -20,6 +20,10 @@ export const openLibraryProvider: MetadataProvider = {
   },
 
   async sync({ providerId, resourceType = 'work' }) {
-    return (await openLibraryProvider.lookup!({ provider: 'openlibrary', providerId, resourceType }))!
+    return (await openLibraryProvider.lookup!({
+      provider: 'openlibrary',
+      providerId,
+      resourceType,
+    }))!
   },
 }

package/layers/metadata/providers/openlibrary/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "../../../apps/playground/tsconfig.json",
+  "extends": "../../../../apps/playground/tsconfig.json",
   "compilerOptions": {
     "strict": true
   },

package/layers/metadata/providers/themoviedb/nuxt.config.ts

@@ -0,0 +1,36 @@
+export default defineNuxtConfig({
+  $meta: {
+    name: 'metadata-tmdb',
+  },
+
+  extends: ['../../'],
+
+  alias: {
+    '#layers/metadata-tmdb': import.meta.dirname,
+  },
+
+  compatibilityDate: '2026-06-30',
+
+  runtimeConfig: {
+    metadataTmdb: {
+      apiKey: '', // env: NUXT_METADATA_TMDB_API_KEY
+      baseUrl: 'https://api.themoviedb.org/3',
+      imageBaseUrl: 'https://image.tmdb.org/t/p',
+    },
+  },
+
+  typescript: {
+    typeCheck: false,
+    strict: true,
+  },
+})
+
+declare module '@nuxt/schema' {
+  type RuntimeConfig = {
+    metadataTmdb: {
+      apiKey: string
+      baseUrl: string
+      imageBaseUrl: string
+    }
+  }
+}

package/layers/metadata/providers/themoviedb/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "kmcom-layer-metadata-tmdb",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./nuxt.config.ts",
+  "scripts": {
+    "dev": "nuxi dev",
+    "dev:playground": "PLAYGROUND_LAYERS=core,metadata,metadata-tmdb pnpm -F playground dev",
+    "typecheck": "vue-tsc --noEmit -p ../../tsconfig.typecheck.json",
+    "lint": "eslint ."
+  }
+}

package/layers/metadata/providers/themoviedb/server/plugins/tmdb-register.ts

@@ -0,0 +1,3 @@
+export default defineNitroPlugin(() => {
+  registerProvider(tmdbProvider)
+})

package/layers/metadata/providers/themoviedb/server/utils/metadata-tmdb/client.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it, vi } from 'vitest'
+
+vi.stubGlobal('useRuntimeConfig', () => ({
+  metadataTmdb: {
+    apiKey: 'test-key',
+    baseUrl: 'https://api.themoviedb.org/3',
+    imageBaseUrl: 'https://image.tmdb.org/t/p',
+  },
+}))
+
+const { tmdbImageUrl } = await import('./client')
+
+describe('tmdbImageUrl', () => {
+  it('returns undefined when path is null', () => {
+    expect(tmdbImageUrl(null)).toBeUndefined()
+  })
+
+  it('defaults size to w500', () => {
+    expect(tmdbImageUrl('/poster.jpg')).toBe('https://image.tmdb.org/t/p/w500/poster.jpg')
+  })
+
+  it('uses a custom size when provided', () => {
+    expect(tmdbImageUrl('/poster.jpg', 'w200')).toBe('https://image.tmdb.org/t/p/w200/poster.jpg')
+  })
+
+  it('prefixes imageBaseUrl from runtime config', () => {
+    expect(tmdbImageUrl('/backdrop.jpg')).toBe(
+      'https://image.tmdb.org/t/p/w500/backdrop.jpg'
+    )
+  })
+})

package/layers/metadata/providers/themoviedb/server/utils/metadata-tmdb/client.ts

@@ -0,0 +1,60 @@
+import type { TMDBFindResponse, TMDBMovie, TMDBSearchResponse, TMDBTVShow } from './types'
+
+function getConfig() {
+  const config = useRuntimeConfig()
+  return config.metadataTmdb
+}
+
+export function tmdbImageUrl(path: string, size?: string): string
+export function tmdbImageUrl(path: string | null, size?: string): string | undefined
+export function tmdbImageUrl(path: string | null, size = 'w500'): string | undefined {
+  if (!path) return undefined
+  return `${getConfig().imageBaseUrl}/${size}${path}`
+}
+
+async function tmdbFetch<T>(path: string, params: Record<string, string> = {}): Promise<T> {
+  const { apiKey, baseUrl } = getConfig()
+
+  const url = new URL(`${baseUrl}${path}`)
+  // JWT (v4 Read Access Token) → Bearer header; hex string → legacy api_key param
+  const isJwt = apiKey.startsWith('eyJ')
+  if (!isJwt) url.searchParams.set('api_key', apiKey)
+  for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v)
+
+  try {
+    return await $fetch<T>(url.toString(), {
+      ...(isJwt && { headers: { Authorization: `Bearer ${apiKey}` } }),
+    })
+  } catch (err) {
+    throw new MetadataProviderError('tmdb', `API error: ${String(err)}`)
+  }
+}
+
+export async function searchTmdb(query: string, limit = 10): Promise<TMDBSearchResponse> {
+  const res = await tmdbFetch<TMDBSearchResponse>('/search/multi', {
+    query,
+    language: 'en-US',
+    page: '1',
+  })
+  return { ...res, results: res.results.slice(0, limit) }
+}
+
+export async function fetchTmdbMovie(id: string | number): Promise<TMDBMovie> {
+  return tmdbFetch<TMDBMovie>(`/movie/${id}`, {
+    append_to_response: 'external_ids,credits',
+    language: 'en-US',
+  })
+}
+
+export async function fetchTmdbTV(id: string | number): Promise<TMDBTVShow> {
+  return tmdbFetch<TMDBTVShow>(`/tv/${id}`, {
+    append_to_response: 'external_ids,credits',
+    language: 'en-US',
+  })
+}
+
+export async function findByImdbId(imdbId: string): Promise<TMDBFindResponse> {
+  return tmdbFetch<TMDBFindResponse>(`/find/${imdbId}`, {
+    external_source: 'imdb_id',
+  })
+}

package/layers/metadata/providers/themoviedb/server/utils/metadata-tmdb/normalise.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { tmdbImageUrl } from './client'
+import { normaliseTmdbMovie, normaliseTmdbSearchResult, normaliseTmdbTV } from './normalise'
+import type { TMDBMovie, TMDBSearchMultiResult, TMDBTVShow } from './types'
+
+// normalise.ts calls tmdbImageUrl() and getConfig() -> useRuntimeConfig() as Nitro auto-imports;
+// stub the runtime config and delegate to the real (pure, string-building) client implementation.
+vi.stubGlobal('useRuntimeConfig', () => ({
+  metadataTmdb: {
+    apiKey: 'test-key',
+    baseUrl: 'https://api.themoviedb.org/3',
+    imageBaseUrl: 'https://image.tmdb.org/t/p',
+  },
+}))
+vi.stubGlobal('tmdbImageUrl', tmdbImageUrl)
+
+function baseMovie(overrides: Partial<TMDBMovie> = {}): TMDBMovie {
+  return {
+    id: 550,
+    title: 'Fight Club',
+    overview: '',
+    poster_path: null,
+    backdrop_path: null,
+    release_date: '',
+    ...overrides,
+  }
+}
+
+function baseTV(overrides: Partial<TMDBTVShow> = {}): TMDBTVShow {
+  return {
+    id: 1399,
+    name: 'Game of Thrones',
+    overview: '',
+    poster_path: null,
+    backdrop_path: null,
+    first_air_date: '',
+    ...overrides,
+  }
+}
+
+function baseSearchResult(overrides: Partial<TMDBSearchMultiResult> = {}): TMDBSearchMultiResult {
+  return {
+    id: 1,
+    media_type: 'movie',
+    poster_path: null,
+    ...overrides,
+  }
+}
+
+describe('normaliseTmdbMovie', () => {
+  it('filters directors from credits.crew by job === "Director"', () => {
+    const record = normaliseTmdbMovie(
+      baseMovie({
+        credits: {
+          cast: [],
+          crew: [
+            { id: 1, name: 'David Fincher', job: 'Director', department: 'Directing' },
+            { id: 2, name: 'Jim Uhls', job: 'Screenplay', department: 'Writing' },
+          ],
+        },
+      })
+    )
+    expect(record.creators).toEqual([{ name: 'David Fincher', role: 'Director', providerId: '1' }])
+  })
+
+  it('omits creators entirely when there are no directors', () => {
+    const record = normaliseTmdbMovie(baseMovie())
+    expect('creators' in record).toBe(false)
+  })
+
+  it('omits description, publisher, publishedAt and coverUrl when source fields are absent', () => {
+    const record = normaliseTmdbMovie(baseMovie())
+    expect('description' in record).toBe(false)
+    expect('publisher' in record).toBe(false)
+    expect('publishedAt' in record).toBe(false)
+    expect('coverUrl' in record).toBe(false)
+  })
+
+  it('includes description, publisher, publishedAt and coverUrl when source fields are present', () => {
+    const record = normaliseTmdbMovie(
+      baseMovie({
+        overview: 'A depressed man forms an underground fight club.',
+        production_companies: [{ id: 1, name: 'Fox 2000 Pictures' }],
+        release_date: '1999-10-15',
+        poster_path: '/poster.jpg',
+      })
+    )
+    expect(record.description).toBe('A depressed man forms an underground fight club.')
+    expect(record.publisher).toBe('Fox 2000 Pictures')
+    expect(record.publishedAt).toBe('1999-10-15')
+    expect(record.coverUrl).toBe('https://image.tmdb.org/t/p/w500/poster.jpg')
+  })
+
+  it('includes imdbId in identifiers only when external_ids.imdb_id is present', () => {
+    const withImdb = normaliseTmdbMovie(baseMovie({ external_ids: { imdb_id: 'tt0137523' } }))
+    expect(withImdb.identifiers).toEqual({ tmdbId: '550', imdbId: 'tt0137523' })
+
+    const withoutImdb = normaliseTmdbMovie(baseMovie())
+    expect(withoutImdb.identifiers).toEqual({ tmdbId: '550' })
+    expect('imdbId' in (withoutImdb.identifiers as object)).toBe(false)
+  })
+
+  it('stamps lastSyncedAt as a string', () => {
+    expect(normaliseTmdbMovie(baseMovie()).lastSyncedAt).toEqual(expect.any(String))
+  })
+})
+
+describe('normaliseTmdbTV', () => {
+  it('maps created_by to Creator-role creators', () => {
+    const record = normaliseTmdbTV(baseTV({ created_by: [{ id: 9, name: 'David Benioff' }] }))
+    expect(record.creators).toEqual([{ name: 'David Benioff', role: 'Creator', providerId: '9' }])
+  })
+
+  it('omits creators when created_by is absent', () => {
+    const record = normaliseTmdbTV(baseTV())
+    expect('creators' in record).toBe(false)
+  })
+
+  it('takes publisher from the first network', () => {
+    const record = normaliseTmdbTV(baseTV({ networks: [{ id: 1, name: 'HBO' }] }))
+    expect(record.publisher).toBe('HBO')
+  })
+
+  it('includes imdbId in identifiers only when external_ids.imdb_id is present', () => {
+    const record = normaliseTmdbTV(baseTV({ external_ids: { imdb_id: 'tt0944947' } }))
+    expect(record.identifiers).toEqual({ tmdbId: '1399', imdbId: 'tt0944947' })
+  })
+})
+
+describe('normaliseTmdbSearchResult', () => {
+  it('uses title/release_date and the movie url path for movie results', () => {
+    const record = normaliseTmdbSearchResult(
+      baseSearchResult({ media_type: 'movie', title: 'Dune', release_date: '2021-10-22' })
+    )
+    expect(record.title).toBe('Dune')
+    expect(record.mediaType).toBe('movie')
+    expect(record.publishedAt).toBe('2021-10-22')
+    expect(record.sourceUrl).toBe('https://www.themoviedb.org/movie/1')
+    expect(record.id).toBe('tmdb:movie:1')
+  })
+
+  it('uses name/first_air_date, tv url path and mediaType tv-show for tv results', () => {
+    const record = normaliseTmdbSearchResult(
+      baseSearchResult({
+        media_type: 'tv',
+        name: 'Dune: Prophecy',
+        first_air_date: '2024-11-17',
+      })
+    )
+    expect(record.title).toBe('Dune: Prophecy')
+    expect(record.mediaType).toBe('tv-show')
+    expect(record.publishedAt).toBe('2024-11-17')
+    expect(record.sourceUrl).toBe('https://www.themoviedb.org/tv/1')
+    expect(record.id).toBe('tmdb:tv:1')
+  })
+
+  it('defaults title to empty string when the branch-specific field is missing', () => {
+    const record = normaliseTmdbSearchResult(baseSearchResult({ media_type: 'movie' }))
+    expect(record.title).toBe('')
+  })
+})

package/layers/metadata/providers/themoviedb/server/utils/metadata-tmdb/normalise.ts

@@ -0,0 +1,83 @@
+import type { MetadataCreator, MetadataRecord } from '#layers/metadata/shared/types'
+
+import type { TMDBMovie, TMDBSearchMultiResult, TMDBTVShow } from './types'
+
+// fallow-ignore-next-line complexity
+export function normaliseTmdbMovie(movie: TMDBMovie): MetadataRecord {
+  const directors: MetadataCreator[] = (movie.credits?.crew ?? [])
+    .filter((c) => c.job === 'Director')
+    .map((c) => ({ name: c.name, role: 'Director', providerId: String(c.id) }))
+
+  return {
+    id: `tmdb:movie:${movie.id}`,
+    provider: 'tmdb',
+    providerId: String(movie.id),
+    mediaType: 'movie',
+    title: movie.title,
+    ...(movie.overview && { description: movie.overview }),
+    ...(directors.length && { creators: directors }),
+    ...(movie.production_companies?.[0]?.name && {
+      publisher: movie.production_companies[0].name,
+    }),
+    ...(movie.release_date && { publishedAt: movie.release_date }),
+    ...(movie.poster_path && { coverUrl: tmdbImageUrl(movie.poster_path) }),
+    identifiers: {
+      tmdbId: String(movie.id),
+      ...(movie.external_ids?.imdb_id && { imdbId: movie.external_ids.imdb_id }),
+    },
+    sourceUrl: `https://www.themoviedb.org/movie/${movie.id}`,
+    raw: movie,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}
+
+// fallow-ignore-next-line complexity
+export function normaliseTmdbTV(show: TMDBTVShow): MetadataRecord {
+  const creators: MetadataCreator[] = (show.created_by ?? []).map((c) => ({
+    name: c.name,
+    role: 'Creator',
+    providerId: String(c.id),
+  }))
+
+  return {
+    id: `tmdb:tv:${show.id}`,
+    provider: 'tmdb',
+    providerId: String(show.id),
+    mediaType: 'tv-show',
+    title: show.name,
+    ...(show.overview && { description: show.overview }),
+    ...(creators.length && { creators }),
+    ...(show.networks?.[0]?.name && { publisher: show.networks[0].name }),
+    ...(show.first_air_date && { publishedAt: show.first_air_date }),
+    ...(show.poster_path && { coverUrl: tmdbImageUrl(show.poster_path) }),
+    identifiers: {
+      tmdbId: String(show.id),
+      ...(show.external_ids?.imdb_id && { imdbId: show.external_ids.imdb_id }),
+    },
+    sourceUrl: `https://www.themoviedb.org/tv/${show.id}`,
+    raw: show,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}
+
+export function normaliseTmdbSearchResult(result: TMDBSearchMultiResult): MetadataRecord {
+  const isMovie = result.media_type === 'movie'
+  const title = (isMovie ? result.title : result.name) ?? ''
+  const date = isMovie ? result.release_date : result.first_air_date
+  const type = isMovie ? 'movie' : 'tv'
+
+  return {
+    id: `tmdb:${type}:${result.id}`,
+    provider: 'tmdb',
+    providerId: String(result.id),
+    mediaType: isMovie ? 'movie' : 'tv-show',
+    title,
+    ...(result.overview && { description: result.overview }),
+    ...(date && { publishedAt: date }),
+    ...(result.poster_path && { coverUrl: tmdbImageUrl(result.poster_path) }),
+    identifiers: { tmdbId: String(result.id) },
+    sourceUrl: `https://www.themoviedb.org/${type}/${result.id}`,
+    raw: result,
+    lastSyncedAt: new Date().toISOString(),
+  }
+}

package/layers/metadata/providers/themoviedb/server/utils/metadata-tmdb/provider.ts

@@ -0,0 +1,37 @@
+import type { MetadataProvider } from '#layers/metadata/shared/types'
+
+export const tmdbProvider: MetadataProvider = {
+  id: 'tmdb',
+  label: 'The Movie Database',
+  mediaTypes: ['movie', 'tv-show'],
+
+  async search({ query, mediaType, limit = 10 }) {
+    const res = await searchTmdb(query, limit)
+    return res.results
+      .filter((r) => {
+        if (r.media_type === 'person') return false
+        if (mediaType === 'movie') return r.media_type === 'movie'
+        if (mediaType === 'tv-show') return r.media_type === 'tv'
+        return true
+      })
+      .map(normaliseTmdbSearchResult)
+  },
+
+  async lookup({ providerId, resourceType = 'movie' }) {
+    // Accept IMDB tt-prefixed IDs — resolve via TMDB's /find endpoint
+    if (providerId.startsWith('tt')) {
+      const found = await findByImdbId(providerId)
+      const movie = found.movie_results[0]
+      const tv = found.tv_results[0]
+      if (movie) return normaliseTmdbMovie(await fetchTmdbMovie(movie.id))
+      if (tv) return normaliseTmdbTV(await fetchTmdbTV(tv.id))
+      return null
+    }
+    if (resourceType === 'tv-show') return normaliseTmdbTV(await fetchTmdbTV(providerId))
+    return normaliseTmdbMovie(await fetchTmdbMovie(providerId))
+  },
+
+  async sync(input) {
+    return (await tmdbProvider.lookup!(input))!
+  },
+}

package/layers/metadata/providers/themoviedb/server/utils/metadata-tmdb/types.ts

@@ -0,0 +1,81 @@
+export type TMDBExternalIds = {
+  imdb_id?: string
+  tvdb_id?: number
+}
+
+export type TMDBCrewMember = {
+  id: number
+  name: string
+  job: string
+  department: string
+}
+
+export type TMDBCastMember = {
+  id: number
+  name: string
+  character: string
+  order: number
+}
+
+export type TMDBCredits = {
+  cast: TMDBCastMember[]
+  crew: TMDBCrewMember[]
+}
+
+export type TMDBCreatedBy = {
+  id: number
+  name: string
+}
+
+export type TMDBMovie = {
+  id: number
+  title: string
+  overview: string
+  poster_path: string | null
+  backdrop_path: string | null
+  release_date: string
+  runtime?: number
+  genres?: Array<{ id: number; name: string }>
+  production_companies?: Array<{ id: number; name: string }>
+  status?: string
+  external_ids?: TMDBExternalIds
+  credits?: TMDBCredits
+}
+
+export type TMDBTVShow = {
+  id: number
+  name: string
+  overview: string
+  poster_path: string | null
+  backdrop_path: string | null
+  first_air_date: string
+  number_of_seasons?: number
+  genres?: Array<{ id: number; name: string }>
+  networks?: Array<{ id: number; name: string }>
+  created_by?: TMDBCreatedBy[]
+  status?: string
+  external_ids?: TMDBExternalIds
+  credits?: TMDBCredits
+}
+
+export type TMDBSearchMultiResult = {
+  id: number
+  media_type: 'movie' | 'tv' | 'person'
+  title?: string
+  name?: string
+  overview?: string
+  poster_path: string | null
+  release_date?: string
+  first_air_date?: string
+}
+
+export type TMDBSearchResponse = {
+  results: TMDBSearchMultiResult[]
+  total_results: number
+  page: number
+}
+
+export type TMDBFindResponse = {
+  movie_results: TMDBMovie[]
+  tv_results: TMDBTVShow[]
+}

package/layers/metadata/providers/themoviedb/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../../../apps/playground/tsconfig.json",
+  "compilerOptions": { "strict": true },
+  "exclude": ["node_modules"]
+}

package/layers/metadata/server/api/metadata/lookup.get.ts

@@ -13,13 +13,18 @@ export default defineEventHandler(async (event) => {
   }
 
   const provider = getProvider(providerName)
-  if (!provider) throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
+  if (!provider)
+    throw createError({ statusCode: 404, message: `Provider '${providerName}' not registered` })
 
   const cacheKey = makeCacheKey('metadata', providerName, resourceType ?? 'item', providerId)
   const cached = await getCacheRecord(cacheKey)
   if (cached) return cached.normalised
 
-  const result = await provider.lookup({ provider: providerName, providerId, resourceType })
+  const result = await provider.lookup({
+    provider: providerName,
+    providerId,
+    ...(resourceType && { resourceType }),
+  })
   if (!result) throw createError({ statusCode: 404, message: 'Not found' })
 
   const now = new Date().toISOString()

package/layers/metadata/server/api/metadata/search.get.ts

@@ -9,9 +9,14 @@ export default defineEventHandler(async (event) => {
 
   const mediaType = query.mediaType as MetadataMediaType | undefined
   const providers = query.providers
-    ? String(query.providers).split(',').filter(Boolean) as MetadataProviderId[]
+    ? (String(query.providers).split(',').filter(Boolean) as MetadataProviderId[])
     : undefined
   const limit = query.limit ? Number(query.limit) : 10
 
-  return searchMetadata({ query: q, mediaType, providers, limit })
+  return searchMetadata({
+    query: q,
+    ...(mediaType && { mediaType }),
+    ...(providers && { providers }),
+    limit,
+  })
 })