Initial Aurora Core 0.1 implementation

Production-grade media metadata backend per docs/aurora-core-spec.md:
Aurora-owned UUIDv7 identity system, normalized movie/TV/people/credits
schema, provider abstraction with a TMDb adapter, an idempotent async
ingestion pipeline (normalize -> match -> upsert -> provenance), a
Postgres FTS/trigram search layer, a stateless FastAPI v1 API with
Redis caching/rate-limiting, arq workers, dev/prod Docker Compose
topologies, unit + integration + load tests, CI, and architecture/
database/API/ERD documentation.

Co-Authored-By: Claude Sonnet 5 <[email protected]>

app/services/movie_service.py

@@ -0,0 +1,147 @@
+"""Assembles Movie API responses from repository data."""
+
+from __future__ import annotations
+
+import uuid
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.ids import aurora_id, parse_aurora_id
+from app.models.enums import ArtworkType
+from app.repositories import movie_repository, polymorphic
+from app.schemas.common import CollectionBriefOut, CompanyBriefOut, GenreOut, KeywordOut
+from app.schemas.movie import (
+    MovieCreditsOut,
+    MovieDetailOut,
+    MovieImagesOut,
+    MovieSummaryOut,
+    MovieVideosOut,
+)
+from app.services.common import primary_artwork_path, split_credits, to_images_out, to_video_out
+
+
+class MovieNotFoundError(Exception):
+    pass
+
+
+async def _resolve_movie_id(movie_aurora_id: str) -> uuid.UUID:
+    try:
+        return uuid.UUID(parse_aurora_id(movie_aurora_id, expected_type="movie"))
+    except ValueError as exc:
+        raise MovieNotFoundError(str(exc)) from exc
+
+
+async def get_movie_detail(session: AsyncSession, movie_aurora_id: str) -> MovieDetailOut:
+    movie_id = await _resolve_movie_id(movie_aurora_id)
+    movie = await movie_repository.get_movie_by_id(session, movie_id)
+    if movie is None:
+        raise MovieNotFoundError(movie_aurora_id)
+
+    genres = await movie_repository.get_movie_genres(session, movie_id)
+    keywords = await movie_repository.get_movie_keywords(session, movie_id)
+    companies = await movie_repository.get_movie_companies(session, movie_id)
+    credits_ = await polymorphic.get_credits(session, "movie", movie_id)
+    artwork = await polymorphic.get_artwork(session, "movie", movie_id)
+    videos = await polymorphic.get_videos(session, "movie", movie_id)
+    external_ids = await polymorphic.get_external_ids(session, "movie", movie_id)
+
+    cast, crew = split_credits(credits_)
+
+    return MovieDetailOut(
+        id=aurora_id("movie", str(movie.id)),
+        title=movie.title,
+        original_title=movie.original_title,
+        overview=movie.overview,
+        tagline=movie.tagline,
+        status=movie.status.value,
+        original_language=movie.original_language_code,
+        release_date=movie.primary_release_date,
+        runtime=movie.runtime_minutes,
+        budget=movie.budget,
+        revenue=movie.revenue,
+        popularity=movie.popularity,
+        vote_average=movie.vote_average,
+        vote_count=movie.vote_count,
+        adult=movie.adult,
+        genres=[GenreOut(id=aurora_id("genre", str(g.id)), name=g.name) for g in genres],
+        keywords=[KeywordOut(id=aurora_id("keyword", str(k.id)), name=k.name) for k in keywords],
+        cast=cast,
+        crew=crew,
+        companies=[
+            CompanyBriefOut(
+                id=aurora_id("company", str(company.id)),
+                name=company.name,
+                company_type=company.company_type.value,
+                logo_path=None,
+            )
+            for company, _role in companies
+        ],
+        collection=(
+            CollectionBriefOut(
+                id=aurora_id("collection", str(movie.collection.id)), name=movie.collection.name
+            )
+            if movie.collection
+            else None
+        ),
+        images=to_images_out(artwork),
+        videos=[to_video_out(v) for v in videos],
+        external_ids=external_ids,
+        created_at=movie.created_at,
+        updated_at=movie.updated_at,
+    )
+
+
+async def get_movie_credits(session: AsyncSession, movie_aurora_id: str) -> MovieCreditsOut:
+    movie_id = await _resolve_movie_id(movie_aurora_id)
+    movie = await movie_repository.get_movie_by_id(session, movie_id)
+    if movie is None:
+        raise MovieNotFoundError(movie_aurora_id)
+    credits_ = await polymorphic.get_credits(session, "movie", movie_id)
+    cast, crew = split_credits(credits_)
+    return MovieCreditsOut(id=aurora_id("movie", str(movie.id)), cast=cast, crew=crew)
+
+
+async def get_movie_images(session: AsyncSession, movie_aurora_id: str) -> MovieImagesOut:
+    movie_id = await _resolve_movie_id(movie_aurora_id)
+    movie = await movie_repository.get_movie_by_id(session, movie_id)
+    if movie is None:
+        raise MovieNotFoundError(movie_aurora_id)
+    artwork = await polymorphic.get_artwork(session, "movie", movie_id)
+    return MovieImagesOut(id=aurora_id("movie", str(movie.id)), images=to_images_out(artwork))
+
+
+async def get_movie_videos(session: AsyncSession, movie_aurora_id: str) -> MovieVideosOut:
+    movie_id = await _resolve_movie_id(movie_aurora_id)
+    movie = await movie_repository.get_movie_by_id(session, movie_id)
+    if movie is None:
+        raise MovieNotFoundError(movie_aurora_id)
+    videos = await polymorphic.get_videos(session, "movie", movie_id)
+    return MovieVideosOut(id=aurora_id("movie", str(movie.id)), videos=[to_video_out(v) for v in videos])
+
+
+async def build_movie_summary(session: AsyncSession, movie_id: uuid.UUID) -> MovieSummaryOut | None:
+    movie = await movie_repository.get_movie_by_id(session, movie_id)
+    if movie is None:
+        return None
+    posters = await polymorphic.get_artwork(session, "movie", movie_id, ArtworkType.POSTER)
+    return MovieSummaryOut(
+        id=aurora_id("movie", str(movie.id)),
+        title=movie.title,
+        original_title=movie.original_title,
+        overview=movie.overview,
+        release_date=movie.primary_release_date,
+        poster_path=primary_artwork_path(posters, ArtworkType.POSTER),
+        popularity=movie.popularity,
+        vote_average=movie.vote_average,
+    )
+
+
+async def build_movie_summaries(
+    session: AsyncSession, movie_ids: list[uuid.UUID]
+) -> list[MovieSummaryOut]:
+    out: list[MovieSummaryOut] = []
+    for movie_id in movie_ids:
+        summary = await build_movie_summary(session, movie_id)
+        if summary is not None:
+            out.append(summary)
+    return out