feat(rss): implement RSS feed adapter and integrate with application state

Co-authored-by: Copilot <copilot@github.com>

.cargo/config.toml

@@ -1,5 +1,2 @@
 [env]
 SQLX_OFFLINE = "true"
-
-[registries.gitea]
-index = "sparse+https://git.gabrielkaszewski.dev/api/packages/GKaszewski/cargo/"

.dockerignore

@@ -1,13 +0,0 @@
-target/
-.git/
-.env
-*.db
-*.db-shm
-*.db-wal
-# .cargo and .sqlx are needed at build time (SQLX_OFFLINE mode)
-docs/
-dev.db
-spa/node_modules/
-spa/dist/
-spa/.env
-spa/.env.local

.env.example

@@ -1,55 +1,11 @@
-# ── Required ──────────────────────────────────────────────────
-
-# Database (SQLite — file auto-created on first run)
-DATABASE_URL=sqlite:///data/movies.db
-
-# Authentication
-JWT_SECRET=change-me-to-a-random-string
-
-# Movie metadata — one of these is required (TMDB preferred)
-# TMDB_API_KEY=your-tmdb-key
-OMDB_API_KEY=your-omdb-key
-
-# ── Recommended ──────────────────────────────────────────────
-
-# Public URL (used for ActivityPub federation and canonical links)
-BASE_URL=https://yourdomain.example.com
-
-# Enable sign-ups (default: false — set true so you can register)
+DATABASE_URL=sqlite:./dev.db
+PORT=3000
+JWT_SECRET=
+JWT_TTL_SECONDS=
 ALLOW_REGISTRATION=true
-
-# ── Image Storage (defaults to local filesystem) ─────────────
-
-# IMAGE_STORAGE_BACKEND=local    # default
-# IMAGE_STORAGE_PATH=./images    # default
-
-# S3-compatible alternative (MinIO, AWS S3, etc.):
-# IMAGE_STORAGE_BACKEND=s3
-# MINIO_ENDPOINT=http://localhost:9000
-# MINIO_BUCKET=posters
-# MINIO_REGION=minio
-# MINIO_ACCESS_KEY_ID=minioadmin
-# MINIO_SECRET_ACCESS_KEY=minioadmin
-
-# ── Optional ─────────────────────────────────────────────────
-
-# TMDb enrichment (cast, crew, genres — separate from search metadata above)
-# TMDB_API_KEY=your-tmdb-key
-
-# Image conversion (converts uploaded posters to AVIF or WebP)
-# IMAGE_CONVERSION_ENABLED=false
-# IMAGE_CONVERSION_FORMAT=avif
-
-# Server
-# HOST=0.0.0.0
-# PORT=3000
-# RATE_LIMIT=60
-# SECURE_COOKIES=true
-# RUST_LOG=presentation=info,tower_http=info,worker=info
-
-# CORS (for SPA development only)
-# CORS_ORIGINS=http://localhost:5173
-
-# Event bus — "db" (default, uses same database) or "nats"
-# EVENT_BUS_BACKEND=db
-# NATS_URL=nats://localhost:4222
+OMDB_API_KEY=
+POSTER_FETCH_TIMEOUT_SECONDS=30
+MINIO_ENDPOINT=
+MINIO_ACCESS_KEY_ID=
+MINIO_SECRET_ACCESS_KEY=
+MINIO_BUCKET=

.gitea/workflows/ci.yml

@@ -1,42 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: ["**"]
-  pull_request:
-
-env:
-  CARGO_TERM_COLOR: always
-  RUST_BACKTRACE: 1
-
-jobs:
-  ci:
-    name: Check / Test
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt, clippy
-
-      - name: Cache cargo
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-cargo-
-
-      - name: fmt
-        run: cargo fmt --all -- --check
-
-      - name: clippy
-        run: cargo clippy --all-targets -- -D warnings
-
-      - name: test
-        run: cargo test

.github/workflows/ci.yml

@@ -1,81 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: ["**"]
-  pull_request:
-
-env:
-  CARGO_TERM_COLOR: always
-  RUST_BACKTRACE: 1
-
-jobs:
-  ci:
-    name: Check / Test
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rustfmt, clippy
-
-      - name: Cache cargo
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-cargo-
-
-      - name: fmt
-        run: cargo fmt --all -- --check
-
-      - name: clippy
-        run: cargo clippy --all-targets -- -D warnings
-
-      - name: test
-        run: cargo test
-
-  docker:
-    name: Build & Push Docker Image
-    runs-on: ubuntu-latest
-    needs: ci
-    if: github.ref == 'refs/heads/master' || startsWith(github.ref, 'refs/tags/v')
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Log in to GHCR
-        uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GHCR_TOKEN || github.token }}
-
-      - name: Docker metadata
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ghcr.io/${{ github.repository }}
-          tags: |
-            type=raw,value=latest,enable={{is_default_branch}}
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=sha,prefix=
-
-      - name: Build and push
-        uses: docker/build-push-action@v6
-        with:
-          context: .
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          build-args: FEATURES=sqlite,sqlite-federation

.gitignore

@@ -8,13 +8,5 @@
 .env.prod
 
 *.db
-*db-shm
-*db-wal
 
 .worktrees/
-.superpowers/
-docs/
-!docs/adr/
-
-imgs/
-.sqlx/

.sqlx/query-01a08873b7fa815ad98a56a0902b60414cfcdc2c7a8570351320c4bc425347c6.json

@@ -0,0 +1,92 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT m.id, m.external_metadata_id, m.title, m.release_year, m.director, m.poster_path,\n                        r.id AS review_id, r.movie_id, r.user_id, r.rating, r.comment, r.watched_at, r.created_at\n                 FROM reviews r\n                 INNER JOIN movies m ON m.id = r.movie_id\n                 WHERE r.movie_id = ?\n                 ORDER BY r.watched_at ASC\n                 LIMIT ? OFFSET ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "external_metadata_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "title",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "release_year",
+        "ordinal": 3,
+        "type_info": "Integer"
+      },
+      {
+        "name": "director",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "poster_path",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "review_id",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "movie_id",
+        "ordinal": 7,
+        "type_info": "Text"
+      },
+      {
+        "name": "user_id",
+        "ordinal": 8,
+        "type_info": "Text"
+      },
+      {
+        "name": "rating",
+        "ordinal": 9,
+        "type_info": "Integer"
+      },
+      {
+        "name": "comment",
+        "ordinal": 10,
+        "type_info": "Text"
+      },
+      {
+        "name": "watched_at",
+        "ordinal": 11,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 12,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      true,
+      true,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "01a08873b7fa815ad98a56a0902b60414cfcdc2c7a8570351320c4bc425347c6"
+}

.sqlx/query-026e2afeb573707cb360fcdab8f6137aabfaf603b5ed57b98ac2888b4a0389ff.json

@@ -0,0 +1,92 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT m.id, m.external_metadata_id, m.title, m.release_year, m.director, m.poster_path,\n                        r.id AS review_id, r.movie_id, r.user_id, r.rating, r.comment, r.watched_at, r.created_at\n                 FROM reviews r\n                 INNER JOIN movies m ON m.id = r.movie_id\n                 ORDER BY r.watched_at DESC\n                 LIMIT ? OFFSET ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "external_metadata_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "title",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "release_year",
+        "ordinal": 3,
+        "type_info": "Integer"
+      },
+      {
+        "name": "director",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "poster_path",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "review_id",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "movie_id",
+        "ordinal": 7,
+        "type_info": "Text"
+      },
+      {
+        "name": "user_id",
+        "ordinal": 8,
+        "type_info": "Text"
+      },
+      {
+        "name": "rating",
+        "ordinal": 9,
+        "type_info": "Integer"
+      },
+      {
+        "name": "comment",
+        "ordinal": 10,
+        "type_info": "Text"
+      },
+      {
+        "name": "watched_at",
+        "ordinal": 11,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 12,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      true,
+      true,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "026e2afeb573707cb360fcdab8f6137aabfaf603b5ed57b98ac2888b4a0389ff"
+}

.sqlx/query-0963b9661182e139cd760bbabb0d6ea3a301a2a3adbdfdda4a88f333a1144c77.json

@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT COUNT(*) FROM reviews",
+  "describe": {
+    "columns": [
+      {
+        "name": "COUNT(*)",
+        "ordinal": 0,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "0963b9661182e139cd760bbabb0d6ea3a301a2a3adbdfdda4a88f333a1144c77"
+}

.sqlx/query-167481bb1692cc81531d9a5cd85425e43d09a6df97c335ac347f7cfd61acd171.json

@@ -0,0 +1,32 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT id, email, password_hash FROM users WHERE email = ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "email",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "password_hash",
+        "ordinal": 2,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "167481bb1692cc81531d9a5cd85425e43d09a6df97c335ac347f7cfd61acd171"
+}

.sqlx/query-18de90feb13b9f467f06d0ce25332d9ea7eabc99d9f1a44694e5d10762606f82.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "INSERT OR IGNORE INTO users (id, email, password_hash, created_at) VALUES (?, ?, ?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 4
+    },
+    "nullable": []
+  },
+  "hash": "18de90feb13b9f467f06d0ce25332d9ea7eabc99d9f1a44694e5d10762606f82"
+}

.sqlx/query-3047579c6ed13ce87aad9b9ce6300c02f0df3516979518976e13f9d9abc6a403.json

@@ -0,0 +1,50 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT id, external_metadata_id, title, release_year, director, poster_path\n             FROM movies WHERE title = ? AND release_year = ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "external_metadata_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "title",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "release_year",
+        "ordinal": 3,
+        "type_info": "Integer"
+      },
+      {
+        "name": "director",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "poster_path",
+        "ordinal": 5,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      true,
+      true
+    ]
+  },
+  "hash": "3047579c6ed13ce87aad9b9ce6300c02f0df3516979518976e13f9d9abc6a403"
+}

.sqlx/query-33d0dae7d16b0635c1c7eb5afd10824bb55af7cc7a854f590d326622863759d1.json

@@ -0,0 +1,50 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT id, external_metadata_id, title, release_year, director, poster_path\n             FROM movies WHERE id = ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "external_metadata_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "title",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "release_year",
+        "ordinal": 3,
+        "type_info": "Integer"
+      },
+      {
+        "name": "director",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "poster_path",
+        "ordinal": 5,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      true,
+      true
+    ]
+  },
+  "hash": "33d0dae7d16b0635c1c7eb5afd10824bb55af7cc7a854f590d326622863759d1"
+}

.sqlx/query-47f7cf95ce3450635b643ab710cadba96f40319140834d510bc5207b2552e055.json

@@ -0,0 +1,92 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT m.id, m.external_metadata_id, m.title, m.release_year, m.director, m.poster_path,\n                        r.id AS review_id, r.movie_id, r.user_id, r.rating, r.comment, r.watched_at, r.created_at\n                 FROM reviews r\n                 INNER JOIN movies m ON m.id = r.movie_id\n                 WHERE r.movie_id = ?\n                 ORDER BY r.watched_at DESC\n                 LIMIT ? OFFSET ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "external_metadata_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "title",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "release_year",
+        "ordinal": 3,
+        "type_info": "Integer"
+      },
+      {
+        "name": "director",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "poster_path",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "review_id",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "movie_id",
+        "ordinal": 7,
+        "type_info": "Text"
+      },
+      {
+        "name": "user_id",
+        "ordinal": 8,
+        "type_info": "Text"
+      },
+      {
+        "name": "rating",
+        "ordinal": 9,
+        "type_info": "Integer"
+      },
+      {
+        "name": "comment",
+        "ordinal": 10,
+        "type_info": "Text"
+      },
+      {
+        "name": "watched_at",
+        "ordinal": 11,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 12,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      true,
+      true,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "47f7cf95ce3450635b643ab710cadba96f40319140834d510bc5207b2552e055"
+}

.sqlx/query-4b3074b532342c6356ee0e8e4d8c4a830f016234bb690e1f6240f02824d6d84f.json

@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT COUNT(*) FROM reviews WHERE movie_id = ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "COUNT(*)",
+        "ordinal": 0,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "4b3074b532342c6356ee0e8e4d8c4a830f016234bb690e1f6240f02824d6d84f"
+}

.sqlx/query-630e092fcd33bc312befef352a98225e6e18e6079644b949258a39bf4b0fe3e5.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "INSERT INTO reviews (id, movie_id, user_id, rating, comment, watched_at, created_at)\n             VALUES (?, ?, ?, ?, ?, ?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 7
+    },
+    "nullable": []
+  },
+  "hash": "630e092fcd33bc312befef352a98225e6e18e6079644b949258a39bf4b0fe3e5"
+}

.sqlx/query-7bc4aebcb94547976d3d7e063e4e908fc22b977b3cbf063ee93ffe4648c42011.json

@@ -0,0 +1,50 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT id, external_metadata_id, title, release_year, director, poster_path\n             FROM movies WHERE external_metadata_id = ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "external_metadata_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "title",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "release_year",
+        "ordinal": 3,
+        "type_info": "Integer"
+      },
+      {
+        "name": "director",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "poster_path",
+        "ordinal": 5,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      true,
+      true
+    ]
+  },
+  "hash": "7bc4aebcb94547976d3d7e063e4e908fc22b977b3cbf063ee93ffe4648c42011"
+}

.sqlx/query-7d7e23355ee0e442f2aa27e898dcfa40bdc4b09391afe04325f076157d9d84aa.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "INSERT INTO movies (id, external_metadata_id, title, release_year, director, poster_path)\n             VALUES (?, ?, ?, ?, ?, ?)\n             ON CONFLICT(id) DO UPDATE SET\n                 external_metadata_id = excluded.external_metadata_id,\n                 title                = excluded.title,\n                 release_year         = excluded.release_year,\n                 director             = excluded.director,\n                 poster_path          = excluded.poster_path",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 6
+    },
+    "nullable": []
+  },
+  "hash": "7d7e23355ee0e442f2aa27e898dcfa40bdc4b09391afe04325f076157d9d84aa"
+}

.sqlx/query-af883f8b78f185077e2d3dcfaa0a6e62fbdfbf00c97c9b33b699dc631476181d.json

@@ -0,0 +1,56 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT id, movie_id, user_id, rating, comment, watched_at, created_at\n             FROM reviews WHERE movie_id = ? ORDER BY watched_at ASC",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "movie_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "user_id",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "rating",
+        "ordinal": 3,
+        "type_info": "Integer"
+      },
+      {
+        "name": "comment",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "watched_at",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 6,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "af883f8b78f185077e2d3dcfaa0a6e62fbdfbf00c97c9b33b699dc631476181d"
+}

.sqlx/query-affe1eb261283c09d4b1ce6e684681755f079a044ffec8ff2bd79cfd8efe16b8.json

@@ -0,0 +1,92 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT m.id, m.external_metadata_id, m.title, m.release_year, m.director, m.poster_path,\n                        r.id AS review_id, r.movie_id, r.user_id, r.rating, r.comment, r.watched_at, r.created_at\n                 FROM reviews r\n                 INNER JOIN movies m ON m.id = r.movie_id\n                 ORDER BY r.watched_at ASC\n                 LIMIT ? OFFSET ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "external_metadata_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "title",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "release_year",
+        "ordinal": 3,
+        "type_info": "Integer"
+      },
+      {
+        "name": "director",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "poster_path",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "review_id",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "movie_id",
+        "ordinal": 7,
+        "type_info": "Text"
+      },
+      {
+        "name": "user_id",
+        "ordinal": 8,
+        "type_info": "Text"
+      },
+      {
+        "name": "rating",
+        "ordinal": 9,
+        "type_info": "Integer"
+      },
+      {
+        "name": "comment",
+        "ordinal": 10,
+        "type_info": "Text"
+      },
+      {
+        "name": "watched_at",
+        "ordinal": 11,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 12,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      false,
+      true,
+      true,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "affe1eb261283c09d4b1ce6e684681755f079a044ffec8ff2bd79cfd8efe16b8"
+}

CONTEXT.md

@@ -1,65 +0,0 @@
-# Movies Diary
-
-A personal movie diary that tracks what you watch, when, and what you thought about it. Supports federation via ActivityPub.
-
-## Language
-
-**Movie**:
-A film in the catalog, identified by title and release year. Optionally linked to an external metadata provider (e.g. TMDb) for enrichment. One Movie record is shared across all users — "Blade Runner (1982)" exists once regardless of how many people review it.
-_Avoid_: Film entry, title record
-
-**Person**:
-Someone involved in making a movie — actor, director, crew member. Sourced from an external metadata provider and enriched with biographical data. Linked to Movies through cast/crew credits. Not a User — Person is movie-industry people only.
-_Avoid_: Celebrity, artist, talent
-
-**Review**:
-A single record of watching a movie — captures the rating, optional comment, when it was watched, and how it was watched.
-_Avoid_: Diary entry, watch, log entry
-
-**Rating**:
-A 1–5 whole-star score given to a movie in a Review. No half-stars, no zero.
-_Avoid_: Score, grade, stars (as a noun for the value itself)
-
-**WatchMedium**:
-The channel through which a movie was watched: Cinema, Streaming, TV, PhysicalMedia, Download, MediaServer, or Other.
-_Avoid_: Source, format, venue, platform
-
-**Watchlist**:
-A user's collection of movies they intend to watch. Each item is a simple bookmark — no priority or ordering. A movie leaves the watchlist implicitly when reviewed, or explicitly when removed.
-_Avoid_: Queue, backlog, to-watch list
-
-**Goal**:
-A yearly target a user sets — e.g. "watch 50 movies in 2025." Progress is tracked automatically as reviews are logged. Currently only supports movie-count goals, but the model is designed for other goal types in the future.
-_Avoid_: Challenge, resolution, target
-
-**WrapUp**:
-A generated summary report of viewing activity over a date range — statistics, trends, highlights, top directors/actors/genres. Can be personal (one user) or global (all users). Generated asynchronously. Shown to users as "Year in Review."
-_Avoid_: Stats page, recap, summary
-
-**User**:
-A registered account with a username, email, and profile (display name, bio, avatar, banner). Can be Standard or Admin.
-_Avoid_: Account, member, profile (as a synonym for the whole User)
-
-**SocialIdentity**:
-The uniform identifier for anyone involved in a social interaction — either a local User or a remote federated actor. Social commands and queries operate on SocialIdentity so the domain never branches on local vs remote.
-_Avoid_: Actor, participant, social user
-
-**Follow**:
-A social relationship where one user subscribes to another's activity. Always requires acceptance by the target user. Works identically for local and federated (ActivityPub) users. Once accepted, the followed user's reviews appear in the follower's Feed.
-_Avoid_: Subscribe, connect, friend
-
-**Feed**:
-A chronological timeline of reviews from users you follow — both local and federated. The main social surface of the app.
-_Avoid_: Timeline, activity stream, home
-
-**WatchEvent**:
-An automatically detected viewing reported by an external source — currently Jellyfin and Plex via webhook, but conceptually any system that can report "this person watched this movie" (e.g. a cinema ticket service). Arrives in a pending state; the user confirms it (creating a Review) or dismisses it.
-_Avoid_: Playback event, webhook event, auto-import
-
-**Import**:
-Bulk ingestion of reviews from an external file — Letterboxd CSV, IMDb CSV, or a generic JSON format. The user uploads a file, column mappings are applied, and reviews are created in batch.
-_Avoid_: Upload, migration, sync
-
-**ImportProfile**:
-A saved set of column-to-field mappings for an Import. Reusable across imports and shareable between users.
-_Avoid_: Template, mapping preset, import config

CONTRIBUTING.md

@@ -1,87 +0,0 @@
-# Contributing
-
-Thanks for your interest in Movies Diary! This is a personal project but contributions are welcome — bug fixes, new features, docs improvements, or picking up the deprecated TUI.
-
-## Getting started
-
-1. Fork and clone the repo
-2. Copy `.env.example` to `.env` and fill in at least `JWT_SECRET` and `OMDB_API_KEY`
-3. Install Rust (stable, 2024 edition) and Bun (for the SPA)
-4. Run the backend and worker:
-
-```bash
-cargo run -p presentation   # HTTP server on :3000
-cargo run -p worker          # event worker (separate terminal)
-```
-
-5. Run the SPA dev server:
-
-```bash
-cd spa && bun install && bun run dev
-```
-
-## Before submitting a PR
-
-```bash
-make           # runs fmt-check + clippy + test
-```
-
-Or individually:
-
-```bash
-cargo fmt --check
-cargo clippy -- -D warnings
-cargo test
-cd spa && bunx tsc --noEmit
-```
-
-All four must pass. PRs with clippy warnings or failing tests won't be merged.
-
-## Architecture
-
-The project follows hexagonal (ports & adapters) architecture. See `architecture.mmd` for the full diagram.
-
-**Key rules:**
-- Presentation handlers never touch repositories directly — all domain logic goes through use cases in the `application` crate
-- Application use cases return raw domain data — URL formatting, date display, and view model assembly belong in presentation mappers (`presentation/src/mappers/`)
-- Use cases called from presentation handlers take `&AppContext`. Functions called from adapter event handlers take individual `Arc<dyn Trait>` params to keep adapter dependencies explicit
-
-```
-domain         → pure types, traits (ports), zero deps
-application    → use cases, orchestration
-presentation   → Axum handlers, routes, OpenAPI
-worker         → event consumer, background jobs
-adapters/*     → implements domain ports (sqlite, postgres, AP, etc.)
-spa/           → React SPA (TanStack Router + shadcn/ui)
-```
-
-### Adding a new feature
-
-1. **Domain first** — models in `domain/src/models/`, ports in `ports.rs`, events in `events.rs`
-2. **Adapters** — implement ports in both `sqlite` and `postgres` adapters, add migration
-3. **Application** — use cases in `application/src/<domain>/`, wire into `context.rs`
-4. **API types** — DTOs in `api-types/src/`
-5. **Presentation** — handler file in `handlers/<domain>.rs`, routes in `routes.rs`
-6. **SPA** — API client in `spa/src/lib/api/`, hook in `spa/src/hooks/`, components
-7. **Classic HTML** — Askama template + CSS in `static/style.css`
-
-### Database adapters
-
-Both SQLite and PostgreSQL are supported. If you add a migration or repository, implement it for both. The postgres adapter uses `$1, $2` params and `TIMESTAMPTZ`; SQLite uses `?` and text datetimes.
-
-### Federation (ActivityPub)
-
-Federation is feature-gated (`#[cfg(feature = "federation")]`). If your feature should federate, add domain events, handle them in `activitypub/src/event_handler.rs`, and create an AP object + inbound handler.
-
-## Code style
-
-- No comments unless the *why* is non-obvious
-- Concise commit messages
-- One feature per PR — don't bundle unrelated changes
-- Follow existing patterns (check a similar feature for reference)
-
-## Areas seeking help
-
-- **TUI** (`crates/tui`) — deprecated, needs a maintainer to bring it up to feature parity
-- **Tests** — the domain and application crates have 400+ unit tests; integration tests for the presentation layer are welcome
-- **Docs** — API usage examples, deployment guides

Cargo.toml

@@ -1,46 +1,19 @@
 [workspace]
 members = [
     "crates/adapters/auth",
-    "crates/adapters/event-publisher",
-    "crates/adapters/metadata",
-    "crates/adapters/poster-fetcher",
-    "crates/adapters/object-storage",
-    "crates/adapters/poster-sync",
+    "crates/adapters/metadata", "crates/adapters/poster-fetcher", "crates/adapters/poster-storage",
     "crates/adapters/rss",
     "crates/adapters/sqlite",
-    "crates/adapters/postgres",
-    "crates/adapters/sqlite-federation",
-    "crates/adapters/postgres-federation",
-    "crates/adapters/sqlite-event-queue",
-    "crates/adapters/postgres-event-queue",
     "crates/adapters/template-askama",
-    "crates/adapters/activitypub",
-    "crates/adapters/export",
-    "crates/adapters/event-payload",
-    "crates/adapters/nats",
-    "crates/api-types",
     "crates/application",
-    "crates/adapters/tmdb-enrichment",
-    "crates/adapters/image-converter",
+    "crates/common",
     "crates/domain",
     "crates/presentation",
-    "crates/tui",
-    "crates/worker",
-    "crates/adapters/importer",
-    "crates/adapters/jellyfin",
-    "crates/adapters/plex",
-    "crates/adapters/sqlite-search",
-    "crates/adapters/postgres-search",
-    "crates/adapters/adapter-common",
-    "crates/infra-wiring",
 ]
 resolver = "2"
 
 [workspace.dependencies]
-tokio = { version = "1.0", features = ["macros", "net", "rt", "rt-multi-thread", "sync", "time"] }
-bytes = "1"
-futures = "0.3"
-async-stream = "0.3"
+tokio = { version = "1.0", features = ["full"] }
 dotenvy = "0.15"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
@@ -49,55 +22,25 @@ thiserror = "2.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
 async-trait = "0.1"
-uuid = { version = "1.23.0", features = ["v4", "v5", "serde"] }
+uuid = { version = "1.23.0", features = ["v4", "serde"] }
 chrono = { version = "0.4", features = ["serde"] }
 sqlx = { version = "0.8.6", features = [
     "runtime-tokio-rustls",
     "sqlite",
     "uuid",
+    "macros",
 ] }
-rand = "0.9"
 reqwest = { version = "0.13", features = ["json", "query"] }
-sha2 = "0.10"
-hex = "0.4"
 object_store = { version = "0.11", features = ["aws"] }
-axum = { version = "0.8.8", features = ["macros", "multipart"] }
-csv = "1"
 
-api-types = { path = "crates/api-types" }
 domain = { path = "crates/domain" }
-tmdb-enrichment = { path = "crates/adapters/tmdb-enrichment" }
+common = { path = "crates/common" }
 application = { path = "crates/application" }
 presentation = { path = "crates/presentation" }
 auth = { path = "crates/adapters/auth" }
 metadata = { path = "crates/adapters/metadata" }
 poster-fetcher = { path = "crates/adapters/poster-fetcher" }
-object-storage = { path = "crates/adapters/object-storage" }
-poster-sync = { path = "crates/adapters/poster-sync" }
-event-publisher = { path = "crates/adapters/event-publisher" }
+poster-storage = { path = "crates/adapters/poster-storage" }
 rss = { path = "crates/adapters/rss" }
-export = { path = "crates/adapters/export" }
 sqlite = { path = "crates/adapters/sqlite" }
-sqlite-federation = { path = "crates/adapters/sqlite-federation" }
-postgres = { path = "crates/adapters/postgres" }
-postgres-federation = { path = "crates/adapters/postgres-federation" }
 template-askama = { path = "crates/adapters/template-askama" }
-activitypub = { path = "crates/adapters/activitypub" }
-event-payload = { path = "crates/adapters/event-payload" }
-nats = { path = "crates/adapters/nats" }
-sqlite-event-queue = { path = "crates/adapters/sqlite-event-queue" }
-postgres-event-queue = { path = "crates/adapters/postgres-event-queue" }
-importer = { path = "crates/adapters/importer" }
-jellyfin = { path = "crates/adapters/jellyfin" }
-plex = { path = "crates/adapters/plex" }
-image-converter = { path = "crates/adapters/image-converter" }
-sqlite-search = { path = "crates/adapters/sqlite-search" }
-postgres-search = { path = "crates/adapters/postgres-search" }
-adapter-common = { path = "crates/adapters/adapter-common" }
-infra-wiring = { path = "crates/infra-wiring" }
-
-[profile.dev]
-debug = 1                    # line tables only — still debuggable, much faster linking
-
-[profile.dev.package."*"]
-opt-level = 2                # compile deps faster at runtime; paid once, cached after

Dockerfile

@@ -1,97 +0,0 @@
-# ----- spa -----
-FROM node:22-slim AS spa-builder
-WORKDIR /spa
-COPY spa/package.json spa/package-lock.json ./
-RUN npm ci
-COPY spa/ .
-RUN npm run build
-
-# ----- build -----
-FROM rust:slim-bookworm AS builder
-
-WORKDIR /build
-
-# Cache dependency compilation separately from source
-COPY Cargo.toml Cargo.lock ./
-COPY .cargo ./.cargo
-COPY crates/adapters/activitypub/Cargo.toml       crates/adapters/activitypub/Cargo.toml
-COPY crates/adapters/auth/Cargo.toml              crates/adapters/auth/Cargo.toml
-COPY crates/adapters/event-payload/Cargo.toml     crates/adapters/event-payload/Cargo.toml
-COPY crates/adapters/event-publisher/Cargo.toml   crates/adapters/event-publisher/Cargo.toml
-COPY crates/adapters/nats/Cargo.toml              crates/adapters/nats/Cargo.toml
-COPY crates/adapters/metadata/Cargo.toml          crates/adapters/metadata/Cargo.toml
-COPY crates/adapters/poster-fetcher/Cargo.toml    crates/adapters/poster-fetcher/Cargo.toml
-COPY crates/adapters/object-storage/Cargo.toml     crates/adapters/object-storage/Cargo.toml
-COPY crates/adapters/poster-sync/Cargo.toml       crates/adapters/poster-sync/Cargo.toml
-COPY crates/adapters/export/Cargo.toml            crates/adapters/export/Cargo.toml
-COPY crates/adapters/importer/Cargo.toml          crates/adapters/importer/Cargo.toml
-COPY crates/adapters/jellyfin/Cargo.toml          crates/adapters/jellyfin/Cargo.toml
-COPY crates/adapters/plex/Cargo.toml              crates/adapters/plex/Cargo.toml
-COPY crates/adapters/rss/Cargo.toml               crates/adapters/rss/Cargo.toml
-COPY crates/adapters/sqlite/Cargo.toml              crates/adapters/sqlite/Cargo.toml
-COPY crates/adapters/sqlite-federation/Cargo.toml   crates/adapters/sqlite-federation/Cargo.toml
-COPY crates/adapters/sqlite-event-queue/Cargo.toml  crates/adapters/sqlite-event-queue/Cargo.toml
-COPY crates/adapters/postgres/Cargo.toml            crates/adapters/postgres/Cargo.toml
-COPY crates/adapters/postgres-federation/Cargo.toml crates/adapters/postgres-federation/Cargo.toml
-COPY crates/adapters/postgres-event-queue/Cargo.toml crates/adapters/postgres-event-queue/Cargo.toml
-COPY crates/adapters/template-askama/Cargo.toml   crates/adapters/template-askama/Cargo.toml
-COPY crates/api-types/Cargo.toml                  crates/api-types/Cargo.toml
-COPY crates/application/Cargo.toml                crates/application/Cargo.toml
-COPY crates/adapters/tmdb-enrichment/Cargo.toml   crates/adapters/tmdb-enrichment/Cargo.toml
-COPY crates/domain/Cargo.toml                     crates/domain/Cargo.toml
-COPY crates/presentation/Cargo.toml               crates/presentation/Cargo.toml
-COPY crates/tui/Cargo.toml                        crates/tui/Cargo.toml
-COPY crates/adapters/image-converter/Cargo.toml   crates/adapters/image-converter/Cargo.toml
-COPY crates/adapters/sqlite-search/Cargo.toml     crates/adapters/sqlite-search/Cargo.toml
-COPY crates/adapters/postgres-search/Cargo.toml   crates/adapters/postgres-search/Cargo.toml
-COPY crates/adapters/adapter-common/Cargo.toml   crates/adapters/adapter-common/Cargo.toml
-COPY crates/worker/Cargo.toml                     crates/worker/Cargo.toml
-COPY crates/infra-wiring/Cargo.toml               crates/infra-wiring/Cargo.toml
-
-# Stub every crate so cargo can resolve and fetch deps
-RUN find crates -name "Cargo.toml" | sed 's|/Cargo.toml||' | \
-    xargs -I{} sh -c 'mkdir -p {}/src && echo "fn main(){}" > {}/src/main.rs && echo "" > {}/src/lib.rs'
-
-# libwebp-dev: required at build time by the `webp` crate (C bindings)
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libwebp-dev \
-    pkg-config \
- && rm -rf /var/lib/apt/lists/*
-
-RUN cargo fetch
-
-# Now copy real sources (invalidates cache only on source changes)
-COPY crates ./crates
-
-# All sqlx queries use the runtime API (no query! macros), so no database
-# or .sqlx cache is needed at compile time.
-#
-# To build with PostgreSQL backend instead:
-#   --build-arg FEATURES=postgres,postgres-federation
-# To add NATS support (EVENT_BUS_BACKEND=nats):
-#   --build-arg FEATURES=sqlite,sqlite-federation,nats
-ARG FEATURES=sqlite,sqlite-federation
-RUN cargo build --release -p presentation -p worker --no-default-features --features "${FEATURES}"
-
-# ----- runtime -----
-FROM debian:bookworm-slim
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    ca-certificates \
-    wget \
-    libwebp7 \
-    fonts-dejavu-core \
- && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-COPY --from=builder /build/target/release/presentation ./presentation
-COPY --from=builder /build/target/release/worker ./worker
-COPY static ./static
-COPY --from=spa-builder /spa/dist ./spa/dist
-
-EXPOSE 3000
-
-ENV RUST_LOG=presentation=info,tower_http=info
-
-CMD ["./presentation"]

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Gabriel Kaszewski
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

Makefile

@@ -1,37 +0,0 @@
-.DEFAULT_GOAL := check
-
-# Run the full local check suite — same order as CI would.
-check: fmt-check clippy test check-appcontext
-	@echo "✅ All checks passed"
-
-# Enforce that no application use case imports AppContext (god-object guard).
-check-appcontext:
-	@if grep -rn "AppContext" crates/application/src --include="*.rs" | grep -q .; then \
-	    echo "❌ AppContext found in application crate:"; \
-	    grep -rn "AppContext" crates/application/src --include="*.rs"; \
-	    exit 1; \
-	fi
-	@echo "✅ No AppContext in application crate"
-
-# Apply rustfmt to all files.
-fmt:
-	cargo fmt
-
-# Check formatting without modifying files (CI-safe).
-fmt-check:
-	cargo fmt --check
-
-# Run Clippy and treat warnings as errors.
-clippy:
-	cargo clippy -- -D warnings
-
-# Run the test suite.
-test:
-	cargo test
-
-# Apply fmt + clippy auto-fixes in one shot.
-fix:
-	cargo fmt
-	cargo clippy --fix --allow-dirty --allow-staged
-
-.PHONY: check fmt fmt-check clippy test fix

README.md

@@ -1,309 +0,0 @@
-# Movies Diary
-
-A self-hosted movie diary built in Rust. Ships a classic server-rendered HTML interface (no JavaScript) alongside a full React SPA, both backed by the same REST API. Federates over ActivityPub so reviews reach the Fediverse. Supports Jellyfin and Plex auto-import, full-text search, annual wrap-ups, goals, and bulk import from Letterboxd, IMDb, and other sources. Runs on SQLite or PostgreSQL.
-
-[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
-[![Built with Rust](https://img.shields.io/badge/built_with-Rust-orange.svg?logo=rust)](https://www.rust-lang.org/)
-[![Docker](https://img.shields.io/badge/docker-ready-2496ED?logo=docker&logoColor=white)](https://hub.docker.com/)
-[![ActivityPub](https://img.shields.io/badge/ActivityPub-federated-5b5ea6)](https://activitypub.rocks/)
-[![SQLite](https://img.shields.io/badge/database-SQLite%20%7C%20PostgreSQL-003B57?logo=sqlite&logoColor=white)](https://www.sqlite.org/)
-
----
-
-## Table of Contents
-
-- [Quick Start](#quick-start)
-- [Features](#features)
-- [Screenshots](#screenshots)
-- [Architecture](#architecture)
-- [Prerequisites](#prerequisites)
-- [Configuration](#configuration)
-- [Run](#run)
-- [API](#api)
-- [SPA](#spa)
-- [Development](#development)
-- [Test](#test)
-- [Docker](#docker)
-- [Media Server Integration](#media-server-integration)
-- [Annual Wrap-Up](#annual-wrap-up)
-- [Contributing](#contributing)
-- [License](#license)
-
----
-
-## Quick Start
-
-The fastest way to run Movies Diary is via Docker Compose:
-
-```bash
-cp .env.example .env
-# Set JWT_SECRET and OMDB_API_KEY (or TMDB_API_KEY) in .env
-docker compose up -d
-```
-
-Open `http://localhost:3000`. The HTTP server and background worker start together; data is persisted in a Docker volume.
-
----
-
-## Features
-
-- Log movies with a TMDB/OMDb ID or manual title/year/director, with a 1–5 rating and optional watch medium (cinema, streaming, TV, physical media, download, media server)
-- Edit reviews after the fact — update rating, comment, date, or watch medium via partial PATCH; each watch is still a separate record (re-watches tracked)
-- Background poster fetching and storage (local filesystem or S3-compatible)
-- Movie enrichment via TMDb — full cast, crew, genres, keywords, runtime, budget/revenue, ratings; fetched automatically on movie discovery and refreshed every 30 days; exposed via `GET /api/v1/movies/{id}/profile`
-- Full-text search across movies and people via `GET /api/v1/search` — free-text query plus structured filters (genre, year, person, department, language); backed by SQLite FTS5 or PostgreSQL tsvector + GIN indexes
-- People as first-class entities — browse by person via `GET /api/v1/people/{id}` and full credit history via `GET /api/v1/people/{id}/credits`; index populated automatically during TMDb enrichment
-- RSS/Atom feed for public subscription (global and per-user)
-- JWT authentication via cookie (HTML) or Bearer token (REST API)
-- ActivityPub federation — follow/unfollow remote users, accept/reject/remove followers, federated reviews broadcast as `Note` objects with movie poster image attachment, `#MoviesDiary` + `#MovieTitle` hashtags, paginated outbox (reviews, watchlist entries, goals), boost/Announce tracking, NodeInfo discovery endpoint, shared inbox delivery, actor profile sync (bio, avatar, discoverable); account migration via `Move` activity; account deletion broadcasts `Delete` actor to followers
-- Federation moderation — instance-level domain blocking (admin-managed), per-user actor blocking with `Block` / `Undo Block` activities, delivery filter excludes blocked actors and blocked-domain inboxes
-- Watchlist — add movies to watch later, per-user; federated watchlist entries visible for remote actors
-- User profiles — display name, bio, avatar, banner, custom profile fields; editable via HTML settings page or REST API; account deletion broadcasts AP `Delete` actor activity; `alsoKnownAs` change triggers AP `Move` for account migration
-- Jellyfin/Plex auto-import — media server sends a webhook on playback stop, movies land in a watch queue; review and confirm with a rating to create diary entries; per-user webhook tokens with SHA-256 auth; setup UI at `/settings/integrations`
-- Annual Wrap-Up — Spotify Wrapped for movies: per-user and instance-wide year-in-review with stats (top directors, actors, genres, rating distribution, watch time, watch medium breakdown, rewatches, budget analysis); directors/actors filtered by minimum watch count for statistical relevance; shareable HTML page at `/wrapups/{user_id}/{year}`; admin-triggered or auto-generated in January
-- Goals — set a "watch N movies in YEAR" target with a progress bar; progress computed from existing reviews (backwards compatible); per-user federation toggle in settings; displayed on profile (SPA: interactive with create/edit/delete, classic HTML: read-only glassmorphic card)
-- Profile trends — top directors, genre breakdown, rating distribution histogram, watch medium breakdown, monthly activity chart; all computed from the user's review history
-- CSV and JSON diary export
-- File importer: upload CSV, TSV, JSON, or XLSX from any source (Letterboxd, IMDb, etc.), map columns to domain fields via a step-by-step wizard or REST API, save mapping profiles for repeat imports
-- REST API v1 (`/api/v1/`) with full feature parity with the HTML interface
-- OpenAPI documentation at `/docs` (Swagger UI) and `/scalar` (Scalar)
-- CSRF protection on all HTML form routes (double-submit cookie, defense-in-depth on top of `SameSite=Strict`)
-- Per-IP rate limiting via token bucket (production-grade, backed by `axum-governor`)
-- Single-page app at `/app/` — React + TanStack Router + shadcn/ui, built with Vite, served from the backend with client-side routing fallback
-- Terminal UI client (`crates/tui`, deprecated) for logging reviews, bulk CSV import, and diary browsing
-
-## Screenshots
-
-> SPA at `/app/` — React + TanStack Router + shadcn/ui
-
-| Feed | Movie | Person |
-|------|-------|--------|
-| ![Feed](screenshots/feed.jpeg) | ![Movie detail](screenshots/movie.jpeg) | ![Person detail](screenshots/person.jpeg) |
-
-| Profile | Wrap-Up | Wrap-Up card |
-|---------|---------|--------------|
-| ![Profile](screenshots/profile.jpeg) | ![Wrap-Up stats](screenshots/wrapup-stats.jpeg) | ![Wrap-Up shareable card](screenshots/wrapup-card.jpeg) |
-
-## Architecture
-
-Hexagonal (Ports & Adapters) with Domain-Driven Design:
-
-```
-api-types           — shared REST API request/response DTOs (Serialize/Deserialize + utoipa schemas) + HtmlPageContext; used by presentation, tui, and template adapters
-infra-wiring        — shared infrastructure types (DbPool, EventBusBackend, AppConfig) used by both presentation and worker binaries
-domain              — pure types and CQRS port traits (MovieCommand/MovieQuery, WatchEventCommand/WatchEventQuery, GoalCommand/GoalQuery, DiaryQuery, PersonCommand/PersonQuery, SearchCommand/SearchPort, SocialCommand/SocialQuery, ImageFetcher, RssFeedRenderer), no external deps except serde
-application         — use cases (commands + queries), business logic orchestration; handlers delegate here for all domain logic; modules: auth, diary, goals, import, integrations, movies, person, search, social, users, watchlist, wrapup
-presentation        — Axum HTTP router, OpenAPI spec assembly, Swagger UI + Scalar serving, composition root for the HTTP process
-worker              — standalone worker binary (event consumer, poster sync, federation)
-adapters/
-  adapter-common       — shared row-to-domain conversions, sqlx error mapping, date/uuid parsing utils
-  auth                 — JWT issuance and validation (Argon2 passwords)
-  sqlite               — SQLite repository + connection factory
-  postgres             — PostgreSQL repository + connection factory
-  metadata             — TMDB / OMDb HTTP client
-  poster-fetcher       — downloads poster images
-  object-storage       — stores images (posters + user avatars) on local filesystem or S3-compatible storage
-  poster-sync          — event handler: triggers poster fetch+store on MovieDiscovered
-  image-converter      — optional background worker: converts stored images to AVIF or WebP; backfills existing images via a 24h periodic job
-  tmdb-enrichment      — TMDb HTTP client implementing MovieEnrichmentClient and PersonEnrichmentClient; event handlers (MovieEnrichmentHandler, PersonEnrichmentHandler) live in the application layer
-  template-askama      — Askama HTML rendering
-  rss                  — RSS/Atom feed generation
-  export               — CSV and JSON diary serialization
-  importer             — CSV/TSV/JSON/XLSX parser and column mapper for bulk import
-  jellyfin             — Jellyfin webhook payload parser (MediaServerParser adapter)
-  plex                 — Plex webhook payload parser (MediaServerParser adapter; requires Plex Pass)
-  event-payload        — shared event serialization DTOs (used by all event bus adapters)
-  sqlite-event-queue   — durable polling event queue backed by SQLite
-  postgres-event-queue — durable polling event queue backed by PostgreSQL
-  event-publisher      — in-memory event channel (used in tests)
-  nats                 — NATS Core / JetStream event publisher and consumer
-  event-publisher      — in-memory event channel (used in tests)
-  activitypub          — ActivityPub federation adapter (follow, inbox/outbox, actor); delegates to k-ap for protocol internals
-  sqlite-search        — SQLite FTS5 implementation of SearchPort + SearchCommand
-  postgres-search      — PostgreSQL tsvector + GIN implementation of SearchPort + SearchCommand
-  sqlite-federation    — SQLite-backed federation repository
-  postgres-federation  — PostgreSQL-backed federation repository
-tui                 — terminal UI client (ratatui); shares api-types with presentation for typed API access
-spa/                — React SPA (TanStack Router + shadcn/ui + Vite); served at /app/ by the backend
-```
-
-## Prerequisites
-
-- Rust (stable, 2024 edition)
-- SQLite
-- Poster storage: local filesystem (zero deps) or an S3-compatible object store (e.g. MinIO)
-- An [OMDb API key](https://www.omdbapi.com/apikey.aspx)
-
-## Configuration
-
-Copy `.env.example` to `.env` and set the values below. Required fields must be set before the server will start.
-
-| Variable | Default | Required | Description |
-|---|---|---|---|
-| `DATABASE_URL` | `sqlite://movies.db` | Yes | SQLite or PostgreSQL connection string |
-| `JWT_SECRET` | — | Yes | Secret for JWT signing — use a long random string |
-| `OMDB_API_KEY` | — | Yes | [OMDb](https://www.omdbapi.com/apikey.aspx) key for movie metadata |
-| `TMDB_API_KEY` | — | No | [TMDb](https://www.themoviedb.org/settings/api) key — enables cast, crew, genres, enrichment |
-| `BASE_URL` | — | Yes | Public URL of your instance (used for ActivityPub actor URLs) |
-| `IMAGE_STORAGE_BACKEND` | `local` | No | `local` or `s3` |
-| `IMAGE_STORAGE_PATH` | `./images` | No | Path for local image storage |
-| `MINIO_ENDPOINT` | — | S3 only | S3-compatible endpoint (e.g. `http://localhost:9000`) |
-| `MINIO_BUCKET` | — | S3 only | Bucket name |
-| `MINIO_REGION` | — | S3 only | Region (e.g. `minio`) |
-| `MINIO_ACCESS_KEY_ID` | — | S3 only | Access key ID |
-| `MINIO_SECRET_ACCESS_KEY` | — | S3 only | Secret access key |
-| `IMAGE_CONVERSION_ENABLED` | `false` | No | Convert stored images to AVIF or WebP |
-| `IMAGE_CONVERSION_FORMAT` | `avif` | No | `avif` or `webp` |
-| `HOST` | `0.0.0.0` | No | Bind address |
-| `PORT` | `3000` | No | HTTP port |
-| `RATE_LIMIT` | `60` | No | Requests per minute per IP |
-| `ALLOW_REGISTRATION` | `true` | No | Set `false` to disable new sign-ups |
-| `SECURE_COOKIES` | `true` | No | Must be `true` when serving over HTTPS |
-| `RUST_LOG` | — | No | Log verbosity (e.g. `presentation=info,worker=info`) |
-| `CORS_ORIGINS` | `*` | No | Comma-separated allowed origins for SPA dev |
-| `EVENT_BUS_BACKEND` | `db` | No | `db` (default) or `nats` |
-| `NATS_URL` | — | NATS only | NATS connection URL (e.g. `nats://localhost:4222`) |
-
-The `worker` binary must run alongside `presentation` to process events:
-
-```bash
-cargo run -p worker
-```
-
-## Run
-
-```bash
-cargo run -p presentation   # HTTP server (0.0.0.0:3000)
-cargo run -p worker         # event worker (poster sync, in a separate terminal)
-```
-
-The worker polls the event queue and must run alongside the presentation to process background tasks like poster fetching. Both processes share the same database.
-
-## API
-
-All REST endpoints are under `/api/v1/`. Authentication uses `Authorization: Bearer <token>` obtained from `POST /api/v1/auth/login`.
-
-Interactive API documentation is available at runtime:
-
-- **Swagger UI** — `http://localhost:3000/docs`
-- **Scalar** — `http://localhost:3000/scalar`
-
-An [Insomnia](https://insomnia.rest/) collection covering all endpoints is included at [`movies-diary.insomnia.json`](movies-diary.insomnia.json). Import it via **File → Import**, set `base_url` and `token` in the environment, and you're ready to go.
-
-## SPA
-
-The single-page app lives in `spa/` and is served at `/app/` by the backend. For local development:
-
-```bash
-cd spa && bun install && bun run dev   # http://localhost:5173/app/
-```
-
-Set `CORS_ORIGINS=http://localhost:5173` in the backend `.env` to allow cross-origin API calls during development.
-
-For production, `bun run build` outputs to `spa/dist/` which the backend serves statically (included in Docker image automatically).
-
-## Terminal UI (deprecated)
-
-> **Note:** The TUI was an experiment with ratatui and is no longer actively maintained. It may not support newer features (goals, watchlist, federation, etc.). Contributions welcome — if you'd like to maintain it, open a PR.
-
-```bash
-cargo run -p tui
-```
-
-Supports review logging, bulk CSV import, and diary browsing.
-
-## Development
-
-A `Makefile` wraps the most common dev commands:
-
-```bash
-make           # default: fmt-check + clippy + test (same order as CI)
-make fix       # auto-apply fmt + clippy fixes
-make fmt       # apply rustfmt
-make clippy    # clippy with -D warnings
-make test      # cargo test
-```
-
-## Test
-
-```bash
-cargo test                    # full workspace (requires DATABASE_URL for sqlx offline checks)
-cargo test -p application     # business logic tests only — no database required
-cargo test -p domain          # domain model + value object tests
-cargo llvm-cov -p application -p domain   # line coverage report (requires cargo-llvm-cov)
-```
-
-The `application` and `domain` crates have 400+ unit tests covering all use case modules (auth, diary, goals, import, integrations, movies, person, search, users, watchlist, wrapup) backed by in-memory fakes from `domain`'s `test-helpers` feature. These run without a database and are the fastest feedback loop for business logic changes.
-
-## Docker
-
-### Quick start
-
-```bash
-cp .env.example .env
-# Edit .env — set JWT_SECRET and OMDB_API_KEY (or TMDB_API_KEY)
-docker compose up -d
-```
-
-This builds and starts the HTTP server (port 3000) and event worker. Data is persisted in a Docker volume.
-
-### Manual docker run
-
-The image contains both `presentation` and `worker` binaries. Run them as separate containers sharing the same data volume:
-
-```bash
-docker build -t movies-diary .
-
-docker run -p 3000:3000 --env-file .env -v movies-diary-data:/data movies-diary
-docker run --env-file .env -v movies-diary-data:/data --entrypoint ./worker movies-diary
-```
-
-Build for PostgreSQL: `--build-arg FEATURES=postgres,postgres-federation`
-
-## Media Server Integration
-
-Auto-log movies you finish watching. Go to `/settings/integrations` to generate a webhook token, then configure your media server.
-
-### Jellyfin
-
-1. Install the **Webhook** plugin (Dashboard > Plugins > Catalog)
-2. Add a **Generic** destination:
-   - **URL**: `https://yourdomain.example.com/api/v1/webhooks/jellyfin`
-   - **Header**: `Authorization` = `Bearer <your-token>`
-   - **Send All Properties**: enabled
-   - **Notification Type**: Playback Stop only
-   - **Item Type**: Movies only
-
-### Plex (requires Plex Pass)
-
-1. Go to Settings > Webhooks in your Plex server
-2. Add webhook URL: `https://yourdomain.example.com/api/v1/webhooks/plex`
-3. Plex does not support custom headers natively — pass the token as a query param: `https://yourdomain.example.com/api/v1/webhooks/plex?token=<your-token>`
-
-Movies you finish watching appear in your watch queue at `/watch-queue` — rate and confirm to add to your diary.
-
-## Annual Wrap-Up
-
-Generate a year-in-review summary for any user — top directors, actors, genres, rating distribution, total watch time, rewatch stats, and more. Available as a shareable HTML page.
-
-**Generate via API** (admin only):
-```bash
-curl -X POST http://localhost:3000/api/v1/wrapups/generate \
-  -H "Authorization: Bearer <admin-token>" \
-  -H "Content-Type: application/json" \
-  -d '{"user_id": "<uuid>", "start_date": "2025-01-01", "end_date": "2026-01-01"}'
-```
-
-Omit `user_id` for a global instance wrap-up. The worker computes stats in the background — poll `GET /api/v1/wrapups/{id}` for status.
-
-**View:** `http://localhost:3000/wrapups/{user_id}/2025` (public, no login required)
-
-**Auto-generate:** The worker runs a daily job in January that generates wrap-ups for all users with reviews in the previous year.
-
-## Contributing
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for setup instructions, architecture overview, and PR guidelines.
-
-## License
-
-MIT License. See [LICENSE](LICENSE).

architecture.mmd

@@ -1,153 +0,0 @@
----
-title: Movies Diary — Hexagonal Architecture
----
-graph TB
-    subgraph Binaries["Binaries (Composition Root)"]
-        WEB["presentation<br/><i>Axum web server</i><br/>Routes, Handlers, Mappers"]
-        WORKER["worker<br/><i>Event consumer</i><br/>Concurrent dispatch, graceful shutdown"]
-        TUI["tui<br/><i>Terminal UI</i>"]
-    end
-
-    subgraph Application["Application Layer"]
-        direction TB
-        CTX["AppContext<br/><i>Repositories + Services</i>"]
-        APP_PORTS["ReviewLogger<br/><i>application-layer port</i>"]
-        subgraph UseCases["Use Cases"]
-            UC_AUTH["auth<br/>login, register"]
-            UC_DIARY["diary<br/>log_review, edit_review,<br/>get_diary, get_activity_feed,<br/>export"]
-            UC_MOVIES["movies<br/>get_movies, get_movie_profile,<br/>enrich_movie, request_enrichment,<br/>sync_poster, reindex_search,<br/>merge_duplicates"]
-            UC_IMPORT["import<br/>create_session, apply_mapping,<br/>execute, profiles"]
-            UC_USERS["users<br/>get_users, get_profile,<br/>update_profile, delete_account"]
-            UC_WATCHLIST["watchlist<br/>add, remove, get"]
-            UC_WRAPUP["wrapup<br/>generate, compute,<br/>list, delete"]
-            UC_GOALS["goals<br/>create, update, delete,<br/>get, list"]
-            UC_INTEGRATIONS["integrations<br/>webhooks, watch_queue,<br/>confirm, dismiss"]
-            UC_SEARCH["search<br/>execute"]
-            UC_PERSON["person<br/>get, get_credits"]
-            UC_SOCIAL["social<br/>follow, unfollow,<br/>accept, reject, block"]
-        end
-        subgraph EventHandlers["Event Handlers"]
-            EH_MOVIE["MovieEnrichmentHandler<br/><i>on MovieEnrichmentRequested</i>"]
-            EH_PERSON["PersonEnrichmentHandler<br/><i>on PersonEnrichmentRequested</i>"]
-            EH_DISCOVER["MovieDiscoveryIndexer"]
-            EH_CLEANUP["SearchCleanupHandler"]
-            EH_REINDEX["SearchReindexHandler"]
-            EH_WRAPUP["WrapUpEventHandler"]
-            EH_AP["ActivityPubEventHandler<br/><i>reviews, watchlist, goals,<br/>UserDeleted, UserAccountMoved</i>"]
-        end
-        subgraph Jobs["Periodic Jobs"]
-            JOB_IMPORT["ImportSessionCleanup"]
-            JOB_WATCH["WatchEventCleanup"]
-            JOB_STALE["EnrichmentStaleness"]
-            JOB_WRAPGEN["WrapUpAutoGenerate"]
-            JOB_WRAPCLEAN["WrapUpCleanup"]
-            JOB_SESSION["RefreshSessionCleanup"]
-            JOB_DEDUP["MovieDeduplication<br/><i>merge duplicate movie<br/>records (daily)</i>"]
-        end
-        WORKER_SVC["WorkerService<br/><i>Semaphore(8), JoinSet,<br/>shutdown signal</i>"]
-    end
-
-    subgraph Domain["Domain Layer (0 dependencies)"]
-        direction TB
-        subgraph Models["Models"]
-            M_MOVIE["Movie, MovieSummary,<br/>MovieProfile"]
-            M_REVIEW["Review, ReviewEdit,<br/>DiaryEntry, FeedEntry"]
-            M_USER["User, UserSummary"]
-            M_PERSON["Person, PersonId,<br/>PersonCredits"]
-            M_WATCHLIST["WatchlistEntry,<br/>WatchEvent"]
-            M_GOAL["Goal, GoalWithProgress,<br/>UserSettings, RemoteGoalEntry"]
-            M_WRAPUP["WrapUpReport,<br/>MovieRef, PersonStat"]
-            M_SEARCH["SearchQuery,<br/>SearchResults"]
-        end
-        subgraph Ports["Port Traits (Interfaces)"]
-            P_REPOS["MovieCommand / MovieQuery<br/>ReviewRepository<br/>DiaryQuery / StatsRepository<br/>UserRepository / UserProfileFieldsRepository<br/>WatchlistRepository<br/>WatchEventCommand / WatchEventQuery<br/>WebhookTokenRepository<br/>ImportSessionRepository / ImportProfileRepository<br/>MovieProfileRepository<br/>WrapUpRepository / WrapUpStatsQuery<br/>GoalCommand / GoalQuery<br/>UserSettingsRepository / RefreshSessionRepository<br/>MovieDeduplicator"]
-            P_SERVICES["AuthService<br/>MetadataClient / MovieEnrichmentClient<br/>PersonEnrichmentClient<br/>PosterFetcherClient<br/>ImageFetcher / ObjectStorage<br/>EventPublisher / EventConsumer<br/>PasswordHasher<br/>DiaryExporter / DocumentParser<br/>RssFeedRenderer / MediaServerParser"]
-            P_SEARCH["SearchPort / SearchCommand<br/>PersonQuery / PersonCommand<br/>FederatedProfileQuery"]
-            P_FEDERATION["SocialCommand / SocialQuery<br/>FederationAdminQuery<br/>LocalApContentQuery<br/>RemoteWatchlistRepository<br/>RemoteGoalRepository"]
-        end
-        subgraph DomainServices["Services (pure, no I/O)"]
-            DS_WRAPUP["WrapUpAnalyzer<br/><i>build_report, compute_*</i>"]
-            DS_REVIEW["ReviewHistoryAnalyzer<br/><i>rating_trend</i>"]
-        end
-        EVENTS["DomainEvent enum<br/><i>ReviewLogged, MovieDiscovered,<br/>GoalCreated, GoalUpdated,<br/>UserDeleted, UserAccountMoved,<br/>SearchReindexRequested, ...</i>"]
-        VO["Value Objects<br/><i>MovieId, UserId, Rating,<br/>WatchMedium, Email, Username,<br/>Password, ...</i>"]
-    end
-
-    subgraph ApiTypes["api-types"]
-        DTO["DTOs<br/><i>MovieDto, ReviewDto,<br/>FeedEntryDto, UserSummaryDto,<br/>HtmlPageContext, ...</i>"]
-    end
-
-    subgraph InfraWiring["infra-wiring"]
-        IW["DbPool, EventBusBackend,<br/>AppConfig<br/><i>Shared infra types</i>"]
-    end
-
-    subgraph Adapters["Adapters (implement Port Traits)"]
-        direction TB
-        A_COMMON["adapter-common<br/><i>Shared row conversions,<br/>error mapping, date utils</i>"]
-        subgraph Storage["Storage"]
-            A_SQLITE["sqlite<br/><i>SQLite repos</i>"]
-            A_PG["postgres<br/><i>PostgreSQL repos</i>"]
-            A_SQLITE_SEARCH["sqlite-search<br/><i>FTS5</i>"]
-            A_PG_SEARCH["postgres-search<br/><i>tsvector/GIN</i>"]
-            A_OBJ["object-storage<br/><i>S3 / filesystem</i>"]
-        end
-        subgraph Messaging["Messaging"]
-            A_NATS["nats<br/><i>JetStream / Core</i>"]
-            A_SQLITE_QUEUE["sqlite-event-queue<br/><i>Polling, dead-letter</i>"]
-            A_PG_QUEUE["postgres-event-queue<br/><i>Polling, dead-letter</i>"]
-            A_EVT_PUB["event-publisher<br/><i>In-memory (tests)</i>"]
-            A_PAYLOAD["event-payload<br/><i>Serde (de)serialization</i>"]
-        end
-        subgraph External["External Services"]
-            A_METADATA["metadata<br/><i>TMDB search/details</i>"]
-            A_TMDB["tmdb-enrichment<br/><i>Credits, keywords, cast</i>"]
-            A_POSTER["poster-fetcher<br/><i>TMDB image download</i>"]
-            A_AUTH["auth<br/><i>JWT tokens</i>"]
-        end
-        subgraph Federation["Federation (feature-gated)"]
-            A_AP["activitypub<br/><i>k_ap library</i>"]
-            A_SQLITE_FED["sqlite-federation"]
-            A_PG_FED["postgres-federation"]
-        end
-        subgraph Media["Media Processing"]
-            A_IMG["image-converter<br/><i>AVIF/WebP</i>"]
-            A_POSTER_SYNC["poster-sync"]
-        end
-        subgraph Presentation["Presentation Helpers"]
-            A_TEMPLATE["template-askama<br/><i>HTML templates</i>"]
-            A_RSS["rss<br/><i>Feed generation</i>"]
-            A_EXPORT["export<br/><i>CSV/JSON diary</i>"]
-            A_IMPORT["importer<br/><i>CSV/JSON/XLSX parser</i>"]
-        end
-        subgraph Webhooks["Webhook Parsers"]
-            A_JELLYFIN["jellyfin"]
-            A_PLEX["plex"]
-        end
-    end
-
-    %% Dependency arrows
-    WEB -->|"uses"| Application
-    WEB -->|"maps to"| ApiTypes
-    WORKER -->|"uses"| Application
-
-    Application -->|"depends on"| Domain
-    UC_WRAPUP -->|"delegates to"| DS_WRAPUP
-
-    Adapters -.->|"implements"| Ports
-
-    %% Key data flows
-    WEB ===|"HTTP"| DTO
-    WORKER ===|"Events"| EVENTS
-
-    classDef domain fill:#1a1a2e,stroke:#e94560,color:#fff
-    classDef app fill:#16213e,stroke:#0f3460,color:#fff
-    classDef adapter fill:#0f3460,stroke:#533483,color:#fff
-    classDef binary fill:#533483,stroke:#e94560,color:#fff
-    classDef api fill:#2a2a4a,stroke:#e94560,color:#fff
-
-    class Domain domain
-    class DomainServices domain
-    class Application app
-    class Adapters adapter
-    class Binaries binary
-    class ApiTypes api

crates/adapters/activitypub/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "activitypub"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-k-ap = { version = "0.5.0", registry = "gitea" }
-domain = { workspace = true }
-axum = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-uuid = { workspace = true }
-chrono = { workspace = true }
-anyhow = { workspace = true }
-tracing = { workspace = true }
-async-trait = { workspace = true }
-
-url = { version = "2", features = ["serde"] }
-ammonia = "4"

crates/adapters/activitypub/src/composite_handler.rs

@@ -1,135 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use k_ap::{ApContentReader, ApObjectHandler, LocalObject};
-use url::Url;
-
-use crate::{
-    goal_handler::GoalObjectHandler, review_handler::ReviewObjectHandler,
-    watchlist_handler::WatchlistObjectHandler,
-};
-
-pub struct CompositeObjectHandler {
-    pub review: Arc<ReviewObjectHandler>,
-    pub watchlist: Arc<WatchlistObjectHandler>,
-    pub goal: Arc<GoalObjectHandler>,
-}
-
-#[async_trait]
-impl ApContentReader for CompositeObjectHandler {
-    async fn get_local_objects_page(
-        &self,
-        user_id: uuid::Uuid,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        limit: usize,
-    ) -> anyhow::Result<Vec<LocalObject>> {
-        let fetch_limit = limit * 3;
-        let reviews = self
-            .review
-            .get_local_objects_page(user_id, before, fetch_limit)
-            .await?;
-        let watchlist = self
-            .watchlist
-            .get_local_objects_page(user_id, None, usize::MAX)
-            .await?;
-        let goals = self
-            .goal
-            .get_local_objects_page(user_id, None, usize::MAX)
-            .await?;
-
-        let mut all: Vec<LocalObject> = Vec::new();
-        all.extend(reviews);
-        all.extend(watchlist);
-        all.extend(goals);
-
-        if let Some(before_ts) = before {
-            all.retain(|obj| obj.published_at < before_ts);
-        }
-        all.sort_by_key(|obj| std::cmp::Reverse(obj.published_at));
-        all.truncate(limit);
-        Ok(all)
-    }
-
-    async fn count_local_posts(&self) -> anyhow::Result<u64> {
-        self.review.count_local_posts().await
-    }
-}
-
-#[async_trait]
-impl ApObjectHandler for CompositeObjectHandler {
-    async fn on_create(
-        &self,
-        ap_id: &Url,
-        actor_url: &Url,
-        object: serde_json::Value,
-    ) -> anyhow::Result<()> {
-        let is_review = object.get("review").and_then(|v| v.as_bool()) == Some(true)
-            || object.get("rating").is_some();
-        let is_watchlist = object.get("watchlistEntry").and_then(|v| v.as_bool()) == Some(true)
-            || (object.get("movieTitle").is_some()
-                && object.get("rating").is_none()
-                && object.get("review").is_none());
-        let is_goal = object.get("goal").and_then(|v| v.as_bool()) == Some(true);
-        if is_review {
-            self.review.on_create(ap_id, actor_url, object).await
-        } else if is_goal {
-            self.goal.on_create(ap_id, actor_url, object).await
-        } else if is_watchlist {
-            self.watchlist.on_create(ap_id, actor_url, object).await
-        } else {
-            tracing::warn!(ap_id = %ap_id, "ignoring Create for unknown object type");
-            Ok(())
-        }
-    }
-
-    async fn on_update(
-        &self,
-        ap_id: &Url,
-        actor_url: &Url,
-        object: serde_json::Value,
-    ) -> anyhow::Result<()> {
-        let is_review = object.get("review").and_then(|v| v.as_bool()) == Some(true)
-            || object.get("rating").is_some();
-        let is_goal = object.get("goal").and_then(|v| v.as_bool()) == Some(true);
-        let is_watchlist = object.get("watchlistEntry").and_then(|v| v.as_bool()) == Some(true);
-        if is_review {
-            self.review.on_update(ap_id, actor_url, object).await
-        } else if is_goal {
-            self.goal.on_update(ap_id, actor_url, object).await
-        } else if is_watchlist {
-            self.watchlist.on_update(ap_id, actor_url, object).await
-        } else {
-            Ok(())
-        }
-    }
-
-    async fn on_delete(&self, ap_id: &Url, actor_url: &Url) -> anyhow::Result<()> {
-        self.review.on_delete(ap_id, actor_url).await?;
-        self.watchlist.on_delete(ap_id, actor_url).await?;
-        self.goal.on_delete(ap_id, actor_url).await?;
-        Ok(())
-    }
-
-    async fn on_actor_removed(&self, actor_url: &Url) -> anyhow::Result<()> {
-        self.review.on_actor_removed(actor_url).await?;
-        self.watchlist.on_actor_removed(actor_url).await?;
-        self.goal.on_actor_removed(actor_url).await?;
-        Ok(())
-    }
-
-    async fn on_like(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_announce_received(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_announce_of_remote(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_unlike(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_mention(&self, _: &Url, _: uuid::Uuid, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-}

crates/adapters/activitypub/src/event_handler.rs

@@ -1,522 +0,0 @@
-use async_trait::async_trait;
-use chrono::Datelike;
-use domain::ports::EventHandler;
-use domain::{
-    errors::DomainError,
-    events::DomainEvent,
-    ports::{
-        GoalQuery, LocalApContentQuery, MovieQuery, ReviewRepository, StatsRepository,
-        UserFederationSettingsQuery,
-    },
-    value_objects::{MovieId, ReviewId, UserId},
-};
-use std::sync::Arc;
-
-use k_ap::{ActivityPubService, ApVisibility};
-
-use crate::objects::{ReviewApInput, goal_to_ap_object, review_to_ap_object};
-use crate::urls::{actor_url, goal_url, review_url};
-
-pub struct ActivityPubEventHandler {
-    ap_service: Arc<ActivityPubService>,
-    content_query: Arc<dyn LocalApContentQuery>,
-    review_repo: Arc<dyn ReviewRepository>,
-    movie_repo: Arc<dyn MovieQuery>,
-    goal_repo: Arc<dyn GoalQuery>,
-    stats_repo: Arc<dyn StatsRepository>,
-    federation_settings: Arc<dyn UserFederationSettingsQuery>,
-    base_url: String,
-}
-
-impl ActivityPubEventHandler {
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
-        ap_service: Arc<ActivityPubService>,
-        content_query: Arc<dyn LocalApContentQuery>,
-        review_repo: Arc<dyn ReviewRepository>,
-        movie_repo: Arc<dyn MovieQuery>,
-        goal_repo: Arc<dyn GoalQuery>,
-        stats_repo: Arc<dyn StatsRepository>,
-        federation_settings: Arc<dyn UserFederationSettingsQuery>,
-        base_url: String,
-    ) -> Self {
-        Self {
-            ap_service,
-            content_query,
-            review_repo,
-            movie_repo,
-            goal_repo,
-            stats_repo,
-            federation_settings,
-            base_url,
-        }
-    }
-}
-
-#[async_trait]
-impl EventHandler for ActivityPubEventHandler {
-    async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
-        match event {
-            DomainEvent::ReviewLogged {
-                review_id, user_id, ..
-            } => self
-                .on_review_logged(user_id, review_id)
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::ReviewUpdated {
-                review_id, user_id, ..
-            } => self
-                .on_review_updated(user_id, review_id)
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::ReviewDeleted { review_id, user_id } => self
-                .on_review_deleted(user_id, review_id)
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::UserUpdated { user_id } => self
-                .ap_service
-                .broadcast_actor_update(user_id.value())
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::WatchlistEntryAdded {
-                user_id,
-                movie_id,
-                movie_title,
-                release_year,
-                external_metadata_id,
-                added_at,
-            } => self
-                .on_watchlist_added(
-                    user_id,
-                    movie_id,
-                    movie_title,
-                    *release_year,
-                    external_metadata_id,
-                    added_at,
-                )
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::WatchlistEntryRemoved { user_id, movie_id } => self
-                .on_watchlist_removed(user_id, movie_id)
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::FederationDeliveryRequested {
-                inbox_url,
-                activity_json,
-                signing_actor_id,
-            } => {
-                let inbox: url::Url = inbox_url
-                    .parse()
-                    .map_err(|e| DomainError::InfrastructureError(format!("bad inbox URL: {e}")))?;
-                self.ap_service
-                    .deliver_to_inbox(inbox, activity_json.clone(), *signing_actor_id)
-                    .await
-                    .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-            }
-            DomainEvent::PosterSynced { movie_id } => self
-                .on_poster_synced(movie_id)
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::GoalCreated {
-                user_id,
-                year,
-                target_count,
-                ..
-            } => self
-                .broadcast_goal(user_id, *year, *target_count, true)
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::GoalUpdated {
-                user_id,
-                year,
-                target_count,
-                ..
-            } => self
-                .broadcast_goal(user_id, *year, *target_count, false)
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::GoalDeleted { user_id, year, .. } => self
-                .on_goal_deleted(user_id, *year)
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-            DomainEvent::UserDeleted { user_id } => {
-                let ap_id = actor_url(&self.base_url, user_id.value());
-                self.ap_service
-                    .broadcast_delete_to_followers(user_id.value(), ap_id)
-                    .await
-                    .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-            }
-            DomainEvent::UserAccountMoved {
-                user_id,
-                new_actor_url,
-            } => {
-                let target = new_actor_url.parse::<url::Url>().map_err(|e| {
-                    DomainError::InfrastructureError(format!("invalid new_actor_url: {e}"))
-                })?;
-                self.ap_service
-                    .broadcast_move(user_id.value(), target)
-                    .await
-                    .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-            }
-            _ => Ok(()),
-        }
-    }
-}
-
-impl ActivityPubEventHandler {
-    async fn on_review_logged(&self, user_id: &UserId, review_id: &ReviewId) -> anyhow::Result<()> {
-        let flags = self
-            .federation_settings
-            .get_federation_flags(user_id)
-            .await
-            .unwrap_or_default();
-        if !flags.reviews {
-            return Ok(());
-        }
-
-        let review = match self.review_repo.get_review_by_id(review_id).await? {
-            Some(r) => r,
-            None => return Ok(()),
-        };
-
-        let ap_id = review_url(&self.base_url, review_id);
-        let actor = actor_url(&self.base_url, user_id.value());
-
-        let movie = self
-            .movie_repo
-            .get_movie_by_id(review.movie_id())
-            .await
-            .ok()
-            .flatten();
-        let movie_title = movie
-            .as_ref()
-            .map(|m| m.title().value().to_string())
-            .unwrap_or_else(|| "Unknown".to_string());
-        let release_year = movie
-            .as_ref()
-            .map(|m| m.release_year().value())
-            .unwrap_or(0);
-        let obj = review_to_ap_object(
-            &review,
-            ReviewApInput {
-                ap_id: ap_id.clone(),
-                actor_url: actor,
-                movie_title,
-                release_year,
-                external_metadata_id: movie
-                    .as_ref()
-                    .and_then(|m| m.external_metadata_id())
-                    .map(|id| id.value().to_string()),
-                poster_url: movie
-                    .as_ref()
-                    .and_then(|m| m.poster_path())
-                    .map(|p| format!("{}/images/{}", self.base_url, p.value())),
-                base_url: self.base_url.clone(),
-            },
-        );
-        let json = serde_json::to_value(obj)?;
-
-        self.ap_service
-            .broadcast_create(user_id.value(), json, ApVisibility::Public, vec![])
-            .await?;
-
-        let year = review.watched_at().year() as u16;
-        self.broadcast_goal_progress_update(user_id, year).await?;
-
-        Ok(())
-    }
-
-    async fn on_review_updated(
-        &self,
-        user_id: &UserId,
-        review_id: &ReviewId,
-    ) -> anyhow::Result<()> {
-        let flags = self
-            .federation_settings
-            .get_federation_flags(user_id)
-            .await
-            .unwrap_or_default();
-        if !flags.reviews {
-            return Ok(());
-        }
-
-        let review = match self.review_repo.get_review_by_id(review_id).await? {
-            Some(r) => r,
-            None => return Ok(()),
-        };
-
-        let ap_id = review_url(&self.base_url, review_id);
-        let actor = actor_url(&self.base_url, user_id.value());
-
-        let movie = self
-            .movie_repo
-            .get_movie_by_id(review.movie_id())
-            .await
-            .ok()
-            .flatten();
-        let movie_title = movie
-            .as_ref()
-            .map(|m| m.title().value().to_string())
-            .unwrap_or_else(|| "Unknown".to_string());
-        let release_year = movie
-            .as_ref()
-            .map(|m| m.release_year().value())
-            .unwrap_or(0);
-        let obj = review_to_ap_object(
-            &review,
-            ReviewApInput {
-                ap_id,
-                actor_url: actor,
-                movie_title,
-                release_year,
-                external_metadata_id: movie
-                    .as_ref()
-                    .and_then(|m| m.external_metadata_id())
-                    .map(|id| id.value().to_string()),
-                poster_url: movie
-                    .as_ref()
-                    .and_then(|m| m.poster_path())
-                    .map(|p| format!("{}/images/{}", self.base_url, p.value())),
-                base_url: self.base_url.clone(),
-            },
-        );
-        let json = serde_json::to_value(obj)?;
-
-        self.ap_service
-            .broadcast_update(user_id.value(), json, ApVisibility::Public, vec![])
-            .await?;
-
-        Ok(())
-    }
-
-    async fn on_review_deleted(
-        &self,
-        user_id: &UserId,
-        review_id: &ReviewId,
-    ) -> anyhow::Result<()> {
-        let ap_id = review_url(&self.base_url, review_id);
-        self.ap_service
-            .broadcast_delete_to_followers(user_id.value(), ap_id)
-            .await?;
-        Ok(())
-    }
-
-    async fn on_watchlist_added(
-        &self,
-        user_id: &UserId,
-        movie_id: &domain::value_objects::MovieId,
-        movie_title: &str,
-        release_year: u16,
-        external_metadata_id: &Option<String>,
-        added_at: &chrono::NaiveDateTime,
-    ) -> anyhow::Result<()> {
-        let flags = self
-            .federation_settings
-            .get_federation_flags(user_id)
-            .await
-            .unwrap_or_default();
-        if !flags.watchlist {
-            return Ok(());
-        }
-
-        use crate::urls::watchlist_entry_url;
-        let ap_id = watchlist_entry_url(&self.base_url, user_id.value(), movie_id.value());
-        let actor = actor_url(&self.base_url, user_id.value());
-
-        let poster_url = self
-            .movie_repo
-            .get_movie_by_id(movie_id)
-            .await
-            .ok()
-            .flatten()
-            .and_then(|m| {
-                m.poster_path()
-                    .map(|p| format!("{}/images/{}", self.base_url, p.value()))
-            });
-
-        let added_at_utc =
-            chrono::DateTime::<chrono::Utc>::from_naive_utc_and_offset(*added_at, chrono::Utc);
-        let obj = crate::objects::watchlist_to_ap_object(crate::objects::WatchlistApInput {
-            ap_id: ap_id.clone(),
-            actor_url: actor,
-            movie_title: movie_title.to_string(),
-            release_year,
-            external_metadata_id: external_metadata_id.clone(),
-            poster_url,
-            added_at: added_at_utc,
-            base_url: self.base_url.clone(),
-        });
-        let json = serde_json::to_value(obj)?;
-
-        self.ap_service
-            .broadcast_create(user_id.value(), json, ApVisibility::Public, vec![])
-            .await?;
-        Ok(())
-    }
-
-    async fn on_watchlist_removed(
-        &self,
-        user_id: &UserId,
-        movie_id: &domain::value_objects::MovieId,
-    ) -> anyhow::Result<()> {
-        use crate::urls::watchlist_entry_url;
-        let ap_id = watchlist_entry_url(&self.base_url, user_id.value(), movie_id.value());
-        self.ap_service
-            .broadcast_delete_to_followers(user_id.value(), ap_id)
-            .await?;
-        Ok(())
-    }
-
-    async fn on_poster_synced(&self, movie_id: &MovieId) -> anyhow::Result<()> {
-        let entries = self
-            .content_query
-            .get_local_reviews_for_movie(movie_id)
-            .await?;
-
-        let movie = self.movie_repo.get_movie_by_id(movie_id).await?;
-        let movie = match movie {
-            Some(m) => m,
-            None => return Ok(()),
-        };
-        let external_metadata_id = movie
-            .external_metadata_id()
-            .map(|id| id.value().to_string());
-        let poster_url = movie
-            .poster_path()
-            .map(|p| format!("{}/images/{}", self.base_url, p.value()));
-
-        for entry in entries {
-            let review = entry.review();
-            let user_id = review.user_id();
-
-            let flags = self
-                .federation_settings
-                .get_federation_flags(user_id)
-                .await
-                .unwrap_or_default();
-            if !flags.reviews {
-                continue;
-            }
-
-            let ap_id = review_url(&self.base_url, review.id());
-            let actor = actor_url(&self.base_url, user_id.value());
-
-            let obj = review_to_ap_object(
-                review,
-                ReviewApInput {
-                    ap_id,
-                    actor_url: actor,
-                    movie_title: movie.title().value().to_string(),
-                    release_year: movie.release_year().value(),
-                    external_metadata_id: external_metadata_id.clone(),
-                    poster_url: poster_url.clone(),
-                    base_url: self.base_url.clone(),
-                },
-            );
-            let json = serde_json::to_value(obj)?;
-
-            self.ap_service
-                .broadcast_update(user_id.value(), json, ApVisibility::Public, vec![])
-                .await?;
-        }
-
-        Ok(())
-    }
-
-    async fn broadcast_goal_progress_update(
-        &self,
-        user_id: &UserId,
-        year: u16,
-    ) -> anyhow::Result<()> {
-        let flags = self
-            .federation_settings
-            .get_federation_flags(user_id)
-            .await
-            .unwrap_or_default();
-        if !flags.goals {
-            return Ok(());
-        }
-        let Some(goal) = self
-            .goal_repo
-            .find_by_user_and_year(user_id, year)
-            .await
-            .ok()
-            .flatten()
-        else {
-            return Ok(());
-        };
-        let current = self
-            .stats_repo
-            .count_reviews_in_year(user_id, year)
-            .await
-            .unwrap_or(0);
-        let ap_id = goal_url(&self.base_url, user_id.value(), year);
-        let actor = actor_url(&self.base_url, user_id.value());
-        let obj = goal_to_ap_object(
-            ap_id,
-            actor,
-            year,
-            goal.target_count(),
-            current,
-            &self.base_url,
-        );
-        let json = serde_json::to_value(obj)?;
-        self.ap_service
-            .broadcast_update(user_id.value(), json, ApVisibility::Public, vec![])
-            .await?;
-        Ok(())
-    }
-
-    async fn broadcast_goal(
-        &self,
-        user_id: &UserId,
-        year: u16,
-        target_count: u32,
-        is_create: bool,
-    ) -> anyhow::Result<()> {
-        let flags = self
-            .federation_settings
-            .get_federation_flags(user_id)
-            .await
-            .unwrap_or_default();
-        if !flags.goals {
-            return Ok(());
-        }
-        let current = self
-            .stats_repo
-            .count_reviews_in_year(user_id, year)
-            .await
-            .unwrap_or(0);
-
-        let ap_id = goal_url(&self.base_url, user_id.value(), year);
-        let actor = actor_url(&self.base_url, user_id.value());
-        let obj = goal_to_ap_object(ap_id, actor, year, target_count, current, &self.base_url);
-        let json = serde_json::to_value(obj)?;
-        if is_create {
-            self.ap_service
-                .broadcast_create(user_id.value(), json, ApVisibility::Public, vec![])
-                .await?;
-        } else {
-            self.ap_service
-                .broadcast_update(user_id.value(), json, ApVisibility::Public, vec![])
-                .await?;
-        }
-        Ok(())
-    }
-
-    async fn on_goal_deleted(&self, user_id: &UserId, year: u16) -> anyhow::Result<()> {
-        let flags = self
-            .federation_settings
-            .get_federation_flags(user_id)
-            .await
-            .unwrap_or_default();
-        if !flags.goals {
-            return Ok(());
-        }
-        let ap_id = goal_url(&self.base_url, user_id.value(), year);
-        self.ap_service
-            .broadcast_delete_to_followers(user_id.value(), ap_id)
-            .await?;
-        Ok(())
-    }
-}

crates/adapters/activitypub/src/federation_event_bridge.rs

@@ -1,73 +0,0 @@
-use std::sync::Arc;
-
-use domain::events::DomainEvent;
-use domain::value_objects::UserId;
-use k_ap::FederationEvent;
-
-pub struct FederationEventBridge {
-    domain_publisher: Arc<dyn domain::ports::EventPublisher>,
-}
-
-impl FederationEventBridge {
-    pub fn new(domain_publisher: Arc<dyn domain::ports::EventPublisher>) -> Self {
-        Self { domain_publisher }
-    }
-}
-
-#[async_trait::async_trait]
-impl k_ap::EventPublisher for FederationEventBridge {
-    async fn publish(&self, event: FederationEvent) -> anyhow::Result<()> {
-        match event {
-            FederationEvent::BackfillRequested {
-                owner_user_id,
-                follower_inbox_url,
-            } => self
-                .domain_publisher
-                .publish(&DomainEvent::BackfillFollower {
-                    owner_user_id: UserId::from_uuid(owner_user_id),
-                    follower_inbox_url,
-                })
-                .await
-                .map_err(|e| anyhow::anyhow!(e.to_string())),
-            FederationEvent::DeliveryRequested {
-                inbox,
-                activity,
-                signing_actor_id,
-            } => self
-                .domain_publisher
-                .publish(&DomainEvent::FederationDeliveryRequested {
-                    inbox_url: inbox.to_string(),
-                    activity_json: activity,
-                    signing_actor_id,
-                })
-                .await
-                .map_err(|e| anyhow::anyhow!(e.to_string())),
-            FederationEvent::DeliveryFailed { inbox, error, .. } => {
-                tracing::warn!(inbox = %inbox, error = %error, "federation delivery failed permanently");
-                Ok(())
-            }
-            FederationEvent::OutboundFollowAccepted {
-                local_user_id,
-                remote_actor_url,
-                outbox_url,
-            } => {
-                let identity = domain::value_objects::SocialIdentity::Remote {
-                    actor_url: remote_actor_url,
-                };
-                self.domain_publisher
-                    .publish(&DomainEvent::FollowAccepted {
-                        owner: UserId::from_uuid(local_user_id),
-                        requester: identity,
-                    })
-                    .await
-                    .map_err(|e| anyhow::anyhow!(e.to_string()))?;
-
-                if let Some(outbox) = outbox_url {
-                    tracing::info!(outbox = %outbox, "importing remote outbox after follow accepted");
-                    // Handled by FollowBackfillHandler reacting to FollowAccepted
-                }
-                Ok(())
-            }
-        }
-    }
-}

crates/adapters/activitypub/src/goal_handler.rs

@@ -1,150 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use chrono::DateTime;
-use domain::{
-    models::RemoteGoalEntry,
-    ports::{GoalQuery, RemoteGoalRepository},
-    value_objects::UserId,
-};
-use k_ap::{AS_PUBLIC, ApContentReader, ApObjectHandler, LocalObject};
-use url::Url;
-
-use crate::objects::{GoalObject, goal_to_ap_object};
-use crate::urls::{actor_url, goal_url};
-
-pub struct GoalObjectHandler {
-    pub remote_goal_repo: Arc<dyn RemoteGoalRepository>,
-    pub goal_repo: Arc<dyn GoalQuery>,
-    pub base_url: String,
-}
-
-#[async_trait]
-impl ApContentReader for GoalObjectHandler {
-    async fn get_local_objects_page(
-        &self,
-        user_id: uuid::Uuid,
-        _before: Option<DateTime<chrono::Utc>>,
-        _limit: usize,
-    ) -> anyhow::Result<Vec<LocalObject>> {
-        let uid = UserId::from_uuid(user_id);
-        let goals = self
-            .goal_repo
-            .list_for_user(&uid)
-            .await
-            .map_err(|e| anyhow::anyhow!(e.to_string()))?;
-
-        let actor = actor_url(&self.base_url, user_id);
-        let follower_cc = format!("{}/followers", actor);
-        let mut results = Vec::new();
-        for goal in goals {
-            let ap_id = goal_url(&self.base_url, user_id, goal.year());
-            let published = DateTime::from_naive_utc_and_offset(*goal.created_at(), chrono::Utc);
-            let obj = goal_to_ap_object(
-                ap_id.clone(),
-                actor.clone(),
-                goal.year(),
-                goal.target_count(),
-                0,
-                &self.base_url,
-            );
-            results.push(LocalObject {
-                ap_id,
-                object: serde_json::to_value(obj)?,
-                published_at: published,
-                to: vec![AS_PUBLIC.to_string()],
-                cc: vec![follower_cc.clone()],
-                bto: vec![],
-                bcc: vec![],
-            });
-        }
-        Ok(results)
-    }
-
-    async fn count_local_posts(&self) -> anyhow::Result<u64> {
-        Ok(0)
-    }
-}
-
-#[async_trait]
-impl ApObjectHandler for GoalObjectHandler {
-    async fn on_create(
-        &self,
-        ap_id: &Url,
-        actor_url: &Url,
-        object: serde_json::Value,
-    ) -> anyhow::Result<()> {
-        let obj: GoalObject = match serde_json::from_value(object) {
-            Ok(o) => o,
-            Err(e) => {
-                tracing::warn!(ap_id = %ap_id, "ignoring malformed goal Create: {}", e);
-                return Ok(());
-            }
-        };
-        let entry = RemoteGoalEntry {
-            ap_id: ap_id.as_str().to_string(),
-            actor_url: actor_url.as_str().to_string(),
-            year: obj.goal_year,
-            target_count: obj.goal_target,
-            current_count: obj.goal_current,
-            received_at: chrono::Utc::now(),
-        };
-        self.remote_goal_repo.save(entry).await?;
-        tracing::info!(ap_id = %ap_id, year = obj.goal_year, "saved remote goal");
-        Ok(())
-    }
-
-    async fn on_update(
-        &self,
-        ap_id: &Url,
-        actor_url: &Url,
-        object: serde_json::Value,
-    ) -> anyhow::Result<()> {
-        let obj: GoalObject = match serde_json::from_value(object) {
-            Ok(o) => o,
-            Err(e) => {
-                tracing::warn!(ap_id = %ap_id, "ignoring malformed goal Update: {}", e);
-                return Ok(());
-            }
-        };
-        if obj.attributed_to != *actor_url {
-            anyhow::bail!("goal Update actor does not match object attributed_to");
-        }
-        self.remote_goal_repo
-            .update_by_ap_id(ap_id.as_str(), obj.goal_target, obj.goal_current)
-            .await?;
-        tracing::info!(ap_id = %ap_id, "updated remote goal progress");
-        Ok(())
-    }
-
-    async fn on_delete(&self, ap_id: &Url, actor_url: &Url) -> anyhow::Result<()> {
-        self.remote_goal_repo
-            .remove_by_ap_id(ap_id.as_str(), actor_url.as_str())
-            .await?;
-        tracing::info!(ap_id = %ap_id, "removed remote goal");
-        Ok(())
-    }
-
-    async fn on_actor_removed(&self, actor_url: &Url) -> anyhow::Result<()> {
-        self.remote_goal_repo
-            .remove_all_by_actor(actor_url.as_str())
-            .await?;
-        Ok(())
-    }
-
-    async fn on_like(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_announce_received(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_announce_of_remote(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_unlike(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_mention(&self, _: &Url, _: uuid::Uuid, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-}

crates/adapters/activitypub/src/lib.rs

@@ -1,176 +0,0 @@
-pub mod composite_handler;
-pub mod event_handler;
-pub mod federation_event_bridge;
-pub mod goal_handler;
-pub mod objects;
-pub mod port;
-pub mod remote_review_repository;
-pub mod review_handler;
-pub mod social_adapter;
-pub(crate) mod urls;
-pub mod user_adapter;
-pub mod watchlist_handler;
-
-pub const INSTANCE_ACTOR_ID: uuid::Uuid =
-    uuid::Uuid::from_bytes([0, 0, 0, 0, 0, 0, 0x40, 0, 0x80, 0, 0, 0, 0, 0, 0, 0]);
-
-// Re-export the generic base types that callers need
-pub use k_ap::{
-    ActivityPubService, ActivityRepository, ActorRepository, ApContentReader, ApFederationConfig,
-    ApObjectHandler, ApUser, ApUserRepository, BlocklistRepository, FederationData,
-    FollowRepository, Follower, FollowerStatus, FollowingStatus, LocalObject, RemoteActor,
-};
-
-pub use event_handler::ActivityPubEventHandler;
-pub use port::{ActivityPubPort, NoopActivityPubService};
-pub use remote_review_repository::{RemoteReviewRepository, RemoteReviewUpdate};
-pub use review_handler::ReviewObjectHandler;
-pub use social_adapter::CompositeSocialAdapter;
-pub use user_adapter::DomainUserRepoAdapter;
-
-pub struct FederationRepos {
-    pub activity: std::sync::Arc<dyn ActivityRepository>,
-    pub follow: std::sync::Arc<dyn FollowRepository>,
-    pub actor: std::sync::Arc<dyn ActorRepository>,
-    pub blocklist: std::sync::Arc<dyn BlocklistRepository>,
-    pub admin_query: std::sync::Arc<dyn domain::ports::FederationAdminQuery>,
-    pub review_store: std::sync::Arc<dyn RemoteReviewRepository>,
-    pub remote_watchlist: std::sync::Arc<dyn domain::ports::RemoteWatchlistRepository>,
-    pub follow_command: std::sync::Arc<dyn domain::ports::FollowCommand>,
-    pub follow_query: std::sync::Arc<dyn domain::ports::FollowQuery>,
-}
-
-pub struct ActivityPubWire {
-    pub service: std::sync::Arc<dyn ActivityPubPort>,
-    pub router: axum::Router,
-    pub event_handler: std::sync::Arc<dyn domain::ports::EventHandler>,
-}
-
-pub struct ActivityPubDeps {
-    pub activity_repo: std::sync::Arc<dyn ActivityRepository>,
-    pub follow_repo: std::sync::Arc<dyn FollowRepository>,
-    pub actor_repo: std::sync::Arc<dyn ActorRepository>,
-    pub blocklist_repo: std::sync::Arc<dyn BlocklistRepository>,
-    pub review_store: std::sync::Arc<dyn RemoteReviewRepository>,
-    pub remote_watchlist_repo: std::sync::Arc<dyn domain::ports::RemoteWatchlistRepository>,
-    pub remote_goal_repo: std::sync::Arc<dyn domain::ports::RemoteGoalRepository>,
-    pub local_ap_content: std::sync::Arc<dyn domain::ports::LocalApContentQuery>,
-    pub movie_repo: std::sync::Arc<dyn domain::ports::MovieQuery>,
-    pub review_repo: std::sync::Arc<dyn domain::ports::ReviewRepository>,
-    pub diary_repo: std::sync::Arc<dyn domain::ports::DiaryQuery>,
-    pub goal_repo: std::sync::Arc<dyn domain::ports::GoalQuery>,
-    pub stats_repo: std::sync::Arc<dyn domain::ports::StatsRepository>,
-    pub user_repo: std::sync::Arc<dyn domain::ports::UserRepository>,
-    pub federation_settings: std::sync::Arc<dyn domain::ports::UserFederationSettingsQuery>,
-    pub follow_command: std::sync::Arc<dyn domain::ports::FollowCommand>,
-    pub follow_query: std::sync::Arc<dyn domain::ports::FollowQuery>,
-    pub base_url: String,
-    pub allow_registration: bool,
-    pub event_publisher: std::sync::Arc<dyn domain::ports::EventPublisher>,
-}
-
-pub async fn wire(deps: ActivityPubDeps) -> anyhow::Result<ActivityPubWire> {
-    let ActivityPubDeps {
-        activity_repo,
-        follow_repo,
-        actor_repo,
-        blocklist_repo,
-        review_store,
-        remote_watchlist_repo,
-        remote_goal_repo,
-        local_ap_content,
-        movie_repo,
-        review_repo,
-        diary_repo,
-        goal_repo,
-        stats_repo,
-        user_repo,
-        federation_settings,
-        follow_command: _,
-        follow_query: _,
-        base_url,
-        allow_registration,
-        event_publisher,
-    } = deps;
-    let review_handler = std::sync::Arc::new(ReviewObjectHandler {
-        content_query: std::sync::Arc::clone(&local_ap_content),
-        movie_repo: std::sync::Arc::clone(&movie_repo),
-        diary_repo,
-        review_store,
-        event_publisher: std::sync::Arc::clone(&event_publisher),
-        base_url: base_url.clone(),
-    });
-    let watchlist_handler = std::sync::Arc::new(watchlist_handler::WatchlistObjectHandler {
-        remote_watchlist_repo,
-        content_query: std::sync::Arc::clone(&local_ap_content),
-        base_url: base_url.clone(),
-    });
-    let goal_handler = std::sync::Arc::new(goal_handler::GoalObjectHandler {
-        remote_goal_repo,
-        goal_repo: std::sync::Arc::clone(&goal_repo),
-        base_url: base_url.clone(),
-    });
-    let composite = std::sync::Arc::new(composite_handler::CompositeObjectHandler {
-        review: review_handler,
-        watchlist: watchlist_handler,
-        goal: goal_handler,
-    });
-
-    let federation_debug = std::env::var("FEDERATION_DEBUG")
-        .map(|v| v == "true" || v == "1")
-        .unwrap_or(false);
-
-    if federation_debug {
-        tracing::warn!(
-            "federation running in DEBUG mode — PermissiveVerifier active, \
-             no URL/signature validation. Do NOT use in production."
-        );
-    }
-
-    let fed_event_bridge = std::sync::Arc::new(
-        federation_event_bridge::FederationEventBridge::new(event_publisher),
-    );
-
-    let concrete = std::sync::Arc::new(
-        ActivityPubService::builder(base_url.clone())
-            .activity_repo(activity_repo)
-            .follow_repo(follow_repo)
-            .actor_repo(actor_repo)
-            .blocklist_repo(blocklist_repo)
-            .user_repo(std::sync::Arc::new(DomainUserRepoAdapter::new(
-                user_repo,
-                base_url.clone(),
-            )))
-            .signed_fetch_actor_id(INSTANCE_ACTOR_ID)
-            .content_reader(composite.clone() as std::sync::Arc<dyn ApContentReader>)
-            .object_handler(composite as std::sync::Arc<dyn ApObjectHandler>)
-            .event_publisher(fed_event_bridge)
-            .allow_registration(allow_registration)
-            .software_name("movies-diary")
-            .nodeinfo_metadata(serde_json::json!({
-                "nodeName": "movies-diary",
-                "nodeDescription": "A federated movie diary"
-            }))
-            .debug(federation_debug)
-            .build()
-            .await?,
-    );
-
-    let router = concrete.router();
-    let event_handler = std::sync::Arc::new(ActivityPubEventHandler::new(
-        std::sync::Arc::clone(&concrete),
-        local_ap_content,
-        review_repo,
-        movie_repo,
-        goal_repo,
-        stats_repo,
-        federation_settings,
-        base_url,
-    )) as std::sync::Arc<dyn domain::ports::EventHandler>;
-
-    Ok(ActivityPubWire {
-        service: concrete as std::sync::Arc<dyn ActivityPubPort>,
-        router,
-        event_handler,
-    })
-}

crates/adapters/activitypub/src/objects.rs

@@ -1,303 +0,0 @@
-use chrono::{DateTime, Utc};
-use k_ap::AS_PUBLIC;
-use serde::{Deserialize, Serialize};
-use url::Url;
-
-use domain::models::Review;
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub(crate) enum ActivityStreamsType {
-    #[default]
-    Note,
-    Article,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ApAttachment {
-    #[serde(rename = "type")]
-    pub(crate) kind: String,
-    pub(crate) url: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(crate) media_type: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub(crate) name: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct ApHashtag {
-    #[serde(rename = "type")]
-    pub(crate) kind: String,
-    pub(crate) href: Url,
-    pub(crate) name: String,
-}
-
-pub(crate) fn normalize_hashtag(title: &str) -> String {
-    title.chars().filter(|c| c.is_alphanumeric()).collect()
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ReviewObject {
-    #[serde(rename = "type")]
-    pub(crate) kind: ActivityStreamsType,
-    pub(crate) id: Url,
-    pub(crate) attributed_to: Url,
-    pub(crate) content: String,
-    pub(crate) published: DateTime<Utc>,
-    pub(crate) movie_title: String,
-    #[serde(default)]
-    pub(crate) release_year: u16,
-    #[serde(default)]
-    pub(crate) external_metadata_id: Option<String>,
-    #[serde(default)]
-    pub(crate) poster_url: Option<String>,
-    pub(crate) rating: u8,
-    pub(crate) comment: Option<String>,
-    pub(crate) watched_at: DateTime<Utc>,
-    #[serde(skip_serializing_if = "Option::is_none", default)]
-    pub(crate) watch_medium: Option<String>,
-    /// Discriminator so Movies Diary instances detect this as a review Note.
-    #[serde(default)]
-    pub(crate) review: bool,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub(crate) attachment: Vec<ApAttachment>,
-    #[serde(default)]
-    pub(crate) tag: Vec<ApHashtag>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub(crate) to: Vec<String>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub(crate) cc: Vec<String>,
-}
-
-pub struct ReviewApInput {
-    pub ap_id: Url,
-    pub actor_url: Url,
-    pub movie_title: String,
-    pub release_year: u16,
-    pub external_metadata_id: Option<String>,
-    pub poster_url: Option<String>,
-    pub base_url: String,
-}
-
-pub fn review_to_ap_object(review: &Review, input: ReviewApInput) -> ReviewObject {
-    let ReviewApInput {
-        ap_id,
-        actor_url,
-        movie_title,
-        release_year,
-        external_metadata_id,
-        poster_url,
-        base_url,
-    } = input;
-    let stars: String = "\u{2B50}".repeat(review.rating().value() as usize);
-    let comment_text = review.comment().map(|c| c.value().to_string());
-    let year_str = if release_year > 0 {
-        format!(" ({})", release_year)
-    } else {
-        String::new()
-    };
-    let watched_str = format!("Watched: {}", review.watched_at().format("%b %-d, %Y"));
-    let content = match &comment_text {
-        Some(c) => format!(
-            "{} {}{}\n{}\n{}",
-            stars, movie_title, year_str, c, watched_str
-        ),
-        None => format!("{} {}{}\n{}", stars, movie_title, year_str, watched_str),
-    };
-
-    let normalized = normalize_hashtag(&movie_title);
-    let tag = vec![
-        ApHashtag {
-            kind: "Hashtag".to_string(),
-            href: Url::parse(&format!("{}/tags/moviesdiary", base_url)).expect("valid base_url"),
-            name: "#MoviesDiary".to_string(),
-        },
-        ApHashtag {
-            kind: "Hashtag".to_string(),
-            href: Url::parse(&format!("{}/tags/{}", base_url, normalized.to_lowercase()))
-                .expect("valid base_url"),
-            name: format!("#{}", normalized),
-        },
-    ];
-    let attachment = match &poster_url {
-        Some(url) => vec![ApAttachment {
-            kind: "Image".to_string(),
-            url: url.clone(),
-            media_type: Some("image/jpeg".to_string()),
-            name: Some(movie_title.clone()),
-        }],
-        None => vec![],
-    };
-
-    ReviewObject {
-        kind: ActivityStreamsType::default(),
-        id: ap_id,
-        attributed_to: actor_url.clone(),
-        content,
-        published: DateTime::from_naive_utc_and_offset(*review.created_at(), Utc),
-        movie_title,
-        release_year,
-        external_metadata_id,
-        poster_url,
-        rating: review.rating().value(),
-        comment: comment_text,
-        watched_at: DateTime::from_naive_utc_and_offset(*review.watched_at(), Utc),
-        watch_medium: review.watch_medium().map(|wm| wm.to_string()),
-        review: true,
-        attachment,
-        tag,
-        to: vec![AS_PUBLIC.to_string()],
-        cc: vec![format!("{}/followers", actor_url)],
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct WatchlistObject {
-    #[serde(rename = "type")]
-    pub(crate) kind: ActivityStreamsType,
-    pub(crate) id: Url,
-    pub(crate) attributed_to: Url,
-    pub(crate) content: String,
-    pub(crate) published: chrono::DateTime<chrono::Utc>,
-    pub(crate) movie_title: String,
-    #[serde(default)]
-    pub(crate) release_year: u16,
-    #[serde(default)]
-    pub(crate) external_metadata_id: Option<String>,
-    #[serde(default)]
-    pub(crate) poster_url: Option<String>,
-    #[serde(default)]
-    pub(crate) tag: Vec<ApHashtag>,
-    /// Discriminator so Movies Diary instances distinguish this from a review Note.
-    /// Non-Movies-Diary apps ignore unknown fields.
-    #[serde(default)]
-    pub(crate) watchlist_entry: bool,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub(crate) to: Vec<String>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub(crate) cc: Vec<String>,
-}
-
-pub struct WatchlistApInput {
-    pub ap_id: Url,
-    pub actor_url: Url,
-    pub movie_title: String,
-    pub release_year: u16,
-    pub external_metadata_id: Option<String>,
-    pub poster_url: Option<String>,
-    pub added_at: chrono::DateTime<chrono::Utc>,
-    pub base_url: String,
-}
-
-pub fn watchlist_to_ap_object(input: WatchlistApInput) -> WatchlistObject {
-    let WatchlistApInput {
-        ap_id,
-        actor_url,
-        movie_title,
-        release_year,
-        external_metadata_id,
-        poster_url,
-        added_at,
-        base_url,
-    } = input;
-    let year_str = if release_year > 0 {
-        format!(" ({})", release_year)
-    } else {
-        String::new()
-    };
-    let content = format!("📋 {}{} — want to watch", movie_title, year_str);
-    let normalized = normalize_hashtag(&movie_title);
-    let tag = vec![
-        ApHashtag {
-            kind: "Hashtag".to_string(),
-            href: Url::parse(&format!("{}/tags/moviesdiary", base_url)).expect("valid base_url"),
-            name: "#MoviesDiary".to_string(),
-        },
-        ApHashtag {
-            kind: "Hashtag".to_string(),
-            href: Url::parse(&format!("{}/tags/{}", base_url, normalized.to_lowercase()))
-                .expect("valid base_url"),
-            name: format!("#{}", normalized),
-        },
-    ];
-
-    WatchlistObject {
-        kind: ActivityStreamsType::default(),
-        id: ap_id,
-        attributed_to: actor_url.clone(),
-        content,
-        published: added_at,
-        movie_title,
-        release_year,
-        external_metadata_id,
-        poster_url,
-        tag,
-        watchlist_entry: true,
-        to: vec![AS_PUBLIC.to_string()],
-        cc: vec![format!("{}/followers", actor_url)],
-    }
-}
-
-// ── Goal object ──────────────────────────────────────────────────────────────
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GoalObject {
-    #[serde(rename = "type")]
-    pub(crate) kind: ActivityStreamsType,
-    pub(crate) id: Url,
-    pub(crate) attributed_to: Url,
-    pub(crate) content: String,
-    pub(crate) published: chrono::DateTime<chrono::Utc>,
-    pub(crate) goal_year: u16,
-    pub(crate) goal_target: u32,
-    pub(crate) goal_current: u32,
-    #[serde(default)]
-    pub(crate) goal: bool,
-    #[serde(default)]
-    pub(crate) tag: Vec<ApHashtag>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub(crate) to: Vec<String>,
-    #[serde(skip_serializing_if = "Vec::is_empty", default)]
-    pub(crate) cc: Vec<String>,
-}
-
-pub fn goal_to_ap_object(
-    ap_id: Url,
-    actor_url: Url,
-    year: u16,
-    target: u32,
-    current: u32,
-    base_url: &str,
-) -> GoalObject {
-    let content = format!(
-        "🎯 Goal: Watch {} movies in {} ({}/{})",
-        target, year, current, target
-    );
-    let tag = vec![ApHashtag {
-        kind: "Hashtag".to_string(),
-        href: Url::parse(&format!("{}/tags/moviesdiary", base_url)).expect("valid base_url"),
-        name: "#MoviesDiary".to_string(),
-    }];
-
-    GoalObject {
-        kind: ActivityStreamsType::default(),
-        id: ap_id,
-        attributed_to: actor_url.clone(),
-        content,
-        published: chrono::Utc::now(),
-        goal_year: year,
-        goal_target: target,
-        goal_current: current,
-        goal: true,
-        tag,
-        to: vec![AS_PUBLIC.to_string()],
-        cc: vec![format!("{}/followers", actor_url)],
-    }
-}
-
-#[cfg(test)]
-#[path = "tests/objects.rs"]
-mod tests;

crates/adapters/activitypub/src/port.rs

@@ -1,178 +0,0 @@
-use async_trait::async_trait;
-use uuid::Uuid;
-
-use k_ap::{ActivityPubService, BlockedDomain, RemoteActor};
-
-#[async_trait]
-pub trait ActivityPubPort: Send + Sync {
-    async fn actor_json(&self, user_id: &str) -> anyhow::Result<String>;
-    async fn follow(&self, local_user_id: Uuid, handle: &str) -> anyhow::Result<()>;
-    async fn unfollow(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()>;
-    async fn accept_follower(
-        &self,
-        local_user_id: Uuid,
-        remote_actor_url: &str,
-    ) -> anyhow::Result<()>;
-    async fn reject_follower(
-        &self,
-        local_user_id: Uuid,
-        remote_actor_url: &str,
-    ) -> anyhow::Result<()>;
-    async fn get_following(&self, local_user_id: Uuid) -> anyhow::Result<Vec<RemoteActor>>;
-    async fn remove_follower(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()>;
-    async fn block_actor(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()>;
-    async fn unblock_actor(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()>;
-    async fn get_blocked_actors(&self, local_user_id: Uuid) -> anyhow::Result<Vec<RemoteActor>>;
-    async fn add_blocked_domain(&self, domain: &str, reason: Option<&str>) -> anyhow::Result<()>;
-    async fn remove_blocked_domain(&self, domain: &str) -> anyhow::Result<()>;
-    async fn get_blocked_domains(&self) -> anyhow::Result<Vec<BlockedDomain>>;
-    async fn import_remote_outbox(&self, outbox_url: &str, actor_url: &str) -> anyhow::Result<()>;
-    async fn followers_collection_json(
-        &self,
-        user_id: Uuid,
-        page: Option<u32>,
-    ) -> anyhow::Result<String>;
-    async fn following_collection_json(
-        &self,
-        user_id: Uuid,
-        page: Option<u32>,
-    ) -> anyhow::Result<String>;
-    async fn run_backfill_for_follower(
-        &self,
-        owner_user_id: Uuid,
-        follower_inbox_url: String,
-    ) -> anyhow::Result<()>;
-}
-
-#[async_trait]
-impl ActivityPubPort for ActivityPubService {
-    async fn actor_json(&self, user_id: &str) -> anyhow::Result<String> {
-        self.actor_json(user_id).await
-    }
-    async fn follow(&self, local_user_id: Uuid, handle: &str) -> anyhow::Result<()> {
-        self.follow(local_user_id, handle).await
-    }
-    async fn unfollow(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()> {
-        self.unfollow(local_user_id, actor_url).await
-    }
-    async fn accept_follower(
-        &self,
-        local_user_id: Uuid,
-        remote_actor_url: &str,
-    ) -> anyhow::Result<()> {
-        self.accept_follower(local_user_id, remote_actor_url).await
-    }
-    async fn reject_follower(
-        &self,
-        local_user_id: Uuid,
-        remote_actor_url: &str,
-    ) -> anyhow::Result<()> {
-        self.reject_follower(local_user_id, remote_actor_url).await
-    }
-    async fn get_following(&self, local_user_id: Uuid) -> anyhow::Result<Vec<RemoteActor>> {
-        self.get_following(local_user_id).await
-    }
-    async fn remove_follower(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()> {
-        self.remove_follower(local_user_id, actor_url).await
-    }
-    async fn block_actor(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()> {
-        self.block_actor(local_user_id, actor_url).await
-    }
-    async fn unblock_actor(&self, local_user_id: Uuid, actor_url: &str) -> anyhow::Result<()> {
-        self.unblock_actor(local_user_id, actor_url).await
-    }
-    async fn get_blocked_actors(&self, local_user_id: Uuid) -> anyhow::Result<Vec<RemoteActor>> {
-        self.get_blocked_actors(local_user_id).await
-    }
-    async fn add_blocked_domain(&self, domain: &str, reason: Option<&str>) -> anyhow::Result<()> {
-        self.add_blocked_domain(domain, reason).await
-    }
-    async fn remove_blocked_domain(&self, domain: &str) -> anyhow::Result<()> {
-        self.remove_blocked_domain(domain).await
-    }
-    async fn get_blocked_domains(&self) -> anyhow::Result<Vec<BlockedDomain>> {
-        self.get_blocked_domains().await
-    }
-    async fn import_remote_outbox(&self, outbox_url: &str, actor_url: &str) -> anyhow::Result<()> {
-        self.import_remote_outbox(outbox_url, actor_url).await
-    }
-    async fn followers_collection_json(
-        &self,
-        user_id: Uuid,
-        page: Option<u32>,
-    ) -> anyhow::Result<String> {
-        self.followers_collection_json(user_id, page).await
-    }
-    async fn following_collection_json(
-        &self,
-        user_id: Uuid,
-        page: Option<u32>,
-    ) -> anyhow::Result<String> {
-        self.following_collection_json(user_id, page).await
-    }
-    async fn run_backfill_for_follower(
-        &self,
-        owner_user_id: Uuid,
-        follower_inbox_url: String,
-    ) -> anyhow::Result<()> {
-        self.run_backfill_for_follower(owner_user_id, follower_inbox_url)
-            .await
-    }
-}
-
-pub struct NoopActivityPubService;
-
-#[async_trait]
-impl ActivityPubPort for NoopActivityPubService {
-    async fn actor_json(&self, _: &str) -> anyhow::Result<String> {
-        Ok(String::new())
-    }
-    async fn follow(&self, _: Uuid, _: &str) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn unfollow(&self, _: Uuid, _: &str) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn accept_follower(&self, _: Uuid, _: &str) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn reject_follower(&self, _: Uuid, _: &str) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn get_following(&self, _: Uuid) -> anyhow::Result<Vec<RemoteActor>> {
-        Ok(vec![])
-    }
-    async fn remove_follower(&self, _: Uuid, _: &str) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn block_actor(&self, _: Uuid, _: &str) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn unblock_actor(&self, _: Uuid, _: &str) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn get_blocked_actors(&self, _: Uuid) -> anyhow::Result<Vec<RemoteActor>> {
-        Ok(vec![])
-    }
-    async fn add_blocked_domain(&self, _: &str, _: Option<&str>) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn remove_blocked_domain(&self, _: &str) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn get_blocked_domains(&self) -> anyhow::Result<Vec<BlockedDomain>> {
-        Ok(vec![])
-    }
-    async fn import_remote_outbox(&self, _: &str, _: &str) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn followers_collection_json(&self, _: Uuid, _: Option<u32>) -> anyhow::Result<String> {
-        Ok(String::new())
-    }
-    async fn following_collection_json(&self, _: Uuid, _: Option<u32>) -> anyhow::Result<String> {
-        Ok(String::new())
-    }
-    async fn run_backfill_for_follower(&self, _: Uuid, _: String) -> anyhow::Result<()> {
-        Ok(())
-    }
-}

crates/adapters/activitypub/src/remote_review_repository.rs

@@ -1,33 +0,0 @@
-use anyhow::Result;
-use async_trait::async_trait;
-use chrono::NaiveDateTime;
-use domain::models::Review;
-
-pub struct RemoteReviewUpdate<'a> {
-    pub ap_id: &'a str,
-    pub actor_url: &'a str,
-    pub rating: u8,
-    pub comment: Option<&'a str>,
-    pub watched_at: NaiveDateTime,
-    pub poster_url: Option<&'a str>,
-    pub watch_medium: Option<&'a str>,
-}
-
-#[async_trait]
-pub trait RemoteReviewRepository: Send + Sync {
-    async fn save_remote_review(
-        &self,
-        review: &Review,
-        ap_id: &str,
-        movie_title: &str,
-        release_year: u16,
-        external_metadata_id: Option<&str>,
-        poster_url: Option<&str>,
-    ) -> Result<()>;
-
-    async fn delete_remote_review(&self, ap_id: &str, actor_url: &str) -> Result<()>;
-
-    async fn update_remote_review(&self, update: RemoteReviewUpdate<'_>) -> Result<()>;
-
-    async fn delete_by_actor(&self, actor_url: &str) -> Result<()>;
-}

crates/adapters/activitypub/src/review_handler.rs

@@ -1,263 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use domain::{
-    events::DomainEvent,
-    models::ReviewSource,
-    ports::{DiaryQuery, EventPublisher, LocalApContentQuery, MovieQuery},
-    value_objects::{Comment, ExternalMetadataId, MovieId, Rating, ReviewId, UserId},
-};
-use k_ap::{AS_PUBLIC, ApContentReader, ApObjectHandler, LocalObject};
-use url::Url;
-
-use crate::objects::{ReviewApInput, ReviewObject, review_to_ap_object};
-use crate::remote_review_repository::RemoteReviewRepository;
-use crate::urls::{actor_url, review_url};
-
-pub struct ReviewObjectHandler {
-    pub content_query: Arc<dyn LocalApContentQuery>,
-    pub movie_repo: Arc<dyn MovieQuery>,
-    pub diary_repo: Arc<dyn DiaryQuery>,
-    pub review_store: Arc<dyn RemoteReviewRepository>,
-    pub event_publisher: Arc<dyn EventPublisher>,
-    pub base_url: String,
-}
-
-#[async_trait]
-impl ApContentReader for ReviewObjectHandler {
-    async fn get_local_objects_page(
-        &self,
-        user_id: uuid::Uuid,
-        before: Option<chrono::DateTime<chrono::Utc>>,
-        limit: usize,
-    ) -> anyhow::Result<Vec<LocalObject>> {
-        let domain_user_id = UserId::from_uuid(user_id);
-        let before_naive = before.map(|dt| dt.naive_utc());
-        let entries = self
-            .content_query
-            .get_local_reviews_page(&domain_user_id, before_naive, limit)
-            .await
-            .map_err(|e| anyhow::anyhow!(e.to_string()))?;
-
-        let actor = actor_url(&self.base_url, user_id);
-        let mut results = Vec::new();
-        for entry in entries {
-            let review = entry.review();
-            let published =
-                chrono::DateTime::from_naive_utc_and_offset(*review.watched_at(), chrono::Utc);
-            let movie = entry.movie();
-            let ap_id = review_url(&self.base_url, review.id());
-            let poster_url = movie
-                .poster_path()
-                .map(|p| format!("{}/images/{}", self.base_url, p.value()));
-
-            let obj = review_to_ap_object(
-                review,
-                ReviewApInput {
-                    ap_id: ap_id.clone(),
-                    actor_url: actor.clone(),
-                    movie_title: movie.title().value().to_string(),
-                    release_year: movie.release_year().value(),
-                    external_metadata_id: movie
-                        .external_metadata_id()
-                        .map(|id| id.value().to_string()),
-                    poster_url,
-                    base_url: self.base_url.clone(),
-                },
-            );
-            let follower_cc = format!("{}/followers", actor);
-            results.push(LocalObject {
-                ap_id,
-                object: serde_json::to_value(obj)?,
-                published_at: published,
-                to: vec![AS_PUBLIC.to_string()],
-                cc: vec![follower_cc],
-                bto: vec![],
-                bcc: vec![],
-            });
-        }
-        Ok(results)
-    }
-
-    async fn count_local_posts(&self) -> anyhow::Result<u64> {
-        self.diary_repo
-            .count_local_posts()
-            .await
-            .map_err(|e| anyhow::anyhow!(e.to_string()))
-    }
-}
-
-#[async_trait]
-impl ApObjectHandler for ReviewObjectHandler {
-    async fn on_create(
-        &self,
-        _ap_id: &Url,
-        _actor_url: &Url,
-        object: serde_json::Value,
-    ) -> anyhow::Result<()> {
-        let mut obj: ReviewObject = match serde_json::from_value(object) {
-            Ok(o) => o,
-            Err(e) => {
-                tracing::warn!("ignoring unrecognized Create object: {}", e);
-                return Ok(());
-            }
-        };
-        obj.movie_title = ammonia::clean(&obj.movie_title);
-        obj.comment = obj.comment.map(|c| ammonia::clean(&c));
-
-        let actor_url_str = obj.attributed_to.to_string();
-        let review_id = ReviewId::generate();
-        let movie_id = if let Some(ref ext_id) = obj.external_metadata_id {
-            let found = if let Ok(ext_meta_id) = ExternalMetadataId::new(ext_id.clone()) {
-                self.movie_repo
-                    .get_movie_by_external_id(&ext_meta_id)
-                    .await
-                    .ok()
-                    .flatten()
-            } else {
-                None
-            };
-            match found {
-                Some(movie) => movie.id().clone(),
-                None => MovieId::from_uuid(uuid::Uuid::new_v5(
-                    &uuid::Uuid::NAMESPACE_URL,
-                    ext_id.as_bytes(),
-                )),
-            }
-        } else {
-            MovieId::from_uuid(uuid::Uuid::new_v5(
-                &uuid::Uuid::NAMESPACE_URL,
-                format!("{}:{}", obj.movie_title, obj.release_year).as_bytes(),
-            ))
-        };
-        let user_id = UserId::from_uuid(uuid::Uuid::new_v5(
-            &uuid::Uuid::NAMESPACE_URL,
-            actor_url_str.as_bytes(),
-        ));
-        let rating = Rating::new(obj.rating.min(5))?;
-        let comment = obj.comment.map(Comment::new).transpose()?;
-        let watch_medium = obj
-            .watch_medium
-            .as_deref()
-            .map(|s| s.parse())
-            .transpose()
-            .unwrap_or(None);
-
-        let review = domain::models::Review::from_persistence(domain::models::PersistedReview {
-            id: review_id,
-            movie_id: movie_id.clone(),
-            user_id,
-            rating,
-            comment,
-            watched_at: obj.watched_at.naive_utc(),
-            created_at: obj.published.naive_utc(),
-            source: ReviewSource::Remote {
-                actor_url: actor_url_str,
-            },
-            watch_medium,
-        });
-
-        self.review_store
-            .save_remote_review(
-                &review,
-                obj.id.as_str(),
-                &obj.movie_title,
-                obj.release_year,
-                obj.external_metadata_id.as_deref(),
-                obj.poster_url.as_deref(),
-            )
-            .await?;
-
-        if let Some(ref ext_id_str) = obj.external_metadata_id
-            && let Ok(external_metadata_id) = ExternalMetadataId::new(ext_id_str.clone())
-        {
-            let _ = self
-                .event_publisher
-                .publish(&DomainEvent::MovieEnrichmentRequested {
-                    movie_id: movie_id.clone(),
-                    external_metadata_id,
-                })
-                .await;
-        }
-
-        Ok(())
-    }
-
-    async fn on_update(
-        &self,
-        ap_id: &Url,
-        actor_url: &Url,
-        object: serde_json::Value,
-    ) -> anyhow::Result<()> {
-        let mut obj: ReviewObject = match serde_json::from_value(object) {
-            Ok(o) => o,
-            Err(_) => {
-                tracing::warn!(actor = %actor_url, "ignoring non-review Update activity");
-                return Ok(());
-            }
-        };
-        obj.movie_title = ammonia::clean(&obj.movie_title);
-        obj.comment = obj.comment.map(|c| ammonia::clean(&c));
-
-        if obj.attributed_to != *actor_url {
-            anyhow::bail!("update actor does not match object attributed_to");
-        }
-
-        self.review_store
-            .update_remote_review(crate::remote_review_repository::RemoteReviewUpdate {
-                ap_id: ap_id.as_str(),
-                actor_url: actor_url.as_str(),
-                rating: obj.rating.min(5),
-                comment: obj.comment.as_deref(),
-                watched_at: obj.watched_at.naive_utc(),
-                poster_url: obj.poster_url.as_deref(),
-                watch_medium: obj.watch_medium.as_deref(),
-            })
-            .await?;
-
-        Ok(())
-    }
-
-    async fn on_delete(&self, ap_id: &Url, actor_url: &Url) -> anyhow::Result<()> {
-        self.review_store
-            .delete_remote_review(ap_id.as_str(), actor_url.as_str())
-            .await
-    }
-
-    async fn on_actor_removed(&self, actor_url: &Url) -> anyhow::Result<()> {
-        self.review_store.delete_by_actor(actor_url.as_str()).await
-    }
-
-    async fn on_like(&self, _object_url: &Url, _actor_url: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-
-    async fn on_announce_received(
-        &self,
-        _object_url: &Url,
-        _actor_url: &Url,
-    ) -> anyhow::Result<()> {
-        Ok(())
-    }
-
-    async fn on_announce_of_remote(
-        &self,
-        _object_url: &Url,
-        _actor_url: &Url,
-    ) -> anyhow::Result<()> {
-        Ok(())
-    }
-
-    async fn on_unlike(&self, _object_url: &Url, _actor_url: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-
-    async fn on_mention(
-        &self,
-        _thought_ap_id: &Url,
-        _mentioned_user_uuid: uuid::Uuid,
-        _actor_url: &Url,
-    ) -> anyhow::Result<()> {
-        Ok(())
-    }
-}

crates/adapters/activitypub/src/social_adapter.rs

@@ -1,298 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    ports::{FollowCommand, FollowQuery, SocialCommand, SocialQuery, UserRepository},
-    value_objects::{FollowStatus, FollowTarget, SocialActor, SocialIdentity, UserId, Username},
-};
-
-use super::ActivityPubPort;
-
-pub struct CompositeSocialAdapter {
-    ap_service: Arc<dyn ActivityPubPort>,
-    user_repo: Arc<dyn UserRepository>,
-    follow_command: Arc<dyn FollowCommand>,
-    follow_query: Arc<dyn FollowQuery>,
-    base_url: String,
-}
-
-impl CompositeSocialAdapter {
-    pub fn new(
-        ap_service: Arc<dyn ActivityPubPort>,
-        user_repo: Arc<dyn UserRepository>,
-        follow_command: Arc<dyn FollowCommand>,
-        follow_query: Arc<dyn FollowQuery>,
-        base_url: String,
-    ) -> Self {
-        Self {
-            ap_service,
-            user_repo,
-            follow_command,
-            follow_query,
-            base_url,
-        }
-    }
-
-    fn local_actor_url(&self, user_id: &UserId) -> String {
-        format!("{}/users/{}", self.base_url, user_id.value())
-    }
-
-    fn actor_url_from_identity(&self, identity: &SocialIdentity) -> String {
-        match identity {
-            SocialIdentity::Local(uid) => self.local_actor_url(uid),
-            SocialIdentity::Remote { actor_url } => actor_url.clone(),
-        }
-    }
-
-    async fn resolve_target_identity(
-        &self,
-        target: &FollowTarget,
-    ) -> Result<SocialIdentity, DomainError> {
-        match target {
-            FollowTarget::Identity(id) => Ok(id.clone()),
-            FollowTarget::Handle(handle) => {
-                let host = handle.rsplit_once('@').map(|(_, h)| h).unwrap_or("");
-                let local_host = SocialIdentity::host_from_base_url(&self.base_url);
-                if host == local_host {
-                    let username_str = handle
-                        .trim_start_matches('@')
-                        .split('@')
-                        .next()
-                        .unwrap_or("");
-                    if let Ok(username) = Username::new(username_str.to_string())
-                        && let Some(user) = self.user_repo.find_by_username(&username).await?
-                    {
-                        return Ok(SocialIdentity::Local(user.id().clone()));
-                    }
-                }
-                Ok(SocialIdentity::Remote {
-                    actor_url: handle.clone(),
-                })
-            }
-        }
-    }
-}
-
-fn ap_err(e: anyhow::Error) -> DomainError {
-    DomainError::InfrastructureError(e.to_string())
-}
-
-#[async_trait]
-impl SocialCommand for CompositeSocialAdapter {
-    async fn follow(&self, follower: &UserId, target: &FollowTarget) -> Result<(), DomainError> {
-        let identity = self.resolve_target_identity(target).await?;
-
-        if let SocialIdentity::Local(ref target_id) = identity {
-            if follower == target_id {
-                return Err(DomainError::ValidationError(
-                    "Cannot follow yourself".into(),
-                ));
-            }
-            let follower_url = self.local_actor_url(follower);
-            let target_url = self.local_actor_url(target_id);
-            self.follow_command
-                .add_follower(target_id.value(), &follower_url, FollowStatus::Pending)
-                .await?;
-            self.follow_command
-                .add_follow(follower.value(), &target_url, FollowStatus::Pending)
-                .await?;
-            return Ok(());
-        }
-
-        let handle = match target {
-            FollowTarget::Handle(h) => h.clone(),
-            FollowTarget::Identity(id) => match id {
-                SocialIdentity::Local(uid) => {
-                    let user = self
-                        .user_repo
-                        .find_by_id(uid)
-                        .await?
-                        .ok_or_else(|| DomainError::NotFound("User not found".into()))?;
-                    SocialIdentity::format_local_handle(user.username().value(), &self.base_url)
-                }
-                SocialIdentity::Remote { actor_url } => actor_url.clone(),
-            },
-        };
-        self.ap_service
-            .follow(follower.value(), &handle)
-            .await
-            .map_err(ap_err)
-    }
-
-    async fn unfollow(
-        &self,
-        follower: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<(), DomainError> {
-        let actor_url = self.actor_url_from_identity(target);
-        match target {
-            SocialIdentity::Local(target_id) => {
-                let follower_url = self.local_actor_url(follower);
-                self.follow_command
-                    .remove_follow(follower.value(), &actor_url)
-                    .await?;
-                self.follow_command
-                    .remove_follower_record(target_id.value(), &follower_url)
-                    .await?;
-                Ok(())
-            }
-            SocialIdentity::Remote { .. } => self
-                .ap_service
-                .unfollow(follower.value(), &actor_url)
-                .await
-                .map_err(ap_err),
-        }
-    }
-
-    async fn accept_follow(
-        &self,
-        owner: &UserId,
-        requester: &SocialIdentity,
-    ) -> Result<(), DomainError> {
-        let actor_url = self.actor_url_from_identity(requester);
-        match requester {
-            SocialIdentity::Local(requester_id) => {
-                let owner_url = self.local_actor_url(owner);
-                self.follow_command
-                    .update_follower_status(owner.value(), &actor_url, FollowStatus::Accepted)
-                    .await?;
-                self.follow_command
-                    .update_follow_status(requester_id.value(), &owner_url, FollowStatus::Accepted)
-                    .await?;
-                Ok(())
-            }
-            SocialIdentity::Remote { .. } => self
-                .ap_service
-                .accept_follower(owner.value(), &actor_url)
-                .await
-                .map_err(ap_err),
-        }
-    }
-
-    async fn reject_follow(
-        &self,
-        owner: &UserId,
-        requester: &SocialIdentity,
-    ) -> Result<(), DomainError> {
-        let actor_url = self.actor_url_from_identity(requester);
-        match requester {
-            SocialIdentity::Local(requester_id) => {
-                let owner_url = self.local_actor_url(owner);
-                self.follow_command
-                    .update_follower_status(owner.value(), &actor_url, FollowStatus::Rejected)
-                    .await?;
-                self.follow_command
-                    .remove_follow(requester_id.value(), &owner_url)
-                    .await?;
-                Ok(())
-            }
-            SocialIdentity::Remote { .. } => self
-                .ap_service
-                .reject_follower(owner.value(), &actor_url)
-                .await
-                .map_err(ap_err),
-        }
-    }
-
-    async fn remove_follower(
-        &self,
-        owner: &UserId,
-        follower: &SocialIdentity,
-    ) -> Result<(), DomainError> {
-        let actor_url = self.actor_url_from_identity(follower);
-        match follower {
-            SocialIdentity::Local(follower_id) => {
-                let owner_url = self.local_actor_url(owner);
-                self.follow_command
-                    .remove_follower_record(owner.value(), &actor_url)
-                    .await?;
-                self.follow_command
-                    .remove_follow(follower_id.value(), &owner_url)
-                    .await?;
-                Ok(())
-            }
-            SocialIdentity::Remote { .. } => self
-                .ap_service
-                .remove_follower(owner.value(), &actor_url)
-                .await
-                .map_err(ap_err),
-        }
-    }
-
-    async fn block(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
-        let actor_url = self.actor_url_from_identity(target);
-        self.ap_service
-            .block_actor(blocker.value(), &actor_url)
-            .await
-            .map_err(ap_err)
-    }
-
-    async fn unblock(&self, blocker: &UserId, target: &SocialIdentity) -> Result<(), DomainError> {
-        let actor_url = self.actor_url_from_identity(target);
-        self.ap_service
-            .unblock_actor(blocker.value(), &actor_url)
-            .await
-            .map_err(ap_err)
-    }
-}
-
-#[async_trait]
-impl SocialQuery for CompositeSocialAdapter {
-    async fn get_following(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        self.follow_query
-            .get_following(user.value(), &self.base_url)
-            .await
-    }
-
-    async fn get_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        self.follow_query
-            .get_followers(user.value(), &self.base_url)
-            .await
-    }
-
-    async fn get_pending_followers(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        self.follow_query
-            .get_pending_followers(user.value(), &self.base_url)
-            .await
-    }
-
-    async fn count_following(&self, user: &UserId) -> Result<usize, DomainError> {
-        self.follow_query.count_following(user.value()).await
-    }
-
-    async fn count_followers(&self, user: &UserId) -> Result<usize, DomainError> {
-        self.follow_query.count_followers(user.value()).await
-    }
-
-    async fn get_blocked(&self, user: &UserId) -> Result<Vec<SocialActor>, DomainError> {
-        let actors = self
-            .ap_service
-            .get_blocked_actors(user.value())
-            .await
-            .map_err(ap_err)?;
-        Ok(actors
-            .into_iter()
-            .map(|a| {
-                let identity = SocialIdentity::from_actor_url(&a.url, &self.base_url);
-                SocialActor {
-                    identity,
-                    handle: a.handle,
-                    display_name: a.display_name,
-                    avatar_url: a.avatar_url,
-                }
-            })
-            .collect())
-    }
-
-    async fn is_following(
-        &self,
-        follower: &UserId,
-        target: &SocialIdentity,
-    ) -> Result<bool, DomainError> {
-        let actor_url = self.actor_url_from_identity(target);
-        self.follow_query
-            .is_following(follower.value(), &actor_url)
-            .await
-    }
-}

crates/adapters/activitypub/src/tests/objects.rs

@@ -1,105 +0,0 @@
-use super::*;
-
-#[test]
-fn normalize_hashtag_strips_non_alphanumeric() {
-    assert_eq!(normalize_hashtag("The Dark Knight"), "TheDarkKnight");
-    assert_eq!(normalize_hashtag("Schindler's List"), "SchindlersList");
-    assert_eq!(
-        normalize_hashtag("2001: A Space Odyssey"),
-        "2001ASpaceOdyssey"
-    );
-}
-
-#[test]
-fn review_to_ap_object_includes_two_hashtags() {
-    use chrono::NaiveDateTime;
-    use domain::{
-        models::{PersistedReview, Review, ReviewSource},
-        value_objects::{MovieId, Rating, ReviewId, UserId},
-    };
-
-    let review = Review::from_persistence(PersistedReview {
-        id: ReviewId::generate(),
-        movie_id: MovieId::from_uuid(uuid::Uuid::new_v4()),
-        user_id: UserId::from_uuid(uuid::Uuid::new_v4()),
-        rating: Rating::new(4).unwrap(),
-        comment: None,
-        watched_at: NaiveDateTime::parse_from_str("2024-01-01 00:00:00", "%Y-%m-%d %H:%M:%S")
-            .unwrap(),
-        created_at: NaiveDateTime::parse_from_str("2024-01-01 00:00:00", "%Y-%m-%d %H:%M:%S")
-            .unwrap(),
-        source: ReviewSource::Local,
-        watch_medium: None,
-    });
-    let obj = review_to_ap_object(
-        &review,
-        ReviewApInput {
-            ap_id: "https://example.com/reviews/1".parse().unwrap(),
-            actor_url: "https://example.com/users/1".parse().unwrap(),
-            movie_title: "Dune".to_string(),
-            release_year: 2021,
-            external_metadata_id: None,
-            poster_url: None,
-            base_url: "https://example.com".to_string(),
-        },
-    );
-    assert_eq!(obj.tag.len(), 2);
-    let names: Vec<&str> = obj.tag.iter().map(|t| t.name.as_str()).collect();
-    assert!(names.contains(&"#MoviesDiary"));
-    assert!(names.contains(&"#Dune"));
-}
-
-#[test]
-fn review_to_ap_object_has_public_addressing() {
-    use chrono::NaiveDateTime;
-    use domain::{
-        models::{PersistedReview, Review, ReviewSource},
-        value_objects::{MovieId, Rating, ReviewId, UserId},
-    };
-
-    let review = Review::from_persistence(PersistedReview {
-        id: ReviewId::generate(),
-        movie_id: MovieId::from_uuid(uuid::Uuid::new_v4()),
-        user_id: UserId::from_uuid(uuid::Uuid::new_v4()),
-        rating: Rating::new(3).unwrap(),
-        comment: None,
-        watched_at: NaiveDateTime::parse_from_str("2024-06-01 00:00:00", "%Y-%m-%d %H:%M:%S")
-            .unwrap(),
-        created_at: NaiveDateTime::parse_from_str("2024-06-01 00:00:00", "%Y-%m-%d %H:%M:%S")
-            .unwrap(),
-        source: ReviewSource::Local,
-        watch_medium: None,
-    });
-    let actor_url: url::Url = "https://example.com/users/abc".parse().unwrap();
-    let obj = review_to_ap_object(
-        &review,
-        ReviewApInput {
-            ap_id: "https://example.com/reviews/1".parse().unwrap(),
-            actor_url: actor_url.clone(),
-            movie_title: "Dune".to_string(),
-            release_year: 2021,
-            external_metadata_id: None,
-            poster_url: None,
-            base_url: "https://example.com".to_string(),
-        },
-    );
-    assert_eq!(obj.to, vec!["https://www.w3.org/ns/activitystreams#Public"]);
-    assert_eq!(obj.cc, vec!["https://example.com/users/abc/followers"]);
-}
-
-#[test]
-fn watchlist_to_ap_object_has_public_addressing() {
-    let actor_url: url::Url = "https://example.com/users/abc".parse().unwrap();
-    let obj = watchlist_to_ap_object(WatchlistApInput {
-        ap_id: "https://example.com/watchlist/1".parse().unwrap(),
-        actor_url: actor_url.clone(),
-        movie_title: "Alien".to_string(),
-        release_year: 1979,
-        external_metadata_id: None,
-        poster_url: None,
-        added_at: chrono::Utc::now(),
-        base_url: "https://example.com".to_string(),
-    });
-    assert_eq!(obj.to, vec!["https://www.w3.org/ns/activitystreams#Public"]);
-    assert_eq!(obj.cc, vec!["https://example.com/users/abc/followers"]);
-}

crates/adapters/activitypub/src/urls.rs

@@ -1,28 +0,0 @@
-use domain::value_objects::ReviewId;
-use url::Url;
-
-/// Builds the canonical actor URL: `{base_url}/users/{user_id}`
-pub fn actor_url(base_url: &str, user_id: uuid::Uuid) -> Url {
-    Url::parse(&format!("{}/users/{}", base_url, user_id))
-        .expect("base_url is always a valid URL prefix")
-}
-
-/// Builds the canonical review URL: `{base_url}/reviews/{review_id}`
-pub fn review_url(base_url: &str, review_id: &ReviewId) -> Url {
-    Url::parse(&format!("{}/reviews/{}", base_url, review_id.value()))
-        .expect("base_url is always a valid URL prefix")
-}
-
-pub fn goal_url(base_url: &str, user_id: uuid::Uuid, year: u16) -> Url {
-    Url::parse(&format!("{}/users/{}/goals/{}", base_url, user_id, year))
-        .expect("base_url is always a valid URL prefix")
-}
-
-/// Builds the canonical watchlist entry URL: `{base_url}/users/{user_id}/watchlist/{movie_id}`
-pub fn watchlist_entry_url(base_url: &str, user_id: uuid::Uuid, movie_id: uuid::Uuid) -> Url {
-    Url::parse(&format!(
-        "{}/users/{}/watchlist/{}",
-        base_url, user_id, movie_id
-    ))
-    .expect("base_url is always a valid URL prefix")
-}

crates/adapters/activitypub/src/user_adapter.rs

@@ -1,89 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use domain::{ports::UserRepository, value_objects::UserId};
-use k_ap::{ApProfileField, ApUser, ApUserRepository};
-use url::Url;
-
-pub struct DomainUserRepoAdapter {
-    pub repo: Arc<dyn UserRepository>,
-    pub base_url: String,
-}
-
-impl DomainUserRepoAdapter {
-    pub fn new(repo: Arc<dyn UserRepository>, base_url: String) -> Self {
-        Self { repo, base_url }
-    }
-
-    fn build_user(&self, u: &domain::models::User) -> ApUser {
-        let avatar_url = u
-            .avatar_path()
-            .and_then(|p| Url::parse(&format!("{}/images/{}", self.base_url, p)).ok());
-        let banner_url = u
-            .banner_path()
-            .and_then(|p| Url::parse(&format!("{}/images/{}", self.base_url, p)).ok());
-        let profile_url = Url::parse(&format!("{}/u/{}", self.base_url, u.username().value())).ok();
-        ApUser {
-            id: u.id().value(),
-            username: u.username().value().to_string(),
-            display_name: u.display_name().map(|s| s.to_string()),
-            bio: u.bio().map(|s| s.to_string()),
-            avatar_url,
-            banner_url,
-            also_known_as: u
-                .also_known_as()
-                .map(|s| vec![s.to_string()])
-                .unwrap_or_default(),
-            profile_url,
-            attachment: u
-                .profile_fields()
-                .iter()
-                .map(|f| ApProfileField {
-                    name: f.name.clone(),
-                    value: f.value.clone(),
-                })
-                .collect(),
-            manually_approves_followers: true,
-            discoverable: true,
-            actor_type: Default::default(),
-            featured_url: Url::parse(&format!(
-                "{}/users/{}/featured",
-                self.base_url,
-                u.id().value()
-            ))
-            .ok(),
-        }
-    }
-}
-
-#[async_trait]
-impl ApUserRepository for DomainUserRepoAdapter {
-    async fn find_by_id(&self, id: uuid::Uuid) -> anyhow::Result<Option<ApUser>> {
-        let user_id = UserId::from_uuid(id);
-        let user = match self.repo.find_by_id(&user_id).await? {
-            Some(u) => u,
-            None => return Ok(None),
-        };
-        Ok(Some(self.build_user(&user)))
-    }
-
-    async fn find_by_username(&self, username: &str) -> anyhow::Result<Option<ApUser>> {
-        use domain::value_objects::Username;
-        let uname =
-            Username::new(username.to_string()).map_err(|e| anyhow::anyhow!(e.to_string()))?;
-        let user = match self.repo.find_by_username(&uname).await? {
-            Some(u) => u,
-            None => return Ok(None),
-        };
-        Ok(Some(self.build_user(&user)))
-    }
-
-    async fn count_users(&self) -> anyhow::Result<usize> {
-        Ok(self
-            .repo
-            .list_with_stats()
-            .await
-            .map_err(|e| anyhow::anyhow!(e.to_string()))?
-            .len())
-    }
-}

crates/adapters/activitypub/src/watchlist_handler.rs

@@ -1,168 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use chrono::DateTime;
-use domain::{
-    models::{RemoteWatchlistEntry, WatchlistWithMovie},
-    ports::{LocalApContentQuery, RemoteWatchlistRepository},
-    value_objects::UserId,
-};
-use k_ap::{AS_PUBLIC, ApContentReader, ApObjectHandler, LocalObject};
-use url::Url;
-
-use crate::objects::{WatchlistApInput, WatchlistObject, watchlist_to_ap_object};
-use crate::urls::{actor_url, watchlist_entry_url};
-
-pub struct WatchlistObjectHandler {
-    pub remote_watchlist_repo: Arc<dyn RemoteWatchlistRepository>,
-    pub content_query: Arc<dyn LocalApContentQuery>,
-    pub base_url: String,
-}
-
-#[async_trait]
-impl ApContentReader for WatchlistObjectHandler {
-    async fn get_local_objects_page(
-        &self,
-        user_id: uuid::Uuid,
-        _before: Option<DateTime<chrono::Utc>>,
-        _limit: usize,
-    ) -> anyhow::Result<Vec<LocalObject>> {
-        let uid = UserId::from_uuid(user_id);
-        let entries = self
-            .content_query
-            .get_local_watchlist_for_user(&uid)
-            .await
-            .map_err(|e| anyhow::anyhow!(e.to_string()))?;
-
-        let actor = actor_url(&self.base_url, user_id);
-        let follower_cc = format!("{}/followers", actor);
-        let mut results = Vec::new();
-        for WatchlistWithMovie { entry, movie } in entries {
-            let ap_id = watchlist_entry_url(&self.base_url, user_id, entry.movie_id.value());
-            let published = DateTime::from_naive_utc_and_offset(entry.added_at, chrono::Utc);
-            let poster_url = movie
-                .poster_path()
-                .map(|p| format!("{}/images/{}", self.base_url, p.value()));
-            let obj = watchlist_to_ap_object(WatchlistApInput {
-                ap_id: ap_id.clone(),
-                actor_url: actor.clone(),
-                movie_title: movie.title().value().to_string(),
-                release_year: movie.release_year().value(),
-                external_metadata_id: movie
-                    .external_metadata_id()
-                    .map(|id| id.value().to_string()),
-                poster_url,
-                added_at: published,
-                base_url: self.base_url.clone(),
-            });
-            results.push(LocalObject {
-                ap_id,
-                object: serde_json::to_value(obj)?,
-                published_at: published,
-                to: vec![AS_PUBLIC.to_string()],
-                cc: vec![follower_cc.clone()],
-                bto: vec![],
-                bcc: vec![],
-            });
-        }
-        Ok(results)
-    }
-
-    async fn count_local_posts(&self) -> anyhow::Result<u64> {
-        Ok(0)
-    }
-}
-
-#[async_trait]
-impl ApObjectHandler for WatchlistObjectHandler {
-    async fn on_create(
-        &self,
-        ap_id: &Url,
-        actor_url: &Url,
-        object: serde_json::Value,
-    ) -> anyhow::Result<()> {
-        let mut obj: WatchlistObject = match serde_json::from_value(object) {
-            Ok(o) => o,
-            Err(e) => {
-                tracing::warn!(ap_id = %ap_id, "ignoring malformed watchlist Create: {}", e);
-                return Ok(());
-            }
-        };
-        obj.movie_title = ammonia::clean(&obj.movie_title);
-        let added_at = obj.published;
-        let entry = RemoteWatchlistEntry {
-            ap_id: ap_id.as_str().to_string(),
-            actor_url: actor_url.as_str().to_string(),
-            movie_title: obj.movie_title,
-            release_year: obj.release_year,
-            external_metadata_id: obj.external_metadata_id,
-            poster_url: obj.poster_url,
-            added_at,
-        };
-        self.remote_watchlist_repo.save(entry).await?;
-        tracing::info!(ap_id = %ap_id, "saved remote watchlist entry");
-        Ok(())
-    }
-
-    async fn on_update(
-        &self,
-        ap_id: &Url,
-        actor_url: &Url,
-        object: serde_json::Value,
-    ) -> anyhow::Result<()> {
-        let mut obj: WatchlistObject = match serde_json::from_value(object) {
-            Ok(o) => o,
-            Err(e) => {
-                tracing::warn!(ap_id = %ap_id, "ignoring malformed watchlist Update: {}", e);
-                return Ok(());
-            }
-        };
-        if obj.attributed_to != *actor_url {
-            anyhow::bail!("watchlist Update actor does not match object attributed_to");
-        }
-        obj.movie_title = ammonia::clean(&obj.movie_title);
-        let entry = RemoteWatchlistEntry {
-            ap_id: ap_id.as_str().to_string(),
-            actor_url: actor_url.as_str().to_string(),
-            movie_title: obj.movie_title,
-            release_year: obj.release_year,
-            external_metadata_id: obj.external_metadata_id,
-            poster_url: obj.poster_url,
-            added_at: obj.published,
-        };
-        self.remote_watchlist_repo.save(entry).await?;
-        tracing::info!(ap_id = %ap_id, "updated remote watchlist entry");
-        Ok(())
-    }
-
-    async fn on_delete(&self, ap_id: &Url, actor_url: &Url) -> anyhow::Result<()> {
-        self.remote_watchlist_repo
-            .remove_by_ap_id(ap_id.as_str(), actor_url.as_str())
-            .await?;
-        tracing::info!(ap_id = %ap_id, "removed remote watchlist entry");
-        Ok(())
-    }
-
-    async fn on_actor_removed(&self, actor_url: &Url) -> anyhow::Result<()> {
-        self.remote_watchlist_repo
-            .remove_all_by_actor(actor_url.as_str())
-            .await?;
-        Ok(())
-    }
-
-    async fn on_like(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_announce_received(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_announce_of_remote(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_unlike(&self, _: &Url, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-    async fn on_mention(&self, _: &Url, _: uuid::Uuid, _: &Url) -> anyhow::Result<()> {
-        Ok(())
-    }
-}

crates/adapters/adapter-common/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "adapter-common"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-domain = { workspace = true }
-sqlx = { workspace = true }
-tracing = { workspace = true }
-chrono = { workspace = true }
-uuid = { workspace = true }

crates/adapters/adapter-common/src/lib.rs

@@ -1,220 +0,0 @@
-use domain::{
-    errors::DomainError,
-    models::{
-        Movie, MovieStats, MovieSummary, PersistedReview, Review, ReviewSource, UserSummary,
-        WatchlistEntry, WatchlistWithMovie,
-    },
-    value_objects::{
-        Comment, Email, ExternalMetadataId, MovieId, MovieTitle, PosterPath, Rating, ReleaseYear,
-        ReviewId, UserId, Username, WatchlistEntryId,
-    },
-};
-
-/// Map a [`sqlx::Error`] to a [`DomainError::InfrastructureError`], logging the
-/// underlying database error at `error` level.
-pub fn map_sqlx_error(e: sqlx::Error) -> DomainError {
-    tracing::error!("Database error: {:?}", e);
-    DomainError::InfrastructureError("Database operation failed".into())
-}
-
-/// Parse a string as a UUID, returning a [`DomainError`] on failure.
-pub fn parse_uuid(s: &str) -> Result<uuid::Uuid, DomainError> {
-    uuid::Uuid::parse_str(s)
-        .map_err(|e| DomainError::InfrastructureError(format!("Invalid UUID '{}': {}", s, e)))
-}
-
-/// Parse a `%Y-%m-%d %H:%M:%S` string into a [`chrono::NaiveDateTime`].
-pub fn parse_datetime(s: &str) -> Result<chrono::NaiveDateTime, DomainError> {
-    chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S")
-        .map_err(|e| DomainError::InfrastructureError(format!("Invalid datetime '{}': {}", s, e)))
-}
-
-/// Format a [`chrono::NaiveDateTime`] as `%Y-%m-%d %H:%M:%S`.
-pub fn datetime_to_str(dt: &chrono::NaiveDateTime) -> String {
-    dt.format("%Y-%m-%d %H:%M:%S").to_string()
-}
-
-/// Convert a `YYYY-MM` string into a human-readable label like `Jan '24`.
-pub fn format_year_month(ym: &str) -> String {
-    let parts: Vec<&str> = ym.splitn(2, '-').collect();
-    if parts.len() != 2 {
-        return ym.to_string();
-    }
-    let year = parts[0].get(2..).unwrap_or(parts[0]);
-    let month = match parts[1] {
-        "01" => "Jan",
-        "02" => "Feb",
-        "03" => "Mar",
-        "04" => "Apr",
-        "05" => "May",
-        "06" => "Jun",
-        "07" => "Jul",
-        "08" => "Aug",
-        "09" => "Sep",
-        "10" => "Oct",
-        "11" => "Nov",
-        "12" => "Dec",
-        _ => parts[1],
-    };
-    format!("{} '{}", month, year)
-}
-
-// ---------------------------------------------------------------------------
-// Shared row-to-domain conversion functions
-//
-// Each database adapter keeps its own `FromRow` structs (sqlite vs postgres
-// derive different impls) but the conversion from parsed row fields into
-// domain types is identical.  These functions capture that shared logic so
-// each adapter's `into_domain()` becomes a one-liner delegation.
-// ---------------------------------------------------------------------------
-
-/// Convert raw movie row fields into a [`Movie`] domain object.
-pub fn movie_row_to_domain(
-    id: String,
-    external_metadata_id: Option<String>,
-    title: String,
-    release_year: i64,
-    director: Option<String>,
-    poster_path: Option<String>,
-) -> Result<Movie, DomainError> {
-    let id = MovieId::from_uuid(parse_uuid(&id)?);
-    let external_metadata_id = external_metadata_id
-        .map(ExternalMetadataId::new)
-        .transpose()?;
-    let title = MovieTitle::new(title)?;
-    let release_year = ReleaseYear::new(release_year as u16)?;
-    let poster_path = poster_path.map(PosterPath::new).transpose()?;
-    Ok(Movie::from_persistence(
-        id,
-        external_metadata_id,
-        title,
-        release_year,
-        director,
-        poster_path,
-    ))
-}
-
-/// Convert raw review row fields into a [`Review`] domain object.
-#[allow(clippy::too_many_arguments)]
-pub fn review_row_to_domain(
-    id: String,
-    movie_id: String,
-    user_id: String,
-    rating: i64,
-    comment: Option<String>,
-    watched_at: String,
-    created_at: String,
-    remote_actor_url: Option<String>,
-    watch_medium: Option<String>,
-) -> Result<Review, DomainError> {
-    let id = ReviewId::from_uuid(parse_uuid(&id)?);
-    let movie_id = MovieId::from_uuid(parse_uuid(&movie_id)?);
-    let user_id = UserId::from_uuid(parse_uuid(&user_id)?);
-    let rating = Rating::new(rating as u8)?;
-    let comment = comment.map(Comment::new).transpose()?;
-    let watched_at = parse_datetime(&watched_at)?;
-    let created_at = parse_datetime(&created_at)?;
-    let source = match remote_actor_url {
-        None => ReviewSource::Local,
-        Some(url) => ReviewSource::Remote { actor_url: url },
-    };
-    let watch_medium = watch_medium.map(|s| s.parse()).transpose()?;
-    Ok(Review::from_persistence(PersistedReview {
-        id,
-        movie_id,
-        user_id,
-        rating,
-        comment,
-        watched_at,
-        created_at,
-        source,
-        watch_medium,
-    }))
-}
-
-/// Assemble a [`MovieSummary`] from an already-converted [`Movie`] and extra
-/// metadata fields.  The caller is responsible for converting genres into a
-/// `Vec<String>` (sqlite splits a comma-separated string, postgres receives a
-/// `Vec` directly).
-pub fn movie_summary_to_domain(
-    movie: Movie,
-    genres: Vec<String>,
-    runtime_minutes: Option<i64>,
-    original_language: Option<String>,
-    overview: Option<String>,
-    collection_name: Option<String>,
-) -> MovieSummary {
-    MovieSummary {
-        movie,
-        genres,
-        runtime_minutes: runtime_minutes.map(|v| v as u32),
-        original_language,
-        overview,
-        collection_name,
-    }
-}
-
-/// Convert raw aggregate stats into a [`MovieStats`] domain object.
-pub fn movie_stats_to_domain(
-    total_count: i64,
-    avg_rating: Option<f64>,
-    federated_count: i64,
-    rating_histogram: [i64; 5],
-) -> MovieStats {
-    MovieStats {
-        total_count: total_count as u64,
-        avg_rating,
-        federated_count: federated_count as u64,
-        rating_histogram: [
-            rating_histogram[0] as u64,
-            rating_histogram[1] as u64,
-            rating_histogram[2] as u64,
-            rating_histogram[3] as u64,
-            rating_histogram[4] as u64,
-        ],
-    }
-}
-
-/// Convert raw user summary row fields into a [`UserSummary`] domain object.
-#[allow(clippy::too_many_arguments)]
-pub fn user_summary_to_domain(
-    id: String,
-    email: String,
-    username: String,
-    display_name: Option<String>,
-    total_movies: i64,
-    avg_rating: Option<f64>,
-    avatar_path: Option<String>,
-) -> Result<UserSummary, DomainError> {
-    Ok(UserSummary::new(
-        UserId::from_uuid(parse_uuid(&id)?),
-        Email::new(email)?,
-        Username::new(username)?,
-        display_name,
-        total_movies,
-        avg_rating,
-        avatar_path,
-    ))
-}
-
-/// Convert raw watchlist entry fields into a [`WatchlistEntry`] domain object.
-pub fn watchlist_entry_to_domain(
-    id: String,
-    user_id: String,
-    movie_id: String,
-    added_at: String,
-) -> Result<WatchlistEntry, DomainError> {
-    Ok(WatchlistEntry {
-        id: WatchlistEntryId::from_uuid(parse_uuid(&id)?),
-        user_id: UserId::from_uuid(parse_uuid(&user_id)?),
-        movie_id: MovieId::from_uuid(parse_uuid(&movie_id)?),
-        added_at: parse_datetime(&added_at)?,
-    })
-}
-
-/// Convert raw watchlist+movie row fields into a [`WatchlistWithMovie`].
-///
-/// Takes the watchlist entry fields and a pre-converted [`Movie`].
-pub fn watchlist_with_movie_to_domain(entry: WatchlistEntry, movie: Movie) -> WatchlistWithMovie {
-    WatchlistWithMovie { entry, movie }
-}

crates/adapters/auth/src/lib.rs

@@ -1,8 +1,8 @@
+use async_trait::async_trait;
 use argon2::{
     Argon2,
     password_hash::{PasswordHasher as _, PasswordVerifier, SaltString},
 };
-use async_trait::async_trait;
 use chrono::{Duration, Utc};
 use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation, decode, encode};
 use rand_core::OsRng;
@@ -11,8 +11,7 @@ use uuid::Uuid;
 
 use domain::{
     errors::DomainError,
-    models::GeneratedToken,
-    ports::{AuthService, PasswordHasher},
+    ports::{AuthService, GeneratedToken, PasswordHasher},
     value_objects::{PasswordHash, UserId},
 };
 
@@ -31,11 +30,8 @@ impl AuthConfig {
         let ttl_seconds = std::env::var("JWT_TTL_SECONDS")
             .ok()
             .and_then(|v| v.parse().ok())
-            .unwrap_or(900u64);
-        Ok(Self {
-            secret,
-            ttl_seconds,
-        })
+            .unwrap_or(86400u64);
+        Ok(Self { secret, ttl_seconds })
     }
 }
 
@@ -106,14 +102,3 @@ impl PasswordHasher for Argon2PasswordHasher {
             .is_ok())
     }
 }
-
-pub fn create() -> anyhow::Result<(
-    std::sync::Arc<dyn domain::ports::AuthService>,
-    std::sync::Arc<dyn domain::ports::PasswordHasher>,
-)> {
-    let config = AuthConfig::from_env()?;
-    Ok((
-        std::sync::Arc::new(JwtAuthService::new(config)),
-        std::sync::Arc::new(Argon2PasswordHasher),
-    ))
-}

crates/adapters/event-payload/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "event-payload"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-domain = { workspace = true }
-serde = { workspace = true }
-chrono = { workspace = true }
-uuid = { workspace = true }
-serde_json = { workspace = true }

crates/adapters/event-payload/src/lib.rs

@@ -1,724 +0,0 @@
-use chrono::NaiveDateTime;
-use domain::{
-    errors::DomainError,
-    events::DomainEvent,
-    models::{ExternalPersonId, PersonId},
-    value_objects::{
-        ExternalMetadataId, GoalId, MovieId, PosterPath, Rating, ReviewId, SocialIdentity, UserId,
-        WrapUpId,
-    },
-};
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-#[serde(tag = "type", content = "data")]
-pub enum EventPayload {
-    ReviewLogged {
-        review_id: String,
-        movie_id: String,
-        user_id: String,
-        rating: u8,
-        watched_at: i64,
-    },
-    ReviewUpdated {
-        review_id: String,
-        movie_id: String,
-        user_id: String,
-        rating: u8,
-        watched_at: i64,
-    },
-    MovieDiscovered {
-        movie_id: String,
-        external_metadata_id: String,
-    },
-    MovieDeleted {
-        movie_id: String,
-        poster_path: Option<String>,
-    },
-    UserUpdated {
-        user_id: String,
-    },
-    ReviewDeleted {
-        review_id: String,
-        user_id: String,
-    },
-    MovieEnrichmentRequested {
-        movie_id: String,
-        external_metadata_id: String,
-    },
-    ImageStored {
-        key: String,
-    },
-    WatchlistEntryAdded {
-        user_id: String,
-        movie_id: String,
-        movie_title: String,
-        release_year: u16,
-        external_metadata_id: Option<String>,
-        added_at: i64,
-    },
-    WatchlistEntryRemoved {
-        user_id: String,
-        movie_id: String,
-    },
-    FollowRequested {
-        follower_id: String,
-        target_kind: String,
-        target_id: String,
-    },
-    FollowAccepted {
-        owner_id: String,
-        requester_kind: String,
-        requester_id: String,
-    },
-    FollowRejected {
-        owner_id: String,
-        requester_kind: String,
-        requester_id: String,
-    },
-    Unfollowed {
-        follower_id: String,
-        target_kind: String,
-        target_id: String,
-    },
-    FollowerRemoved {
-        owner_id: String,
-        follower_kind: String,
-        follower_id: String,
-    },
-    ActorBlocked {
-        blocker_id: String,
-        target_kind: String,
-        target_id: String,
-    },
-    ActorUnblocked {
-        blocker_id: String,
-        target_kind: String,
-        target_id: String,
-    },
-    BackfillFollower {
-        owner_user_id: String,
-        follower_inbox_url: String,
-    },
-    FederationDeliveryRequested {
-        inbox_url: String,
-        activity_json: serde_json::Value,
-        signing_actor_id: String,
-    },
-    WatchEventIngested {
-        user_id: String,
-        title: String,
-        source: String,
-    },
-    WrapUpRequested {
-        wrapup_id: String,
-        user_id: Option<String>,
-        start_date: String,
-        end_date: String,
-    },
-    WrapUpCompleted {
-        wrapup_id: String,
-    },
-    SearchReindexRequested,
-    PosterSynced {
-        movie_id: String,
-    },
-    GoalCreated {
-        goal_id: String,
-        user_id: String,
-        year: u16,
-        target_count: u32,
-    },
-    GoalUpdated {
-        goal_id: String,
-        user_id: String,
-        year: u16,
-        target_count: u32,
-    },
-    GoalDeleted {
-        goal_id: String,
-        user_id: String,
-        year: u16,
-    },
-    PersonEnrichmentRequested {
-        person_id: String,
-        external_person_id: String,
-    },
-    UserDeleted {
-        user_id: String,
-    },
-    UserAccountMoved {
-        user_id: String,
-        new_actor_url: String,
-    },
-}
-
-impl EventPayload {
-    pub fn event_type(&self) -> &'static str {
-        match self {
-            EventPayload::ReviewLogged { .. } => "ReviewLogged",
-            EventPayload::ReviewUpdated { .. } => "ReviewUpdated",
-            EventPayload::MovieDiscovered { .. } => "MovieDiscovered",
-            EventPayload::MovieDeleted { .. } => "MovieDeleted",
-            EventPayload::UserUpdated { .. } => "UserUpdated",
-            EventPayload::ReviewDeleted { .. } => "ReviewDeleted",
-            EventPayload::MovieEnrichmentRequested { .. } => "MovieEnrichmentRequested",
-            EventPayload::ImageStored { .. } => "ImageStored",
-            EventPayload::WatchlistEntryAdded { .. } => "WatchlistEntryAdded",
-            EventPayload::WatchlistEntryRemoved { .. } => "WatchlistEntryRemoved",
-            EventPayload::FollowRequested { .. } => "FollowRequested",
-            EventPayload::FollowAccepted { .. } => "FollowAccepted",
-            EventPayload::FollowRejected { .. } => "FollowRejected",
-            EventPayload::Unfollowed { .. } => "Unfollowed",
-            EventPayload::FollowerRemoved { .. } => "FollowerRemoved",
-            EventPayload::ActorBlocked { .. } => "ActorBlocked",
-            EventPayload::ActorUnblocked { .. } => "ActorUnblocked",
-            EventPayload::BackfillFollower { .. } => "BackfillFollower",
-            EventPayload::FederationDeliveryRequested { .. } => "FederationDeliveryRequested",
-            EventPayload::WatchEventIngested { .. } => "WatchEventIngested",
-            EventPayload::WrapUpRequested { .. } => "WrapUpRequested",
-            EventPayload::WrapUpCompleted { .. } => "WrapUpCompleted",
-            EventPayload::SearchReindexRequested => "SearchReindexRequested",
-            EventPayload::PosterSynced { .. } => "PosterSynced",
-            EventPayload::GoalCreated { .. } => "GoalCreated",
-            EventPayload::GoalUpdated { .. } => "GoalUpdated",
-            EventPayload::GoalDeleted { .. } => "GoalDeleted",
-            EventPayload::PersonEnrichmentRequested { .. } => "PersonEnrichmentRequested",
-            EventPayload::UserDeleted { .. } => "UserDeleted",
-            EventPayload::UserAccountMoved { .. } => "UserAccountMoved",
-        }
-    }
-}
-
-fn parse_uuid(s: &str, field: &str) -> Result<Uuid, DomainError> {
-    Uuid::parse_str(s).map_err(|e| DomainError::InfrastructureError(format!("{field}: {e}")))
-}
-
-fn identity_to_payload(id: &SocialIdentity) -> (String, String) {
-    match id {
-        SocialIdentity::Local(uid) => ("local".into(), uid.value().to_string()),
-        SocialIdentity::Remote { actor_url } => ("remote".into(), actor_url.clone()),
-    }
-}
-
-fn follow_target_to_payload(target: &domain::value_objects::FollowTarget) -> (String, String) {
-    match target {
-        domain::value_objects::FollowTarget::Identity(id) => identity_to_payload(id),
-        domain::value_objects::FollowTarget::Handle(h) => ("handle".into(), h.clone()),
-    }
-}
-
-fn payload_to_identity(kind: &str, id: String) -> Result<SocialIdentity, DomainError> {
-    match kind {
-        "local" => Ok(SocialIdentity::Local(UserId::from_uuid(parse_uuid(
-            &id, "user_id",
-        )?))),
-        "remote" => Ok(SocialIdentity::Remote { actor_url: id }),
-        other => Err(DomainError::InfrastructureError(format!(
-            "unknown identity kind: {other}"
-        ))),
-    }
-}
-
-fn payload_to_follow_target(
-    kind: &str,
-    id: String,
-) -> Result<domain::value_objects::FollowTarget, DomainError> {
-    match kind {
-        "handle" => Ok(domain::value_objects::FollowTarget::Handle(id)),
-        other => Ok(domain::value_objects::FollowTarget::Identity(
-            payload_to_identity(other, id)?,
-        )),
-    }
-}
-
-fn parse_ts(ts: i64) -> Result<NaiveDateTime, DomainError> {
-    chrono::DateTime::from_timestamp(ts, 0)
-        .map(|dt| dt.naive_utc())
-        .ok_or_else(|| DomainError::InfrastructureError(format!("invalid timestamp: {ts}")))
-}
-
-impl From<&DomainEvent> for EventPayload {
-    fn from(event: &DomainEvent) -> Self {
-        match event {
-            DomainEvent::ReviewLogged {
-                review_id,
-                movie_id,
-                user_id,
-                rating,
-                watched_at,
-            } => EventPayload::ReviewLogged {
-                review_id: review_id.value().to_string(),
-                movie_id: movie_id.value().to_string(),
-                user_id: user_id.value().to_string(),
-                rating: rating.value(),
-                watched_at: watched_at.and_utc().timestamp(),
-            },
-            DomainEvent::ReviewUpdated {
-                review_id,
-                movie_id,
-                user_id,
-                rating,
-                watched_at,
-            } => EventPayload::ReviewUpdated {
-                review_id: review_id.value().to_string(),
-                movie_id: movie_id.value().to_string(),
-                user_id: user_id.value().to_string(),
-                rating: rating.value(),
-                watched_at: watched_at.and_utc().timestamp(),
-            },
-            DomainEvent::MovieDiscovered {
-                movie_id,
-                external_metadata_id,
-            } => EventPayload::MovieDiscovered {
-                movie_id: movie_id.value().to_string(),
-                external_metadata_id: external_metadata_id.value().to_owned(),
-            },
-            DomainEvent::MovieDeleted {
-                movie_id,
-                poster_path,
-            } => EventPayload::MovieDeleted {
-                movie_id: movie_id.value().to_string(),
-                poster_path: poster_path.as_ref().map(|p| p.value().to_string()),
-            },
-            DomainEvent::UserUpdated { user_id } => EventPayload::UserUpdated {
-                user_id: user_id.value().to_string(),
-            },
-            DomainEvent::ReviewDeleted { review_id, user_id } => EventPayload::ReviewDeleted {
-                review_id: review_id.value().to_string(),
-                user_id: user_id.value().to_string(),
-            },
-            DomainEvent::MovieEnrichmentRequested {
-                movie_id,
-                external_metadata_id,
-            } => EventPayload::MovieEnrichmentRequested {
-                movie_id: movie_id.value().to_string(),
-                external_metadata_id: external_metadata_id.value().to_string(),
-            },
-            DomainEvent::ImageStored { key } => EventPayload::ImageStored { key: key.clone() },
-            DomainEvent::WatchlistEntryAdded {
-                user_id,
-                movie_id,
-                movie_title,
-                release_year,
-                external_metadata_id,
-                added_at,
-            } => EventPayload::WatchlistEntryAdded {
-                user_id: user_id.value().to_string(),
-                movie_id: movie_id.value().to_string(),
-                movie_title: movie_title.clone(),
-                release_year: *release_year,
-                external_metadata_id: external_metadata_id.clone(),
-                added_at: added_at.and_utc().timestamp(),
-            },
-            DomainEvent::WatchlistEntryRemoved { user_id, movie_id } => {
-                EventPayload::WatchlistEntryRemoved {
-                    user_id: user_id.value().to_string(),
-                    movie_id: movie_id.value().to_string(),
-                }
-            }
-            DomainEvent::FollowRequested { follower, target } => {
-                let (kind, id) = follow_target_to_payload(target);
-                EventPayload::FollowRequested {
-                    follower_id: follower.value().to_string(),
-                    target_kind: kind,
-                    target_id: id,
-                }
-            }
-            DomainEvent::FollowAccepted { owner, requester } => {
-                let (kind, id) = identity_to_payload(requester);
-                EventPayload::FollowAccepted {
-                    owner_id: owner.value().to_string(),
-                    requester_kind: kind,
-                    requester_id: id,
-                }
-            }
-            DomainEvent::FollowRejected { owner, requester } => {
-                let (kind, id) = identity_to_payload(requester);
-                EventPayload::FollowRejected {
-                    owner_id: owner.value().to_string(),
-                    requester_kind: kind,
-                    requester_id: id,
-                }
-            }
-            DomainEvent::Unfollowed { follower, target } => {
-                let (kind, id) = identity_to_payload(target);
-                EventPayload::Unfollowed {
-                    follower_id: follower.value().to_string(),
-                    target_kind: kind,
-                    target_id: id,
-                }
-            }
-            DomainEvent::FollowerRemoved { owner, follower } => {
-                let (kind, id) = identity_to_payload(follower);
-                EventPayload::FollowerRemoved {
-                    owner_id: owner.value().to_string(),
-                    follower_kind: kind,
-                    follower_id: id,
-                }
-            }
-            DomainEvent::ActorBlocked { blocker, target } => {
-                let (kind, id) = identity_to_payload(target);
-                EventPayload::ActorBlocked {
-                    blocker_id: blocker.value().to_string(),
-                    target_kind: kind,
-                    target_id: id,
-                }
-            }
-            DomainEvent::ActorUnblocked { blocker, target } => {
-                let (kind, id) = identity_to_payload(target);
-                EventPayload::ActorUnblocked {
-                    blocker_id: blocker.value().to_string(),
-                    target_kind: kind,
-                    target_id: id,
-                }
-            }
-            DomainEvent::BackfillFollower {
-                owner_user_id,
-                follower_inbox_url,
-            } => EventPayload::BackfillFollower {
-                owner_user_id: owner_user_id.value().to_string(),
-                follower_inbox_url: follower_inbox_url.clone(),
-            },
-            DomainEvent::FederationDeliveryRequested {
-                inbox_url,
-                activity_json,
-                signing_actor_id,
-            } => EventPayload::FederationDeliveryRequested {
-                inbox_url: inbox_url.clone(),
-                activity_json: activity_json.clone(),
-                signing_actor_id: signing_actor_id.to_string(),
-            },
-            DomainEvent::WatchEventIngested {
-                user_id,
-                title,
-                source,
-            } => EventPayload::WatchEventIngested {
-                user_id: user_id.value().to_string(),
-                title: title.clone(),
-                source: source.clone(),
-            },
-            DomainEvent::WrapUpRequested {
-                wrapup_id,
-                user_id,
-                start_date,
-                end_date,
-            } => EventPayload::WrapUpRequested {
-                wrapup_id: wrapup_id.value().to_string(),
-                user_id: user_id.as_ref().map(|u| u.value().to_string()),
-                start_date: start_date.to_string(),
-                end_date: end_date.to_string(),
-            },
-            DomainEvent::WrapUpCompleted { wrapup_id } => EventPayload::WrapUpCompleted {
-                wrapup_id: wrapup_id.value().to_string(),
-            },
-            DomainEvent::SearchReindexRequested => EventPayload::SearchReindexRequested,
-            DomainEvent::PosterSynced { movie_id } => EventPayload::PosterSynced {
-                movie_id: movie_id.value().to_string(),
-            },
-            DomainEvent::GoalCreated {
-                goal_id,
-                user_id,
-                year,
-                target_count,
-            } => EventPayload::GoalCreated {
-                goal_id: goal_id.value().to_string(),
-                user_id: user_id.value().to_string(),
-                year: *year,
-                target_count: *target_count,
-            },
-            DomainEvent::GoalUpdated {
-                goal_id,
-                user_id,
-                year,
-                target_count,
-            } => EventPayload::GoalUpdated {
-                goal_id: goal_id.value().to_string(),
-                user_id: user_id.value().to_string(),
-                year: *year,
-                target_count: *target_count,
-            },
-            DomainEvent::GoalDeleted {
-                goal_id,
-                user_id,
-                year,
-            } => EventPayload::GoalDeleted {
-                goal_id: goal_id.value().to_string(),
-                user_id: user_id.value().to_string(),
-                year: *year,
-            },
-            DomainEvent::PersonEnrichmentRequested {
-                person_id,
-                external_person_id,
-            } => EventPayload::PersonEnrichmentRequested {
-                person_id: person_id.value().to_string(),
-                external_person_id: external_person_id.value().to_string(),
-            },
-            DomainEvent::UserDeleted { user_id } => EventPayload::UserDeleted {
-                user_id: user_id.value().to_string(),
-            },
-            DomainEvent::UserAccountMoved {
-                user_id,
-                new_actor_url,
-            } => EventPayload::UserAccountMoved {
-                user_id: user_id.value().to_string(),
-                new_actor_url: new_actor_url.clone(),
-            },
-        }
-    }
-}
-
-impl TryFrom<EventPayload> for DomainEvent {
-    type Error = DomainError;
-    fn try_from(payload: EventPayload) -> Result<Self, DomainError> {
-        match payload {
-            EventPayload::ReviewLogged {
-                review_id,
-                movie_id,
-                user_id,
-                rating,
-                watched_at,
-            } => Ok(DomainEvent::ReviewLogged {
-                review_id: ReviewId::from_uuid(parse_uuid(&review_id, "review_id")?),
-                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                rating: Rating::new(rating)?,
-                watched_at: parse_ts(watched_at)?,
-            }),
-            EventPayload::ReviewUpdated {
-                review_id,
-                movie_id,
-                user_id,
-                rating,
-                watched_at,
-            } => Ok(DomainEvent::ReviewUpdated {
-                review_id: ReviewId::from_uuid(parse_uuid(&review_id, "review_id")?),
-                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                rating: Rating::new(rating)?,
-                watched_at: parse_ts(watched_at)?,
-            }),
-            EventPayload::MovieDiscovered {
-                movie_id,
-                external_metadata_id,
-            } => Ok(DomainEvent::MovieDiscovered {
-                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                external_metadata_id: ExternalMetadataId::new(external_metadata_id)?,
-            }),
-            EventPayload::MovieDeleted {
-                movie_id,
-                poster_path,
-            } => {
-                let movie_id = MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?);
-                let poster_path = poster_path
-                    .map(PosterPath::new)
-                    .transpose()
-                    .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-                Ok(DomainEvent::MovieDeleted {
-                    movie_id,
-                    poster_path,
-                })
-            }
-            EventPayload::UserUpdated { user_id } => Ok(DomainEvent::UserUpdated {
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-            }),
-            EventPayload::ReviewDeleted { review_id, user_id } => Ok(DomainEvent::ReviewDeleted {
-                review_id: ReviewId::from_uuid(parse_uuid(&review_id, "review_id")?),
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-            }),
-            EventPayload::MovieEnrichmentRequested {
-                movie_id,
-                external_metadata_id,
-            } => Ok(DomainEvent::MovieEnrichmentRequested {
-                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                external_metadata_id: ExternalMetadataId::new(external_metadata_id)
-                    .map_err(|e| DomainError::InfrastructureError(e.to_string()))?,
-            }),
-            EventPayload::ImageStored { key } => Ok(DomainEvent::ImageStored { key }),
-            EventPayload::WatchlistEntryAdded {
-                user_id,
-                movie_id,
-                movie_title,
-                release_year,
-                external_metadata_id,
-                added_at,
-            } => Ok(DomainEvent::WatchlistEntryAdded {
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                movie_title,
-                release_year,
-                external_metadata_id,
-                added_at: parse_ts(added_at)?,
-            }),
-            EventPayload::WatchlistEntryRemoved { user_id, movie_id } => {
-                Ok(DomainEvent::WatchlistEntryRemoved {
-                    user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                    movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-                })
-            }
-            EventPayload::FollowRequested {
-                follower_id,
-                target_kind,
-                target_id,
-            } => Ok(DomainEvent::FollowRequested {
-                follower: UserId::from_uuid(parse_uuid(&follower_id, "follower_id")?),
-                target: payload_to_follow_target(&target_kind, target_id)?,
-            }),
-            EventPayload::FollowAccepted {
-                owner_id,
-                requester_kind,
-                requester_id,
-            } => Ok(DomainEvent::FollowAccepted {
-                owner: UserId::from_uuid(parse_uuid(&owner_id, "owner_id")?),
-                requester: payload_to_identity(&requester_kind, requester_id)?,
-            }),
-            EventPayload::FollowRejected {
-                owner_id,
-                requester_kind,
-                requester_id,
-            } => Ok(DomainEvent::FollowRejected {
-                owner: UserId::from_uuid(parse_uuid(&owner_id, "owner_id")?),
-                requester: payload_to_identity(&requester_kind, requester_id)?,
-            }),
-            EventPayload::Unfollowed {
-                follower_id,
-                target_kind,
-                target_id,
-            } => Ok(DomainEvent::Unfollowed {
-                follower: UserId::from_uuid(parse_uuid(&follower_id, "follower_id")?),
-                target: payload_to_identity(&target_kind, target_id)?,
-            }),
-            EventPayload::FollowerRemoved {
-                owner_id,
-                follower_kind,
-                follower_id,
-            } => Ok(DomainEvent::FollowerRemoved {
-                owner: UserId::from_uuid(parse_uuid(&owner_id, "owner_id")?),
-                follower: payload_to_identity(&follower_kind, follower_id)?,
-            }),
-            EventPayload::ActorBlocked {
-                blocker_id,
-                target_kind,
-                target_id,
-            } => Ok(DomainEvent::ActorBlocked {
-                blocker: UserId::from_uuid(parse_uuid(&blocker_id, "blocker_id")?),
-                target: payload_to_identity(&target_kind, target_id)?,
-            }),
-            EventPayload::ActorUnblocked {
-                blocker_id,
-                target_kind,
-                target_id,
-            } => Ok(DomainEvent::ActorUnblocked {
-                blocker: UserId::from_uuid(parse_uuid(&blocker_id, "blocker_id")?),
-                target: payload_to_identity(&target_kind, target_id)?,
-            }),
-            EventPayload::BackfillFollower {
-                owner_user_id,
-                follower_inbox_url,
-            } => Ok(DomainEvent::BackfillFollower {
-                owner_user_id: UserId::from_uuid(parse_uuid(&owner_user_id, "owner_user_id")?),
-                follower_inbox_url,
-            }),
-            EventPayload::FederationDeliveryRequested {
-                inbox_url,
-                activity_json,
-                signing_actor_id,
-            } => Ok(DomainEvent::FederationDeliveryRequested {
-                inbox_url,
-                activity_json,
-                signing_actor_id: parse_uuid(&signing_actor_id, "signing_actor_id")?,
-            }),
-            EventPayload::WatchEventIngested {
-                user_id,
-                title,
-                source,
-            } => Ok(DomainEvent::WatchEventIngested {
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                title,
-                source,
-            }),
-            EventPayload::WrapUpRequested {
-                wrapup_id,
-                user_id,
-                start_date,
-                end_date,
-            } => {
-                let wid = parse_uuid(&wrapup_id, "wrapup_id")?;
-                let uid = user_id.map(|s| parse_uuid(&s, "user_id")).transpose()?;
-                let sd = chrono::NaiveDate::parse_from_str(&start_date, "%Y-%m-%d")
-                    .map_err(|e| DomainError::ValidationError(e.to_string()))?;
-                let ed = chrono::NaiveDate::parse_from_str(&end_date, "%Y-%m-%d")
-                    .map_err(|e| DomainError::ValidationError(e.to_string()))?;
-                Ok(DomainEvent::WrapUpRequested {
-                    wrapup_id: WrapUpId::from_uuid(wid),
-                    user_id: uid.map(UserId::from_uuid),
-                    start_date: sd,
-                    end_date: ed,
-                })
-            }
-            EventPayload::WrapUpCompleted { wrapup_id } => {
-                let wid = parse_uuid(&wrapup_id, "wrapup_id")?;
-                Ok(DomainEvent::WrapUpCompleted {
-                    wrapup_id: WrapUpId::from_uuid(wid),
-                })
-            }
-            EventPayload::SearchReindexRequested => Ok(DomainEvent::SearchReindexRequested),
-            EventPayload::PosterSynced { movie_id } => Ok(DomainEvent::PosterSynced {
-                movie_id: MovieId::from_uuid(parse_uuid(&movie_id, "movie_id")?),
-            }),
-            EventPayload::GoalCreated {
-                goal_id,
-                user_id,
-                year,
-                target_count,
-            } => Ok(DomainEvent::GoalCreated {
-                goal_id: GoalId::from_uuid(parse_uuid(&goal_id, "goal_id")?),
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                year,
-                target_count,
-            }),
-            EventPayload::GoalUpdated {
-                goal_id,
-                user_id,
-                year,
-                target_count,
-            } => Ok(DomainEvent::GoalUpdated {
-                goal_id: GoalId::from_uuid(parse_uuid(&goal_id, "goal_id")?),
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                year,
-                target_count,
-            }),
-            EventPayload::GoalDeleted {
-                goal_id,
-                user_id,
-                year,
-            } => Ok(DomainEvent::GoalDeleted {
-                goal_id: GoalId::from_uuid(parse_uuid(&goal_id, "goal_id")?),
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                year,
-            }),
-            EventPayload::PersonEnrichmentRequested {
-                person_id,
-                external_person_id,
-            } => Ok(DomainEvent::PersonEnrichmentRequested {
-                person_id: PersonId::from_uuid(parse_uuid(&person_id, "person_id")?),
-                external_person_id: ExternalPersonId::new(external_person_id),
-            }),
-            EventPayload::UserDeleted { user_id } => Ok(DomainEvent::UserDeleted {
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-            }),
-            EventPayload::UserAccountMoved {
-                user_id,
-                new_actor_url,
-            } => Ok(DomainEvent::UserAccountMoved {
-                user_id: UserId::from_uuid(parse_uuid(&user_id, "user_id")?),
-                new_actor_url,
-            }),
-        }
-    }
-}
-
-#[cfg(test)]
-#[path = "tests/lib.rs"]
-mod tests;

crates/adapters/event-payload/src/tests/lib.rs

@@ -1,101 +0,0 @@
-use super::*;
-
-fn fixed_dt() -> NaiveDateTime {
-    chrono::DateTime::from_timestamp(1_700_000_000, 0)
-        .unwrap()
-        .naive_utc()
-}
-
-fn review_logged() -> DomainEvent {
-    DomainEvent::ReviewLogged {
-        review_id: ReviewId::from_uuid(Uuid::new_v4()),
-        movie_id: MovieId::from_uuid(Uuid::new_v4()),
-        user_id: UserId::from_uuid(Uuid::new_v4()),
-        rating: Rating::new(4).unwrap(),
-        watched_at: fixed_dt(),
-    }
-}
-
-fn review_updated() -> DomainEvent {
-    DomainEvent::ReviewUpdated {
-        review_id: ReviewId::from_uuid(Uuid::new_v4()),
-        movie_id: MovieId::from_uuid(Uuid::new_v4()),
-        user_id: UserId::from_uuid(Uuid::new_v4()),
-        rating: Rating::new(3).unwrap(),
-        watched_at: fixed_dt(),
-    }
-}
-
-fn movie_discovered() -> DomainEvent {
-    DomainEvent::MovieDiscovered {
-        movie_id: MovieId::from_uuid(Uuid::new_v4()),
-        external_metadata_id: ExternalMetadataId::new("tt1234567".into()).unwrap(),
-    }
-}
-
-fn round_trip(event: DomainEvent) {
-    let payload = EventPayload::from(&event);
-    let json = serde_json::to_string(&payload).expect("serialize");
-    let back: EventPayload = serde_json::from_str(&json).expect("deserialize");
-    let recovered = DomainEvent::try_from(back).expect("try_from");
-    assert_eq!(EventPayload::from(&event), EventPayload::from(&recovered));
-}
-
-#[test]
-fn round_trip_review_logged() {
-    round_trip(review_logged());
-}
-
-#[test]
-fn round_trip_review_updated() {
-    round_trip(review_updated());
-}
-
-#[test]
-fn round_trip_movie_discovered() {
-    round_trip(movie_discovered());
-}
-
-#[test]
-fn serialized_format_is_tagged() {
-    let payload = EventPayload::from(&movie_discovered());
-    let json = serde_json::to_string(&payload).unwrap();
-    assert!(json.contains(r#""type":"MovieDiscovered""#));
-    assert!(json.contains(r#""data":"#));
-}
-
-#[test]
-fn event_type_strings() {
-    assert_eq!(
-        EventPayload::from(&review_logged()).event_type(),
-        "ReviewLogged"
-    );
-    assert_eq!(
-        EventPayload::from(&review_updated()).event_type(),
-        "ReviewUpdated"
-    );
-    assert_eq!(
-        EventPayload::from(&movie_discovered()).event_type(),
-        "MovieDiscovered"
-    );
-}
-
-#[test]
-fn round_trip_image_stored() {
-    let event = DomainEvent::ImageStored {
-        key: "avatars/abc123".into(),
-    };
-    let payload = EventPayload::from(&event);
-    let json = serde_json::to_string(&payload).unwrap();
-    let back: EventPayload = serde_json::from_str(&json).unwrap();
-    let recovered = DomainEvent::try_from(back).unwrap();
-    assert_eq!(EventPayload::from(&event), EventPayload::from(&recovered));
-}
-
-#[test]
-fn image_stored_event_type() {
-    let payload = EventPayload::from(&DomainEvent::ImageStored {
-        key: "posters/x".into(),
-    });
-    assert_eq!(payload.event_type(), "ImageStored");
-}

crates/adapters/event-publisher/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "event-publisher"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-domain      = { workspace = true }
-async-trait = { workspace = true }
-tokio       = { workspace = true }
-futures     = { workspace = true }

crates/adapters/event-publisher/src/lib.rs

@@ -1,92 +0,0 @@
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    events::{AckHandle, DomainEvent, EventEnvelope},
-    ports::{EventConsumer, EventPublisher},
-};
-use futures::stream::{self, BoxStream};
-use std::sync::Arc;
-use tokio::sync::Mutex;
-use tokio::sync::mpsc;
-
-pub use domain::ports::EventHandler;
-
-pub struct EventPublisherConfig {
-    pub channel_buffer: usize,
-}
-
-impl EventPublisherConfig {
-    pub fn from_env() -> Self {
-        let channel_buffer = std::env::var("EVENT_CHANNEL_BUFFER")
-            .ok()
-            .and_then(|v| v.parse().ok())
-            .unwrap_or(128);
-        Self { channel_buffer }
-    }
-}
-
-pub struct ChannelEventPublisher {
-    sender: mpsc::Sender<DomainEvent>,
-}
-
-#[async_trait]
-impl EventPublisher for ChannelEventPublisher {
-    async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> {
-        self.sender
-            .send(event.clone())
-            .await
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-    }
-}
-
-struct NoopAck;
-
-#[async_trait]
-impl AckHandle for NoopAck {
-    async fn ack(&self) -> Result<(), DomainError> {
-        Ok(())
-    }
-    async fn nack(&self) -> Result<(), DomainError> {
-        Ok(())
-    }
-}
-
-pub struct ChannelEventConsumer {
-    receiver: Arc<Mutex<mpsc::Receiver<DomainEvent>>>,
-}
-
-impl EventConsumer for ChannelEventConsumer {
-    fn consume(&self) -> BoxStream<'_, Result<EventEnvelope, DomainError>> {
-        let receiver = Arc::clone(&self.receiver);
-        Box::pin(stream::unfold(receiver, |rx| async move {
-            let event = rx.lock().await.recv().await?;
-            let envelope = EventEnvelope::new(event, Box::new(NoopAck));
-            Some((Ok(envelope), rx))
-        }))
-    }
-}
-
-pub struct NoopEventPublisher;
-
-#[async_trait]
-impl EventPublisher for NoopEventPublisher {
-    async fn publish(&self, _event: &DomainEvent) -> Result<(), DomainError> {
-        Ok(())
-    }
-}
-
-pub fn create_event_channel(
-    config: EventPublisherConfig,
-) -> (ChannelEventPublisher, ChannelEventConsumer) {
-    let (tx, rx) = mpsc::channel(config.channel_buffer);
-    (
-        ChannelEventPublisher { sender: tx },
-        ChannelEventConsumer {
-            receiver: Arc::new(Mutex::new(rx)),
-        },
-    )
-}
-
-#[cfg(test)]
-#[path = "tests/lib.rs"]
-mod tests;

crates/adapters/event-publisher/src/tests/lib.rs

@@ -1,57 +0,0 @@
-use super::*;
-use domain::{
-    events::DomainEvent,
-    value_objects::{ExternalMetadataId, MovieId},
-};
-use futures::StreamExt;
-
-fn movie_discovered() -> DomainEvent {
-    DomainEvent::MovieDiscovered {
-        movie_id: MovieId::generate(),
-        external_metadata_id: ExternalMetadataId::new("tt1234567".into()).unwrap(),
-    }
-}
-
-#[tokio::test]
-async fn consumer_yields_published_events() {
-    let config = EventPublisherConfig { channel_buffer: 8 };
-    let (publisher, consumer) = create_event_channel(config);
-
-    publisher.publish(&movie_discovered()).await.unwrap();
-    drop(publisher);
-
-    let mut stream = consumer.consume();
-    let envelope = stream.next().await.unwrap().unwrap();
-    assert!(matches!(
-        envelope.event,
-        DomainEvent::MovieDiscovered { .. }
-    ));
-    assert!(stream.next().await.is_none());
-}
-
-#[tokio::test]
-async fn consumer_yields_multiple_events_in_order() {
-    let config = EventPublisherConfig { channel_buffer: 8 };
-    let (publisher, consumer) = create_event_channel(config);
-
-    publisher.publish(&movie_discovered()).await.unwrap();
-    publisher.publish(&movie_discovered()).await.unwrap();
-    drop(publisher);
-
-    let mut stream = consumer.consume();
-    let first = stream.next().await.unwrap().unwrap();
-    let second = stream.next().await.unwrap().unwrap();
-    assert!(matches!(first.event, DomainEvent::MovieDiscovered { .. }));
-    assert!(matches!(second.event, DomainEvent::MovieDiscovered { .. }));
-    assert!(stream.next().await.is_none());
-}
-
-#[tokio::test]
-async fn stream_ends_when_publisher_dropped() {
-    let config = EventPublisherConfig { channel_buffer: 8 };
-    let (publisher, consumer) = create_event_channel(config);
-    drop(publisher);
-
-    let mut stream = consumer.consume();
-    assert!(stream.next().await.is_none());
-}

crates/adapters/export/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "export"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-domain = { workspace = true }
-async-trait = { workspace = true }
-serde_json = { workspace = true }
-chrono = { workspace = true }
-futures = { workspace = true }
-bytes = { workspace = true }
-async-stream = { workspace = true }
-
-[dev-dependencies]
-uuid = { workspace = true }
-tokio = { workspace = true }

crates/adapters/export/src/lib.rs

@@ -1,111 +0,0 @@
-use bytes::Bytes;
-use domain::{
-    errors::DomainError,
-    models::{DiaryEntry, ExportFormat},
-    ports::DiaryExporter,
-};
-use futures::stream::BoxStream;
-
-pub struct ExportAdapter;
-
-impl DiaryExporter for ExportAdapter {
-    fn stream_entries(
-        &self,
-        stream: BoxStream<'static, Result<DiaryEntry, DomainError>>,
-        format: ExportFormat,
-    ) -> BoxStream<'static, Result<Bytes, DomainError>> {
-        match format {
-            ExportFormat::Csv => stream_csv(stream),
-            ExportFormat::Json => stream_json(stream),
-        }
-    }
-}
-
-fn stream_csv(
-    entries: BoxStream<'static, Result<DiaryEntry, DomainError>>,
-) -> BoxStream<'static, Result<Bytes, DomainError>> {
-    use futures::StreamExt;
-    let header = futures::stream::once(async {
-        Ok(Bytes::from_static(
-            b"title,year,director,rating,comment,watched_at,external_metadata_id\n",
-        ))
-    });
-    let rows = entries.map(|r| r.map(|e| Bytes::from(csv_row(&e))));
-    Box::pin(header.chain(rows))
-}
-
-fn stream_json(
-    stream: BoxStream<'static, Result<DiaryEntry, DomainError>>,
-) -> BoxStream<'static, Result<Bytes, DomainError>> {
-    Box::pin(async_stream::stream! {
-        futures::pin_mut!(stream);
-        let mut is_first = true;
-        while let Some(r) = futures::StreamExt::next(&mut stream).await {
-            match r {
-                Err(e) => { yield Err(e); return; }
-                Ok(entry) => {
-                    let json = serde_json::to_string(&entry_to_json(&entry))
-                        .map_err(|e| DomainError::InfrastructureError(e.to_string()));
-                    let json = match json {
-                        Ok(s) => s,
-                        Err(e) => { yield Err(e); return; }
-                    };
-                    let prefix = if is_first { "[" } else { "," };
-                    is_first = false;
-                    yield Ok(Bytes::from(format!("{}{}", prefix, json)));
-                }
-            }
-        }
-        if is_first {
-            yield Ok(Bytes::from_static(b"[]"));
-        } else {
-            yield Ok(Bytes::from_static(b"]"));
-        }
-    })
-}
-
-fn csv_row(e: &DiaryEntry) -> String {
-    let title = csv_escape(e.movie().title().value());
-    let year = e.movie().release_year().value();
-    let director = e.movie().director().map(csv_escape).unwrap_or_default();
-    let rating = e.review().rating().value();
-    let comment = e
-        .review()
-        .comment()
-        .map(|c| csv_escape(c.value()))
-        .unwrap_or_default();
-    let watched_at = e.review().watched_at().format("%Y-%m-%d");
-    let ext_id = e
-        .movie()
-        .external_metadata_id()
-        .map(|id| id.value().to_string())
-        .unwrap_or_default();
-    format!(
-        "{},{},{},{},{},{},{}\n",
-        title, year, director, rating, comment, watched_at, ext_id
-    )
-}
-
-fn csv_escape(s: &str) -> String {
-    if s.contains(',') || s.contains('"') || s.contains('\n') {
-        format!("\"{}\"", s.replace('"', "\"\""))
-    } else {
-        s.to_string()
-    }
-}
-
-fn entry_to_json(e: &DiaryEntry) -> serde_json::Value {
-    serde_json::json!({
-        "title": e.movie().title().value(),
-        "year": e.movie().release_year().value(),
-        "director": e.movie().director(),
-        "rating": e.review().rating().value(),
-        "comment": e.review().comment().map(|c| c.value().to_string()),
-        "watched_at": e.review().watched_at().format("%Y-%m-%d").to_string(),
-        "external_metadata_id": e.movie().external_metadata_id().map(|id| id.value().to_string()),
-    })
-}
-
-#[cfg(test)]
-#[path = "tests/lib.rs"]
-mod tests;

crates/adapters/export/src/tests/lib.rs

@@ -1,163 +0,0 @@
-use super::ExportAdapter;
-use domain::{
-    models::{DiaryEntry, ExportFormat, Movie, Review},
-    ports::DiaryExporter,
-    value_objects::{ExternalMetadataId, MovieTitle, Rating, ReleaseYear},
-};
-
-async fn collect_stream(
-    stream: futures::stream::BoxStream<'static, Result<bytes::Bytes, domain::errors::DomainError>>,
-) -> Vec<u8> {
-    use futures::StreamExt;
-    let mut out = Vec::new();
-    futures::pin_mut!(stream);
-    while let Some(chunk) = stream.next().await {
-        out.extend_from_slice(&chunk.unwrap());
-    }
-    out
-}
-
-fn entry_stream(
-    entries: Vec<domain::models::DiaryEntry>,
-) -> futures::stream::BoxStream<
-    'static,
-    Result<domain::models::DiaryEntry, domain::errors::DomainError>,
-> {
-    Box::pin(futures::stream::iter(entries.into_iter().map(Ok)))
-}
-
-fn make_entry(
-    title: &str,
-    year: u16,
-    director: Option<&str>,
-    rating: u8,
-    comment: Option<&str>,
-) -> DiaryEntry {
-    make_entry_full(title, year, director, rating, comment, None)
-}
-
-fn make_entry_full(
-    title: &str,
-    year: u16,
-    director: Option<&str>,
-    rating: u8,
-    comment: Option<&str>,
-    external_id: Option<&str>,
-) -> DiaryEntry {
-    let movie = Movie::new(
-        external_id.map(|id| ExternalMetadataId::new(id.to_string()).unwrap()),
-        MovieTitle::new(title.to_string()).unwrap(),
-        ReleaseYear::new(year).unwrap(),
-        director.map(str::to_string),
-        None,
-    );
-    let user_id = domain::value_objects::UserId::from_uuid(uuid::Uuid::new_v4());
-    let review = Review::new(
-        movie.id().clone(),
-        user_id,
-        Rating::new(rating).unwrap(),
-        comment.map(|c| domain::value_objects::Comment::new(c.to_string()).unwrap()),
-        chrono::NaiveDate::from_ymd_opt(2024, 3, 15)
-            .unwrap()
-            .and_hms_opt(0, 0, 0)
-            .unwrap(),
-        None,
-    )
-    .unwrap();
-    DiaryEntry::new(movie, review)
-}
-
-#[tokio::test]
-async fn csv_has_header_and_one_row() {
-    let adapter = ExportAdapter;
-    let entry = make_entry(
-        "Inception",
-        2010,
-        Some("Christopher Nolan"),
-        5,
-        Some("great"),
-    );
-    let bytes =
-        collect_stream(adapter.stream_entries(entry_stream(vec![entry]), ExportFormat::Csv)).await;
-    let text = String::from_utf8(bytes).unwrap();
-    assert!(
-        text.starts_with("title,year,director,rating,comment,watched_at,external_metadata_id\n")
-    );
-    assert!(text.contains("Inception"));
-    assert!(text.contains("2010"));
-    assert!(text.contains("Christopher Nolan"));
-    assert!(text.contains("5"));
-    assert!(text.contains("great"));
-    assert!(text.contains("2024-03-15"));
-}
-
-#[tokio::test]
-async fn csv_escapes_commas_in_title() {
-    let adapter = ExportAdapter;
-    let entry = make_entry("Tár, A Film", 2022, None, 4, None);
-    let bytes =
-        collect_stream(adapter.stream_entries(entry_stream(vec![entry]), ExportFormat::Csv)).await;
-    let text = String::from_utf8(bytes).unwrap();
-    assert!(text.contains("\"Tár, A Film\""));
-}
-
-#[tokio::test]
-async fn json_is_valid_array() {
-    let adapter = ExportAdapter;
-    let entry = make_entry("Dune", 2021, Some("Denis Villeneuve"), 5, None);
-    let bytes =
-        collect_stream(adapter.stream_entries(entry_stream(vec![entry]), ExportFormat::Json)).await;
-    let arr: Vec<serde_json::Value> = serde_json::from_slice(&bytes).unwrap();
-    assert_eq!(arr.len(), 1);
-    assert_eq!(arr[0]["title"], "Dune");
-    assert_eq!(arr[0]["year"], 2021);
-    assert_eq!(arr[0]["rating"], 5);
-    assert_eq!(arr[0]["comment"], serde_json::Value::Null);
-    assert_eq!(arr[0]["external_metadata_id"], serde_json::Value::Null);
-}
-
-#[tokio::test]
-async fn external_metadata_id_included_when_present() {
-    let adapter = ExportAdapter;
-    let entry = make_entry_full("Alien", 1979, None, 5, None, Some("tt0078748"));
-    let bytes =
-        collect_stream(adapter.stream_entries(entry_stream(vec![entry]), ExportFormat::Json)).await;
-    let arr: Vec<serde_json::Value> = serde_json::from_slice(&bytes).unwrap();
-    assert_eq!(arr[0]["external_metadata_id"], "tt0078748");
-
-    let bytes = collect_stream(adapter.stream_entries(
-        entry_stream(vec![make_entry_full(
-            "Alien",
-            1979,
-            None,
-            5,
-            None,
-            Some("tt0078748"),
-        )]),
-        ExportFormat::Csv,
-    ))
-    .await;
-    let text = String::from_utf8(bytes).unwrap();
-    assert!(text.contains("tt0078748"));
-}
-
-#[tokio::test]
-async fn empty_entries_returns_csv_header_only() {
-    let adapter = ExportAdapter;
-    let bytes =
-        collect_stream(adapter.stream_entries(entry_stream(vec![]), ExportFormat::Csv)).await;
-    let text = String::from_utf8(bytes).unwrap();
-    assert_eq!(
-        text,
-        "title,year,director,rating,comment,watched_at,external_metadata_id\n"
-    );
-}
-
-#[tokio::test]
-async fn empty_json_is_valid_empty_array() {
-    let adapter = ExportAdapter;
-    let bytes =
-        collect_stream(adapter.stream_entries(entry_stream(vec![]), ExportFormat::Json)).await;
-    let arr: Vec<serde_json::Value> = serde_json::from_slice(&bytes).unwrap();
-    assert!(arr.is_empty());
-}

crates/adapters/image-converter/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "image-converter"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-domain      = { workspace = true }
-async-trait = { workspace = true }
-anyhow      = { workspace = true }
-tracing     = { workspace = true }
-tokio       = { workspace = true }
-image       = { version = "0.25", default-features = false, features = ["jpeg", "png", "webp"] }
-ravif       = { version = "0.11", default-features = false }
-webp        = "0.3"
-
-[dev-dependencies]
-object-storage = { workspace = true }
-object_store = "0.11"
-uuid = { workspace = true }

crates/adapters/image-converter/src/backfill.rs

@@ -1,55 +0,0 @@
-use std::{sync::Arc, time::Duration};
-
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    events::DomainEvent,
-    ports::{EventPublisher, ImageRefQuery, PeriodicJob},
-};
-
-pub struct ConversionBackfillJob {
-    image_ref: Arc<dyn ImageRefQuery>,
-    event_publisher: Arc<dyn EventPublisher>,
-}
-
-impl ConversionBackfillJob {
-    pub fn new(
-        image_ref: Arc<dyn ImageRefQuery>,
-        event_publisher: Arc<dyn EventPublisher>,
-    ) -> Self {
-        Self {
-            image_ref,
-            event_publisher,
-        }
-    }
-}
-
-#[async_trait]
-impl PeriodicJob for ConversionBackfillJob {
-    fn interval(&self) -> Duration {
-        Duration::from_secs(60 * 60 * 24) // 24h
-    }
-
-    async fn run(&self) -> Result<(), DomainError> {
-        let keys = self.image_ref.list_keys().await?;
-
-        for key in keys {
-            if key.ends_with(".avif") || key.ends_with(".webp") {
-                continue;
-            }
-            if let Err(e) = self
-                .event_publisher
-                .publish(&DomainEvent::ImageStored { key: key.clone() })
-                .await
-            {
-                tracing::warn!("backfill: failed to emit ImageStored for {key}: {e}");
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-#[path = "tests/backfill.rs"]
-mod tests;

crates/adapters/image-converter/src/config.rs

@@ -1,51 +0,0 @@
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Format {
-    Avif,
-    Webp,
-}
-
-impl Format {
-    pub fn extension(self) -> &'static str {
-        match self {
-            Format::Avif => ".avif",
-            Format::Webp => ".webp",
-        }
-    }
-}
-
-pub struct ConversionConfig {
-    pub format: Format,
-}
-
-impl ConversionConfig {
-    pub fn from_env() -> anyhow::Result<Option<Self>> {
-        Self::from_vars(
-            std::env::var("IMAGE_CONVERSION_ENABLED").ok().as_deref(),
-            std::env::var("IMAGE_CONVERSION_FORMAT").ok().as_deref(),
-        )
-    }
-
-    fn from_vars(enabled: Option<&str>, format: Option<&str>) -> anyhow::Result<Option<Self>> {
-        if enabled != Some("true") {
-            return Ok(None);
-        }
-
-        let format_str = format.ok_or_else(|| {
-            anyhow::anyhow!("IMAGE_CONVERSION_FORMAT required when IMAGE_CONVERSION_ENABLED=true")
-        })?;
-
-        let format = match format_str {
-            "avif" => Format::Avif,
-            "webp" => Format::Webp,
-            other => anyhow::bail!(
-                "Unknown IMAGE_CONVERSION_FORMAT: {other:?}. Valid values: avif, webp"
-            ),
-        };
-
-        Ok(Some(Self { format }))
-    }
-}
-
-#[cfg(test)]
-#[path = "tests/config.rs"]
-mod tests;

crates/adapters/image-converter/src/handler.rs

@@ -1,105 +0,0 @@
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    events::DomainEvent,
-    ports::{EventHandler, ImageRefCommand, ObjectStorage},
-};
-
-use crate::Format;
-
-pub struct ImageConversionHandler {
-    storage: Arc<dyn ObjectStorage>,
-    image_ref: Arc<dyn ImageRefCommand>,
-    format: Format,
-}
-
-impl ImageConversionHandler {
-    pub fn new(
-        storage: Arc<dyn ObjectStorage>,
-        image_ref: Arc<dyn ImageRefCommand>,
-        format: Format,
-    ) -> Self {
-        Self {
-            storage,
-            image_ref,
-            format,
-        }
-    }
-}
-
-#[async_trait]
-impl EventHandler for ImageConversionHandler {
-    async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
-        let key = match event {
-            DomainEvent::ImageStored { key } => key.clone(),
-            _ => return Ok(()),
-        };
-
-        if key.ends_with(".avif") || key.ends_with(".webp") {
-            return Ok(());
-        }
-
-        let bytes = self.storage.get(&key).await?;
-        let format = self.format;
-
-        let converted = tokio::task::spawn_blocking(move || convert(bytes, format))
-            .await
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?
-            .map_err(DomainError::InfrastructureError)?;
-
-        let ext = format.extension();
-        let new_key = format!("{key}{ext}");
-        self.storage.store(&new_key, &converted).await?;
-
-        if let Err(e) = self.image_ref.swap(&key, &new_key).await {
-            tracing::error!("swap failed for {key} → {new_key}: {e}");
-            return Err(e);
-        }
-
-        if let Err(e) = self.storage.delete(&key).await {
-            tracing::warn!("failed to delete old image key {key}: {e}");
-        }
-
-        tracing::info!("converted {key} → {new_key}");
-        Ok(())
-    }
-}
-
-fn convert(bytes: Vec<u8>, format: Format) -> Result<Vec<u8>, String> {
-    let img = image::load_from_memory(&bytes).map_err(|e| e.to_string())?;
-
-    match format {
-        Format::Avif => {
-            let rgba = img.to_rgba8();
-            let width = rgba.width() as usize;
-            let height = rgba.height() as usize;
-            let pixels: Vec<ravif::RGBA8> = rgba
-                .pixels()
-                .map(|p| ravif::RGBA8 {
-                    r: p.0[0],
-                    g: p.0[1],
-                    b: p.0[2],
-                    a: p.0[3],
-                })
-                .collect();
-            let result = ravif::Encoder::new()
-                .with_quality(80.0)
-                .with_speed(6)
-                .encode_rgba(ravif::Img::new(&pixels, width, height))
-                .map_err(|e| e.to_string())?;
-            Ok(result.avif_file.to_vec())
-        }
-        Format::Webp => {
-            let rgba = img.to_rgba8();
-            let (width, height) = (rgba.width(), rgba.height());
-            let encoder = webp::Encoder::from_rgba(rgba.as_raw(), width, height);
-            Ok(encoder.encode(80.0).to_vec())
-        }
-    }
-}
-
-#[cfg(test)]
-#[path = "tests/handler.rs"]
-mod tests;

crates/adapters/image-converter/src/lib.rs

@@ -1,41 +0,0 @@
-mod backfill;
-mod config;
-mod handler;
-
-pub use backfill::ConversionBackfillJob;
-pub use config::{ConversionConfig, Format};
-pub use handler::ImageConversionHandler;
-
-use domain::ports::{
-    EventHandler, EventPublisher, ImageRefCommand, ImageRefQuery, ObjectStorage, PeriodicJob,
-};
-use std::sync::Arc;
-
-type ConversionPair = (Arc<dyn EventHandler>, Arc<dyn PeriodicJob>);
-
-pub fn build(
-    object_storage: Arc<dyn ObjectStorage>,
-    image_ref_command: Arc<dyn ImageRefCommand>,
-    image_ref_query: Arc<dyn ImageRefQuery>,
-    event_publisher: Arc<dyn EventPublisher>,
-) -> anyhow::Result<Option<ConversionPair>> {
-    let config = match ConversionConfig::from_env()? {
-        Some(c) => c,
-        None => return Ok(None),
-    };
-
-    let format = config.format;
-
-    let handler = Arc::new(ImageConversionHandler::new(
-        Arc::clone(&object_storage),
-        image_ref_command,
-        format,
-    )) as Arc<dyn EventHandler>;
-
-    let job = Arc::new(ConversionBackfillJob::new(
-        image_ref_query,
-        Arc::clone(&event_publisher),
-    )) as Arc<dyn PeriodicJob>;
-
-    Ok(Some((handler, job)))
-}

crates/adapters/image-converter/src/tests/backfill.rs

@@ -1,85 +0,0 @@
-use super::*;
-use std::sync::Mutex;
-
-struct MockImageRef {
-    keys: Vec<String>,
-}
-
-#[async_trait::async_trait]
-impl ImageRefQuery for MockImageRef {
-    async fn list_keys(&self) -> Result<Vec<String>, DomainError> {
-        Ok(self.keys.clone())
-    }
-}
-
-struct MockPublisher {
-    emitted: Mutex<Vec<String>>,
-}
-
-impl MockPublisher {
-    fn new() -> Arc<Self> {
-        Arc::new(Self {
-            emitted: Mutex::new(vec![]),
-        })
-    }
-
-    fn emitted(&self) -> Vec<String> {
-        self.emitted.lock().unwrap().clone()
-    }
-}
-
-#[async_trait::async_trait]
-impl EventPublisher for MockPublisher {
-    async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> {
-        if let DomainEvent::ImageStored { key } = event {
-            self.emitted.lock().unwrap().push(key.clone());
-        }
-        Ok(())
-    }
-}
-
-#[tokio::test]
-async fn emits_image_stored_for_unconverted_keys() {
-    let image_ref = Arc::new(MockImageRef {
-        keys: vec!["avatars/u1".into(), "posters/m1".into()],
-    });
-    let publisher = MockPublisher::new();
-    let job =
-        ConversionBackfillJob::new(image_ref, Arc::clone(&publisher) as Arc<dyn EventPublisher>);
-
-    job.run().await.unwrap();
-
-    let mut emitted = publisher.emitted();
-    emitted.sort();
-    assert_eq!(emitted, vec!["avatars/u1", "posters/m1"]);
-}
-
-#[tokio::test]
-async fn skips_already_converted_keys() {
-    let image_ref = Arc::new(MockImageRef {
-        keys: vec![
-            "avatars/u1.avif".into(),
-            "posters/m1".into(),
-            "avatars/u2.webp".into(),
-        ],
-    });
-    let publisher = MockPublisher::new();
-    let job =
-        ConversionBackfillJob::new(image_ref, Arc::clone(&publisher) as Arc<dyn EventPublisher>);
-
-    job.run().await.unwrap();
-
-    assert_eq!(publisher.emitted(), vec!["posters/m1"]);
-}
-
-#[tokio::test]
-async fn empty_keys_emits_nothing() {
-    let image_ref = Arc::new(MockImageRef { keys: vec![] });
-    let publisher = MockPublisher::new();
-    let job =
-        ConversionBackfillJob::new(image_ref, Arc::clone(&publisher) as Arc<dyn EventPublisher>);
-
-    job.run().await.unwrap();
-
-    assert!(publisher.emitted().is_empty());
-}

crates/adapters/image-converter/src/tests/config.rs

@@ -1,45 +0,0 @@
-use super::*;
-
-#[test]
-fn disabled_by_default() {
-    assert!(ConversionConfig::from_vars(None, None).unwrap().is_none());
-    assert!(ConversionConfig::from_vars(Some("false"), None)
-        .unwrap()
-        .is_none());
-}
-
-#[test]
-fn enabled_avif() {
-    let cfg = ConversionConfig::from_vars(Some("true"), Some("avif"))
-        .unwrap()
-        .unwrap();
-    assert_eq!(cfg.format, Format::Avif);
-}
-
-#[test]
-fn enabled_webp() {
-    let cfg = ConversionConfig::from_vars(Some("true"), Some("webp"))
-        .unwrap()
-        .unwrap();
-    assert_eq!(cfg.format, Format::Webp);
-}
-
-#[test]
-fn unknown_format_is_error() {
-    assert!(ConversionConfig::from_vars(Some("true"), Some("gif")).is_err());
-}
-
-#[test]
-fn missing_format_when_enabled_is_error() {
-    assert!(ConversionConfig::from_vars(Some("true"), None).is_err());
-}
-
-#[test]
-fn avif_extension() {
-    assert_eq!(Format::Avif.extension(), ".avif");
-}
-
-#[test]
-fn webp_extension() {
-    assert_eq!(Format::Webp.extension(), ".webp");
-}

crates/adapters/image-converter/src/tests/handler.rs

@@ -1,160 +0,0 @@
-use super::*;
-use object_storage::ObjectStorageAdapter;
-use object_store::memory::InMemory;
-use std::sync::Mutex;
-
-struct MockImageRef {
-    swaps: Mutex<Vec<(String, String)>>,
-}
-
-impl MockImageRef {
-    fn new() -> Arc<Self> {
-        Arc::new(Self {
-            swaps: Mutex::new(vec![]),
-        })
-    }
-
-    fn swaps(&self) -> Vec<(String, String)> {
-        self.swaps.lock().unwrap().clone()
-    }
-}
-
-#[async_trait::async_trait]
-impl ImageRefCommand for MockImageRef {
-    async fn swap(&self, old: &str, new: &str) -> Result<(), DomainError> {
-        self.swaps.lock().unwrap().push((old.into(), new.into()));
-        Ok(())
-    }
-}
-
-fn in_memory_storage() -> Arc<ObjectStorageAdapter> {
-    Arc::new(ObjectStorageAdapter::new(Arc::new(InMemory::new())))
-}
-
-fn tiny_jpeg() -> Vec<u8> {
-    use image::{DynamicImage, ImageBuffer, Rgb};
-    let img = DynamicImage::ImageRgb8(ImageBuffer::from_pixel(4, 4, Rgb([200u8, 100, 50])));
-    let mut buf = std::io::Cursor::new(Vec::new());
-    img.write_to(&mut buf, image::ImageFormat::Jpeg).unwrap();
-    buf.into_inner()
-}
-
-#[tokio::test]
-async fn ignores_non_image_stored_events() {
-    let storage = in_memory_storage();
-    let image_ref = MockImageRef::new();
-    let handler = ImageConversionHandler::new(
-        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
-        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
-        Format::Avif,
-    );
-
-    handler
-        .handle(&DomainEvent::UserUpdated {
-            user_id: domain::value_objects::UserId::from_uuid(uuid::Uuid::new_v4()),
-        })
-        .await
-        .unwrap();
-
-    assert!(image_ref.swaps().is_empty());
-}
-
-#[tokio::test]
-async fn skips_already_converted_avif_key() {
-    let storage = in_memory_storage();
-    storage
-        .store("avatars/u1.avif", &tiny_jpeg())
-        .await
-        .unwrap();
-    let image_ref = MockImageRef::new();
-    let handler = ImageConversionHandler::new(
-        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
-        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
-        Format::Avif,
-    );
-
-    handler
-        .handle(&DomainEvent::ImageStored {
-            key: "avatars/u1.avif".into(),
-        })
-        .await
-        .unwrap();
-
-    assert!(image_ref.swaps().is_empty());
-}
-
-#[tokio::test]
-async fn skips_already_converted_webp_key() {
-    let storage = in_memory_storage();
-    storage
-        .store("posters/m1.webp", &tiny_jpeg())
-        .await
-        .unwrap();
-    let image_ref = MockImageRef::new();
-    let handler = ImageConversionHandler::new(
-        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
-        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
-        Format::Webp,
-    );
-
-    handler
-        .handle(&DomainEvent::ImageStored {
-            key: "posters/m1.webp".into(),
-        })
-        .await
-        .unwrap();
-
-    assert!(image_ref.swaps().is_empty());
-}
-
-#[tokio::test]
-async fn converts_jpeg_to_avif_and_swaps_key() {
-    let storage = in_memory_storage();
-    storage.store("avatars/u1", &tiny_jpeg()).await.unwrap();
-    let image_ref = MockImageRef::new();
-    let handler = ImageConversionHandler::new(
-        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
-        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
-        Format::Avif,
-    );
-
-    handler
-        .handle(&DomainEvent::ImageStored {
-            key: "avatars/u1".into(),
-        })
-        .await
-        .unwrap();
-
-    assert_eq!(
-        image_ref.swaps(),
-        vec![("avatars/u1".into(), "avatars/u1.avif".into())]
-    );
-    assert!(storage.get("avatars/u1.avif").await.is_ok());
-    // Old raw key deleted — fallback resolves to .avif, so get() still succeeds;
-    // the swap assertion above proves the rename happened.
-}
-
-#[tokio::test]
-async fn converts_jpeg_to_webp_and_swaps_key() {
-    let storage = in_memory_storage();
-    storage.store("avatars/u1", &tiny_jpeg()).await.unwrap();
-    let image_ref = MockImageRef::new();
-    let handler = ImageConversionHandler::new(
-        Arc::clone(&storage) as Arc<dyn ObjectStorage>,
-        Arc::clone(&image_ref) as Arc<dyn ImageRefCommand>,
-        Format::Webp,
-    );
-
-    handler
-        .handle(&DomainEvent::ImageStored {
-            key: "avatars/u1".into(),
-        })
-        .await
-        .unwrap();
-
-    assert_eq!(
-        image_ref.swaps(),
-        vec![("avatars/u1".into(), "avatars/u1.webp".into())]
-    );
-    assert!(storage.get("avatars/u1.webp").await.is_ok());
-}

crates/adapters/importer/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "importer"
-version = "0.1.0"
-edition = "2024"
-
-[features]
-xlsx = ["dep:calamine"]
-
-[dependencies]
-domain = { workspace = true }
-serde_json = { workspace = true }
-csv = { workspace = true }
-calamine = { version = "0.35", optional = true }

crates/adapters/importer/src/lib.rs

@@ -1,32 +0,0 @@
-mod mapper;
-mod parsers;
-
-use domain::{
-    models::{AnnotatedRow, FieldMapping, FileFormat, ImportError, ParsedFile},
-    ports::DocumentParser,
-};
-
-pub struct ImporterDocumentParser;
-
-impl DocumentParser for ImporterDocumentParser {
-    fn parse(&self, bytes: &[u8], format: FileFormat) -> Result<ParsedFile, ImportError> {
-        match format {
-            FileFormat::Csv => parsers::parse_csv(bytes),
-            FileFormat::Json => parsers::parse_json(bytes),
-            FileFormat::Xlsx => {
-                #[cfg(feature = "xlsx")]
-                {
-                    parsers::parse_xlsx(bytes)
-                }
-                #[cfg(not(feature = "xlsx"))]
-                {
-                    Err(ImportError::Xlsx("XLSX support not compiled in".into()))
-                }
-            }
-        }
-    }
-
-    fn apply_mapping(&self, file: &ParsedFile, mappings: &[FieldMapping]) -> Vec<AnnotatedRow> {
-        mapper::apply_mapping(file, mappings)
-    }
-}

crates/adapters/importer/src/mapper.rs

@@ -1,85 +0,0 @@
-use domain::models::{
-    AnnotatedRow, DomainField, FieldMapping, ImportRow, ParsedFile, RowResult, Transform,
-};
-
-pub fn apply_mapping(file: &ParsedFile, mappings: &[FieldMapping]) -> Vec<AnnotatedRow> {
-    file.rows
-        .iter()
-        .map(|row| {
-            let result = map_row(row, &file.columns, mappings);
-            AnnotatedRow {
-                result,
-                is_duplicate: false,
-            }
-        })
-        .collect()
-}
-
-fn map_row(row: &[String], columns: &[String], mappings: &[FieldMapping]) -> RowResult {
-    let mut import_row = ImportRow::default();
-    let mut errors = Vec::new();
-
-    for mapping in mappings {
-        let Some(col_idx) = columns.iter().position(|c| c == &mapping.source_column) else {
-            continue;
-        };
-        let raw_value = row.get(col_idx).map(|s| s.as_str()).unwrap_or("").trim();
-        if raw_value.is_empty() {
-            continue;
-        }
-        if let Some(value) = apply_transform(raw_value, &mapping.transform, &mut errors) {
-            set_field(&mut import_row, &mapping.domain_field, value);
-        }
-    }
-
-    if import_row.title.is_none() && import_row.external_metadata_id.is_none() {
-        errors.push("missing required field: title or external_metadata_id".into());
-    }
-    if import_row.rating.is_none() {
-        errors.push("missing required field: rating".into());
-    }
-    if import_row.watched_at.is_none() {
-        errors.push("missing required field: watched_at".into());
-    }
-
-    if errors.is_empty() {
-        RowResult::Valid(import_row)
-    } else {
-        let raw = columns
-            .iter()
-            .zip(row.iter())
-            .map(|(c, v)| (c.clone(), v.clone()))
-            .collect();
-        RowResult::Invalid { errors, raw }
-    }
-}
-
-fn apply_transform(value: &str, transform: &Transform, errors: &mut Vec<String>) -> Option<String> {
-    match transform {
-        Transform::Identity => Some(value.to_string()),
-        Transform::DateFormat(_) => Some(value.to_string()),
-        Transform::RatingScale(factor) => match value.parse::<f64>() {
-            Ok(n) => Some((n * factor).round().to_string()),
-            Err(_) => {
-                errors.push(format!("rating '{}' is not a number", value));
-                None
-            }
-        },
-    }
-}
-
-fn set_field(row: &mut ImportRow, field: &DomainField, value: String) {
-    match field {
-        DomainField::Title => row.title = Some(value),
-        DomainField::ReleaseYear => row.release_year = Some(value),
-        DomainField::Director => row.director = Some(value),
-        DomainField::Rating => row.rating = Some(value),
-        DomainField::WatchedAt => row.watched_at = Some(value),
-        DomainField::Comment => row.comment = Some(value),
-        DomainField::ExternalMetadataId => row.external_metadata_id = Some(value),
-    }
-}
-
-#[cfg(test)]
-#[path = "tests/mapper.rs"]
-mod tests;

crates/adapters/importer/src/parsers/csv.rs

@@ -1,48 +0,0 @@
-use domain::models::{ImportError, ParsedFile};
-
-pub fn parse_csv(bytes: &[u8]) -> Result<ParsedFile, ImportError> {
-    if bytes.is_empty() {
-        return Err(ImportError::Empty);
-    }
-
-    let delimiter = detect_delimiter(bytes);
-    let mut rdr = csv::ReaderBuilder::new()
-        .delimiter(delimiter)
-        .from_reader(bytes);
-
-    let columns: Vec<String> = rdr
-        .headers()
-        .map_err(|e| ImportError::Csv(e.to_string()))?
-        .iter()
-        .map(|s| s.trim().to_string())
-        .collect();
-
-    if columns.is_empty() {
-        return Err(ImportError::NoHeader);
-    }
-
-    let rows: Vec<Vec<String>> = rdr
-        .records()
-        .map(|r| {
-            r.map_err(|e| ImportError::Csv(e.to_string())).map(|rec| {
-                let mut cells: Vec<String> = rec.iter().map(|f| f.trim().to_string()).collect();
-                cells.resize(columns.len(), String::new());
-                cells.truncate(columns.len());
-                cells
-            })
-        })
-        .collect::<Result<_, _>>()?;
-
-    if rows.is_empty() {
-        return Err(ImportError::Empty);
-    }
-
-    Ok(ParsedFile { columns, rows })
-}
-
-fn detect_delimiter(bytes: &[u8]) -> u8 {
-    let first_line = bytes.split(|&b| b == b'\n').next().unwrap_or(bytes);
-    let tabs = first_line.iter().filter(|&&b| b == b'\t').count();
-    let commas = first_line.iter().filter(|&&b| b == b',').count();
-    if tabs > commas { b'\t' } else { b',' }
-}

crates/adapters/importer/src/parsers/json.rs

@@ -1,48 +0,0 @@
-use domain::models::{ImportError, ParsedFile};
-use serde_json::Value;
-
-pub fn parse_json(bytes: &[u8]) -> Result<ParsedFile, ImportError> {
-    let value: Value =
-        serde_json::from_slice(bytes).map_err(|e| ImportError::Json(e.to_string()))?;
-
-    let arr = value
-        .as_array()
-        .ok_or_else(|| ImportError::Json("expected a JSON array".into()))?;
-
-    if arr.is_empty() {
-        return Err(ImportError::Empty);
-    }
-
-    let first = arr[0]
-        .as_object()
-        .ok_or_else(|| ImportError::Json("array elements must be objects".into()))?;
-    let columns: Vec<String> = first.keys().cloned().collect();
-
-    if columns.is_empty() {
-        return Err(ImportError::NoHeader);
-    }
-
-    let rows: Vec<Vec<String>> = arr
-        .iter()
-        .enumerate()
-        .map(|(idx, item)| {
-            let obj = item.as_object().ok_or_else(|| {
-                ImportError::Json(format!("element at index {} is not an object", idx))
-            })?;
-            Ok(columns
-                .iter()
-                .map(|col| obj.get(col).map(value_to_string).unwrap_or_default())
-                .collect())
-        })
-        .collect::<Result<_, ImportError>>()?;
-
-    Ok(ParsedFile { columns, rows })
-}
-
-fn value_to_string(v: &Value) -> String {
-    match v {
-        Value::String(s) => s.clone(),
-        Value::Null => String::new(),
-        other => other.to_string(),
-    }
-}

crates/adapters/importer/src/parsers/mod.rs

@@ -1,13 +0,0 @@
-mod csv;
-mod json;
-#[cfg(feature = "xlsx")]
-mod xlsx;
-
-pub use csv::parse_csv;
-pub use json::parse_json;
-#[cfg(feature = "xlsx")]
-pub use xlsx::parse_xlsx;
-
-#[cfg(test)]
-#[path = "tests.rs"]
-mod tests;

crates/adapters/importer/src/parsers/tests.rs

@@ -1,37 +0,0 @@
-use super::*;
-
-#[test]
-fn csv_parses_headers_and_rows() {
-    let data = b"title,rating,watched_at\nInception,5,2024-01-01\nDune,4,2024-02-15\n";
-    let file = parse_csv(data).unwrap();
-    assert_eq!(file.columns, vec!["title", "rating", "watched_at"]);
-    assert_eq!(file.rows.len(), 2);
-    assert_eq!(file.rows[0], vec!["Inception", "5", "2024-01-01"]);
-}
-
-#[test]
-fn csv_rejects_empty() {
-    assert!(parse_csv(b"").is_err());
-}
-
-#[test]
-fn tsv_parses_correctly() {
-    let data = b"title\trating\nInception\t5\n";
-    let file = parse_csv(data).unwrap();
-    assert_eq!(file.columns, vec!["title", "rating"]);
-    assert_eq!(file.rows[0], vec!["Inception", "5"]);
-}
-
-#[test]
-fn json_array_of_objects() {
-    let data = br#"[{"title":"Inception","rating":"5"},{"title":"Dune","rating":"4"}]"#;
-    let file = parse_json(data).unwrap();
-    assert_eq!(file.columns.len(), 2);
-    assert!(file.columns.contains(&"title".to_string()));
-    assert_eq!(file.rows.len(), 2);
-}
-
-#[test]
-fn json_empty_array_errors() {
-    assert!(parse_json(b"[]").is_err());
-}

crates/adapters/importer/src/parsers/xlsx.rs

@@ -1,71 +0,0 @@
-use calamine::{Data, Reader, Xlsx, open_workbook_from_rs};
-use domain::models::{ImportError, ParsedFile};
-use std::io::Cursor;
-
-pub fn parse_xlsx(bytes: &[u8]) -> Result<ParsedFile, ImportError> {
-    let cursor = Cursor::new(bytes);
-    let mut workbook: Xlsx<_> = open_workbook_from_rs(cursor)
-        .map_err(|e: calamine::XlsxError| ImportError::Xlsx(e.to_string()))?;
-
-    let sheet_name = workbook
-        .sheet_names()
-        .first()
-        .cloned()
-        .ok_or(ImportError::Empty)?;
-
-    let range = workbook
-        .worksheet_range(&sheet_name)
-        .map_err(|e| ImportError::Xlsx(e.to_string()))?;
-
-    let mut iter = range.rows();
-
-    let header = iter.next().ok_or(ImportError::NoHeader)?;
-    let columns: Vec<String> = header
-        .iter()
-        .map(|c| cell_to_string(c).trim().to_string())
-        .collect();
-
-    if columns.is_empty() {
-        return Err(ImportError::NoHeader);
-    }
-
-    let rows: Vec<Vec<String>> = iter
-        .map(|row| {
-            let mut cells: Vec<String> = row.iter().map(cell_to_string).collect();
-            cells.resize(columns.len(), String::new());
-            cells.truncate(columns.len());
-            cells
-        })
-        .collect();
-
-    if rows.is_empty() {
-        return Err(ImportError::Empty);
-    }
-
-    Ok(ParsedFile { columns, rows })
-}
-
-fn cell_to_string(cell: &Data) -> String {
-    match cell {
-        Data::String(s) => s.clone(),
-        Data::Float(f) => {
-            if f.fract() == 0.0 {
-                format!("{}", *f as i64)
-            } else {
-                format!("{}", f)
-            }
-        }
-        Data::Int(i) => i.to_string(),
-        Data::Bool(b) => b.to_string(),
-        Data::DateTime(dt) => {
-            // ExcelDateTime::to_ymd_hms_milli() works without the chrono feature.
-            let (year, month, day, _, _, _, _) = dt.to_ymd_hms_milli();
-            format!("{:04}-{:02}-{:02}", year, month, day)
-        }
-        Data::DateTimeIso(s) => s.clone(),
-        Data::DurationIso(s) => s.clone(),
-        Data::Empty | Data::Error(_) => String::new(),
-        // Fallback for unexpected calamine Data variants; renders as debug string
-        other => format!("{other:?}"),
-    }
-}

crates/adapters/importer/src/tests/mapper.rs

@@ -1,158 +0,0 @@
-use super::*;
-use domain::models::{DomainField, FieldMapping, ParsedFile, RowResult, Transform};
-
-fn sample_file() -> ParsedFile {
-    ParsedFile {
-        columns: vec!["Name".into(), "Stars".into(), "Date".into()],
-        rows: vec![
-            vec!["Inception".into(), "10".into(), "2024-01-15".into()],
-            vec!["Dune".into(), "8".into(), "2024-02-20".into()],
-            vec!["".into(), "3".into(), "2024-03-01".into()], // missing title → invalid
-        ],
-    }
-}
-
-fn full_mappings() -> Vec<FieldMapping> {
-    vec![
-        FieldMapping {
-            source_column: "Name".into(),
-            domain_field: DomainField::Title,
-            transform: Transform::Identity,
-        },
-        FieldMapping {
-            source_column: "Stars".into(),
-            domain_field: DomainField::Rating,
-            transform: Transform::RatingScale(0.5),
-        },
-        FieldMapping {
-            source_column: "Date".into(),
-            domain_field: DomainField::WatchedAt,
-            transform: Transform::Identity,
-        },
-    ]
-}
-
-#[test]
-fn maps_valid_rows() {
-    let results = apply_mapping(&sample_file(), &full_mappings());
-    assert_eq!(results.len(), 3);
-    // First two rows are valid
-    assert!(matches!(results[0].result, RowResult::Valid(_)));
-    assert!(matches!(results[1].result, RowResult::Valid(_)));
-    // is_duplicate defaults to false
-    assert!(!results[0].is_duplicate);
-}
-
-#[test]
-fn applies_rating_scale_transform() {
-    let results = apply_mapping(&sample_file(), &full_mappings());
-    if let RowResult::Valid(row) = &results[0].result {
-        // 10 * 0.5 = 5
-        assert_eq!(row.rating.as_deref(), Some("5"));
-    } else {
-        panic!("expected Valid");
-    }
-}
-
-#[test]
-fn marks_missing_required_fields_invalid() {
-    let results = apply_mapping(&sample_file(), &full_mappings());
-    // Row 2 has empty title
-    assert!(matches!(results[2].result, RowResult::Invalid { .. }));
-}
-
-#[test]
-fn ignores_unmapped_columns() {
-    let mappings = vec![FieldMapping {
-        source_column: "Name".into(),
-        domain_field: DomainField::Title,
-        transform: Transform::Identity,
-    }];
-    let file = ParsedFile {
-        columns: vec!["Name".into(), "Extra".into()],
-        rows: vec![vec!["Inception".into(), "ignored".into()]],
-    };
-    let results = apply_mapping(&file, &mappings);
-    assert_eq!(results.len(), 1);
-    // Missing rating and watched_at → invalid
-    assert!(matches!(results[0].result, RowResult::Invalid { .. }));
-}
-
-#[test]
-fn nonexistent_source_column_skipped() {
-    let mappings = vec![FieldMapping {
-        source_column: "DoesNotExist".into(),
-        domain_field: DomainField::Title,
-        transform: Transform::Identity,
-    }];
-    let file = ParsedFile {
-        columns: vec!["Name".into()],
-        rows: vec![vec!["Inception".into()]],
-    };
-    let results = apply_mapping(&file, &mappings);
-    // Column not found → field not set → invalid (missing title, rating, watched_at)
-    assert!(matches!(results[0].result, RowResult::Invalid { .. }));
-}
-
-#[test]
-fn collects_all_errors_not_just_first() {
-    let mappings = vec![
-        FieldMapping {
-            source_column: "Name".into(),
-            domain_field: DomainField::Title,
-            transform: Transform::Identity,
-        },
-        FieldMapping {
-            source_column: "Stars".into(),
-            domain_field: DomainField::Rating,
-            transform: Transform::RatingScale(0.5),
-        },
-        // no watched_at mapping
-    ];
-    let file = ParsedFile {
-        columns: vec!["Name".into(), "Stars".into()],
-        rows: vec![vec!["Inception".into(), "notanumber".into()]],
-    };
-    let results = apply_mapping(&file, &mappings);
-    if let RowResult::Invalid { errors, .. } = &results[0].result {
-        assert!(
-            errors.iter().any(|e| e.contains("not a number")),
-            "expected rating error, got: {:?}",
-            errors
-        );
-        assert!(
-            errors.iter().any(|e| e.contains("watched_at")),
-            "expected watched_at error, got: {:?}",
-            errors
-        );
-    } else {
-        panic!("expected Invalid");
-    }
-}
-
-#[test]
-fn non_numeric_rating_produces_error_in_row() {
-    let mappings = vec![
-        FieldMapping {
-            source_column: "Name".into(),
-            domain_field: DomainField::Title,
-            transform: Transform::Identity,
-        },
-        FieldMapping {
-            source_column: "Stars".into(),
-            domain_field: DomainField::Rating,
-            transform: Transform::RatingScale(0.5),
-        },
-        FieldMapping {
-            source_column: "Date".into(),
-            domain_field: DomainField::WatchedAt,
-            transform: Transform::Identity,
-        },
-    ];
-    let file = ParsedFile {
-        columns: vec!["Name".into(), "Stars".into(), "Date".into()],
-        rows: vec![vec!["Inception".into(), "five".into(), "2024-01-15".into()]],
-    };
-    let results = apply_mapping(&file, &mappings);
-    assert!(matches!(results[0].result, RowResult::Invalid { .. }));
-}

crates/adapters/jellyfin/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "jellyfin"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-domain = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }

crates/adapters/jellyfin/src/lib.rs

@@ -1,132 +0,0 @@
-use domain::{errors::DomainError, models::ParsedPlaybackEvent, ports::MediaServerParser};
-use serde::Deserialize;
-
-pub struct JellyfinParser;
-
-impl MediaServerParser for JellyfinParser {
-    fn parse_playback_event(
-        &self,
-        body: &[u8],
-    ) -> Result<Option<ParsedPlaybackEvent>, DomainError> {
-        let payload: JellyfinPayload = serde_json::from_slice(body)
-            .map_err(|e| DomainError::ValidationError(format!("invalid Jellyfin payload: {e}")))?;
-
-        if payload.notification_type != "PlaybackStop" {
-            return Ok(None);
-        }
-
-        let item_type = payload.item_type.as_deref().unwrap_or("");
-        if item_type != "Movie" {
-            return Ok(None);
-        }
-
-        if !payload.played_to_completion.unwrap_or(false) {
-            return Ok(None);
-        }
-
-        let title = match payload.name {
-            Some(t) if !t.is_empty() => t,
-            _ => return Ok(None),
-        };
-
-        let tmdb_id = payload.provider_tmdb.map(|id| format!("tmdb:{id}"));
-        let imdb_id = payload.provider_imdb;
-
-        Ok(Some(ParsedPlaybackEvent {
-            title,
-            year: payload.year,
-            tmdb_id,
-            imdb_id,
-        }))
-    }
-}
-
-#[derive(Deserialize)]
-struct JellyfinPayload {
-    #[serde(rename = "NotificationType")]
-    notification_type: String,
-    #[serde(rename = "ItemType")]
-    item_type: Option<String>,
-    #[serde(rename = "Name")]
-    name: Option<String>,
-    #[serde(rename = "Year")]
-    year: Option<u16>,
-    #[serde(rename = "PlayedToCompletion")]
-    played_to_completion: Option<bool>,
-    #[serde(rename = "Provider_tmdb")]
-    provider_tmdb: Option<String>,
-    #[serde(rename = "Provider_imdb")]
-    provider_imdb: Option<String>,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parses_valid_playback_stop() {
-        let body = serde_json::json!({
-            "NotificationType": "PlaybackStop",
-            "ItemType": "Movie",
-            "Name": "Blade Runner",
-            "Year": 1982,
-            "PlayedToCompletion": true,
-            "Provider_tmdb": "78",
-            "Provider_imdb": "tt0083658"
-        });
-        let parser = JellyfinParser;
-        let result = parser
-            .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
-            .unwrap();
-        let event = result.expect("should parse");
-        assert_eq!(event.title, "Blade Runner");
-        assert_eq!(event.year, Some(1982));
-        assert_eq!(event.tmdb_id, Some("tmdb:78".into()));
-        assert_eq!(event.imdb_id, Some("tt0083658".into()));
-    }
-
-    #[test]
-    fn ignores_non_movie() {
-        let body = serde_json::json!({
-            "NotificationType": "PlaybackStop",
-            "ItemType": "Episode",
-            "Name": "Some Episode",
-            "PlayedToCompletion": true
-        });
-        let parser = JellyfinParser;
-        let result = parser
-            .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
-            .unwrap();
-        assert!(result.is_none());
-    }
-
-    #[test]
-    fn ignores_incomplete_playback() {
-        let body = serde_json::json!({
-            "NotificationType": "PlaybackStop",
-            "ItemType": "Movie",
-            "Name": "Blade Runner",
-            "PlayedToCompletion": false
-        });
-        let parser = JellyfinParser;
-        let result = parser
-            .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
-            .unwrap();
-        assert!(result.is_none());
-    }
-
-    #[test]
-    fn ignores_playback_start() {
-        let body = serde_json::json!({
-            "NotificationType": "PlaybackStart",
-            "ItemType": "Movie",
-            "Name": "Blade Runner",
-            "PlayedToCompletion": false
-        });
-        let parser = JellyfinParser;
-        let result = parser
-            .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
-            .unwrap();
-        assert!(result.is_none());
-    }
-}

crates/adapters/metadata/Cargo.toml

@@ -4,7 +4,6 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-anyhow = { workspace = true }
 async-trait = { workspace = true }
 reqwest = { workspace = true }
 serde = { workspace = true }

crates/adapters/metadata/src/lib.rs

@@ -1,13 +1,12 @@
 use async_trait::async_trait;
 use domain::{
     errors::DomainError,
-    models::{MetadataSearchCriteria, Movie},
-    ports::MetadataClient,
-    value_objects::{ExternalMetadataId, MovieId, MovieTitle, PosterUrl, ReleaseYear},
+    models::Movie,
+    ports::{MetadataClient, MetadataSearchCriteria},
+    value_objects::{ExternalMetadataId, MovieTitle, PosterUrl, ReleaseYear},
 };
 
 mod omdb;
-mod tmdb;
 
 pub(crate) struct ProviderMovie {
     pub imdb_id: ExternalMetadataId,
@@ -32,12 +31,6 @@ impl MetadataClientImpl {
             provider: Box::new(omdb::OmdbProvider::new(api_key)),
         }
     }
-
-    pub fn new_tmdb(api_key: String) -> Self {
-        Self {
-            provider: Box::new(tmdb::TmdbProvider::new(api_key)),
-        }
-    }
 }
 
 #[async_trait]
@@ -47,15 +40,7 @@ impl MetadataClient for MetadataClientImpl {
         criteria: &MetadataSearchCriteria,
     ) -> Result<Movie, DomainError> {
         let pm = self.provider.fetch(criteria).await?;
-        let movie_id = MovieId::from_external(&pm.imdb_id);
-        Ok(Movie::from_persistence(
-            movie_id,
-            Some(pm.imdb_id),
-            pm.title,
-            pm.release_year,
-            pm.director,
-            None,
-        ))
+        Ok(Movie::new(Some(pm.imdb_id), pm.title, pm.release_year, pm.director, None))
     }
 
     async fn get_poster_url(
@@ -67,14 +52,3 @@ impl MetadataClient for MetadataClientImpl {
         Ok(pm.poster_url)
     }
 }
-
-pub fn create() -> anyhow::Result<std::sync::Arc<dyn domain::ports::MetadataClient>> {
-    use anyhow::Context;
-    if let Ok(key) = std::env::var("TMDB_API_KEY") {
-        Ok(std::sync::Arc::new(MetadataClientImpl::new_tmdb(key)))
-    } else {
-        let key = std::env::var("OMDB_API_KEY")
-            .context("either TMDB_API_KEY or OMDB_API_KEY must be set")?;
-        Ok(std::sync::Arc::new(MetadataClientImpl::new_omdb(key)))
-    }
-}

crates/adapters/metadata/src/omdb.rs

@@ -1,7 +1,7 @@
 use async_trait::async_trait;
 use domain::{
     errors::DomainError,
-    models::MetadataSearchCriteria,
+    ports::MetadataSearchCriteria,
     value_objects::{ExternalMetadataId, MovieTitle, PosterUrl, ReleaseYear},
 };
 use serde::Deserialize;
@@ -56,9 +56,9 @@ impl MetadataProvider for OmdbProvider {
                     params.append_pair("i", id.value());
                 }
                 MetadataSearchCriteria::Title { title, year } => {
-                    params.append_pair("t", title.value());
+                    params.append_pair("t", title);
                     if let Some(y) = year {
-                        params.append_pair("y", &y.value().to_string());
+                        params.append_pair("y", &y.to_string());
                     }
                 }
             }
@@ -101,8 +101,8 @@ impl MetadataProvider for OmdbProvider {
             .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
         let title = MovieTitle::new(resp.title)
             .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        let release_year =
-            ReleaseYear::new(year).map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        let release_year = ReleaseYear::new(year)
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
 
         let director = match resp.director.as_str() {
             "N/A" | "" => None,
@@ -114,12 +114,6 @@ impl MetadataProvider for OmdbProvider {
             url => PosterUrl::new(url.to_string()).ok(),
         };
 
-        Ok(ProviderMovie {
-            imdb_id,
-            title,
-            release_year,
-            director,
-            poster_url,
-        })
+        Ok(ProviderMovie { imdb_id, title, release_year, director, poster_url })
     }
 }

crates/adapters/metadata/src/tmdb.rs

@@ -1,175 +0,0 @@
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    models::MetadataSearchCriteria,
-    value_objects::{ExternalMetadataId, MovieTitle, PosterUrl, ReleaseYear},
-};
-use serde::Deserialize;
-
-use crate::{MetadataProvider, ProviderMovie};
-
-pub(crate) struct TmdbProvider {
-    client: reqwest::Client,
-    api_key: String,
-}
-
-impl TmdbProvider {
-    pub(crate) fn new(api_key: String) -> Self {
-        Self {
-            client: reqwest::Client::new(),
-            api_key,
-        }
-    }
-
-    fn base(&self, path: &str) -> String {
-        format!("https://api.themoviedb.org/3{}", path)
-    }
-
-    fn poster_url(&self, path: &str) -> Option<PosterUrl> {
-        if path.is_empty() || path == "null" {
-            return None;
-        }
-        PosterUrl::new(format!("https://image.tmdb.org/t/p/w500{}", path)).ok()
-    }
-
-    async fn get<T: for<'de> Deserialize<'de>>(
-        &self,
-        url: &str,
-        extra: &[(&str, &str)],
-    ) -> Result<T, DomainError> {
-        let mut req = self
-            .client
-            .get(url)
-            .query(&[("api_key", self.api_key.as_str())]);
-        for (k, v) in extra {
-            req = req.query(&[(k, v)]);
-        }
-        req.send()
-            .await
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?
-            .error_for_status()
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?
-            .json::<T>()
-            .await
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-    }
-
-    async fn fetch_details(&self, tmdb_id: u64) -> Result<ProviderMovie, DomainError> {
-        #[derive(Deserialize)]
-        struct CrewMember {
-            job: String,
-            name: String,
-        }
-        #[derive(Deserialize)]
-        struct Credits {
-            crew: Vec<CrewMember>,
-        }
-        #[derive(Deserialize)]
-        struct Details {
-            imdb_id: Option<String>,
-            title: String,
-            release_date: String, // "YYYY-MM-DD"
-            poster_path: Option<String>,
-            credits: Credits,
-        }
-
-        let url = self.base(&format!("/movie/{}", tmdb_id));
-        let d: Details = self.get(&url, &[("append_to_response", "credits")]).await?;
-
-        let year: u16 = d
-            .release_date
-            .split('-')
-            .next()
-            .and_then(|y| y.parse().ok())
-            .ok_or_else(|| {
-                DomainError::InfrastructureError(format!(
-                    "Unparseable release_date: {}",
-                    d.release_date
-                ))
-            })?;
-
-        // Prefer IMDB ID; fall back to "tmdb:{id}" so the record is still usable.
-        let raw_id = d
-            .imdb_id
-            .filter(|s| !s.is_empty())
-            .unwrap_or_else(|| format!("tmdb:{}", tmdb_id));
-
-        let imdb_id = ExternalMetadataId::new(raw_id)
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        let title = MovieTitle::new(d.title)
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        let release_year =
-            ReleaseYear::new(year).map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-
-        let director = d
-            .credits
-            .crew
-            .into_iter()
-            .find(|c| c.job == "Director")
-            .map(|c| c.name);
-
-        let poster_url = d.poster_path.as_deref().and_then(|p| self.poster_url(p));
-
-        Ok(ProviderMovie {
-            imdb_id,
-            title,
-            release_year,
-            director,
-            poster_url,
-        })
-    }
-}
-
-#[async_trait]
-impl MetadataProvider for TmdbProvider {
-    async fn fetch(&self, criteria: &MetadataSearchCriteria) -> Result<ProviderMovie, DomainError> {
-        let tmdb_id: u64 = match criteria {
-            MetadataSearchCriteria::ImdbId(id) => {
-                #[derive(Deserialize)]
-                struct FindResult {
-                    id: u64,
-                }
-                #[derive(Deserialize)]
-                struct FindResponse {
-                    movie_results: Vec<FindResult>,
-                }
-                let url = self.base(&format!("/find/{}", id.value()));
-                let resp: FindResponse = self.get(&url, &[("external_source", "imdb_id")]).await?;
-                resp.movie_results
-                    .into_iter()
-                    .next()
-                    .ok_or_else(|| {
-                        DomainError::NotFound(format!("TMDB: no movie for {}", id.value()))
-                    })?
-                    .id
-            }
-            MetadataSearchCriteria::Title { title, year } => {
-                #[derive(Deserialize)]
-                struct SearchResult {
-                    id: u64,
-                }
-                #[derive(Deserialize)]
-                struct SearchResponse {
-                    results: Vec<SearchResult>,
-                }
-                let url = self.base("/search/movie");
-                let mut extra = vec![("query", title.value())];
-                let year_str;
-                if let Some(y) = year {
-                    year_str = y.value().to_string();
-                    extra.push(("year", year_str.as_str()));
-                }
-                let resp: SearchResponse = self.get(&url, &extra).await?;
-                resp.results
-                    .into_iter()
-                    .next()
-                    .ok_or_else(|| {
-                        DomainError::NotFound(format!("TMDB: no results for '{}'", title.value()))
-                    })?
-                    .id
-            }
-        };
-
-        self.fetch_details(tmdb_id).await
-    }
-}

crates/adapters/nats/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "nats"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-async-nats = "0.48.0"
-
-domain = { workspace = true }
-event-payload = { workspace = true }
-async-trait = { workspace = true }
-anyhow = { workspace = true }
-tracing = { workspace = true }
-serde_json = { workspace = true }
-uuid = { workspace = true }
-chrono = { workspace = true }
-tokio = { workspace = true }
-futures = { workspace = true }

crates/adapters/nats/src/config.rs

@@ -1,58 +0,0 @@
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum NatsMode {
-    Core,
-    JetStream,
-}
-
-#[derive(Debug, Clone)]
-pub struct NatsConfig {
-    pub url: String,
-    pub mode: NatsMode,
-    pub subject_prefix: String,
-    pub stream_name: String,
-    pub consumer_name: String,
-}
-
-impl NatsConfig {
-    pub fn from_env() -> anyhow::Result<Self> {
-        Self::from_vars(
-            std::env::var("NATS_URL").ok().as_deref(),
-            std::env::var("NATS_MODE").ok().as_deref(),
-            std::env::var("NATS_SUBJECT_PREFIX").ok().as_deref(),
-            std::env::var("NATS_STREAM_NAME").ok().as_deref(),
-            std::env::var("NATS_CONSUMER_NAME").ok().as_deref(),
-        )
-    }
-
-    pub(crate) fn from_vars(
-        url: Option<&str>,
-        mode: Option<&str>,
-        subject_prefix: Option<&str>,
-        stream_name: Option<&str>,
-        consumer_name: Option<&str>,
-    ) -> anyhow::Result<Self> {
-        let url = url.ok_or_else(|| anyhow::anyhow!("NATS_URL is not set"))?;
-
-        let mode = match mode.unwrap_or("jetstream") {
-            "core" => NatsMode::Core,
-            "jetstream" => NatsMode::JetStream,
-            other => anyhow::bail!("unknown NATS_MODE: {other}"),
-        };
-
-        let subject_prefix = subject_prefix.unwrap_or("movies-diary.events").to_string();
-        let stream_name = stream_name.unwrap_or("MOVIES_DIARY_EVENTS").to_string();
-        let consumer_name = consumer_name.unwrap_or("worker").to_string();
-
-        Ok(Self {
-            url: url.to_string(),
-            mode,
-            subject_prefix,
-            stream_name,
-            consumer_name,
-        })
-    }
-}
-
-#[cfg(test)]
-#[path = "tests/config.rs"]
-mod tests;

crates/adapters/nats/src/consumer.rs

@@ -1,214 +0,0 @@
-use async_nats::{
-    Client,
-    jetstream::{self, consumer::pull, message::AckKind, stream::Config as StreamConfig},
-};
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    events::{AckHandle, DomainEvent, EventEnvelope},
-    ports::EventConsumer,
-};
-use futures::{
-    StreamExt,
-    stream::{self, BoxStream},
-};
-use std::sync::Arc;
-use tokio::sync::{Mutex, mpsc};
-
-use crate::{config::NatsConfig, payload::NatsEventPayload, subject::consumer_subject_filter};
-
-// ── JetStream ack handle ─────────────────────────────────────────────────────
-
-struct NatsJetStreamAckHandle {
-    message: async_nats::jetstream::Message,
-}
-
-#[async_trait]
-impl AckHandle for NatsJetStreamAckHandle {
-    async fn ack(&self) -> Result<(), DomainError> {
-        tracing::debug!(
-            "acknowledging message with sequence {}",
-            self.message.info().unwrap().stream_sequence
-        );
-
-        self.message
-            .ack()
-            .await
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-    }
-
-    async fn nack(&self) -> Result<(), DomainError> {
-        tracing::debug!(
-            "negatively acknowledging message with sequence {}",
-            self.message.info().unwrap().stream_sequence
-        );
-
-        self.message
-            .ack_with(AckKind::Nak(None))
-            .await
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-    }
-}
-
-// ── Core NATS ack handle (no-op) ─────────────────────────────────────────────
-
-struct NoopAck;
-
-#[async_trait]
-impl AckHandle for NoopAck {
-    async fn ack(&self) -> Result<(), DomainError> {
-        Ok(())
-    }
-    async fn nack(&self) -> Result<(), DomainError> {
-        Ok(())
-    }
-}
-
-// ── Envelope construction helpers ────────────────────────────────────────────
-
-fn decode_js(msg: async_nats::jetstream::Message) -> Result<EventEnvelope, DomainError> {
-    let payload: NatsEventPayload = serde_json::from_slice(&msg.payload)
-        .map_err(|e| DomainError::InfrastructureError(format!("deserialize: {e}")))?;
-    let event = DomainEvent::try_from(payload)?;
-    Ok(EventEnvelope::new(
-        event,
-        Box::new(NatsJetStreamAckHandle { message: msg }),
-    ))
-}
-
-fn decode_core(msg: async_nats::Message) -> Result<EventEnvelope, DomainError> {
-    let payload: NatsEventPayload = serde_json::from_slice(&msg.payload)
-        .map_err(|e| DomainError::InfrastructureError(format!("deserialize: {e}")))?;
-    let event = DomainEvent::try_from(payload)?;
-    Ok(EventEnvelope::new(event, Box::new(NoopAck)))
-}
-
-// ── Channel-bridge shared by both consumers ──────────────────────────────────
-
-type EnvelopeRx = Arc<Mutex<mpsc::Receiver<Result<EventEnvelope, DomainError>>>>;
-
-fn consume_from_rx(rx: EnvelopeRx) -> BoxStream<'static, Result<EventEnvelope, DomainError>> {
-    Box::pin(stream::unfold(rx, |rx| async move {
-        let item = rx.lock().await.recv().await?;
-        Some((item, rx))
-    }))
-}
-
-// ── JetStream consumer ────────────────────────────────────────────────────────
-
-pub struct NatsJetStreamConsumer {
-    rx: EnvelopeRx,
-}
-
-impl NatsJetStreamConsumer {
-    pub async fn create(cfg: &NatsConfig, client: Client) -> anyhow::Result<Self> {
-        let js = jetstream::new(client);
-
-        let stream = js
-            .get_or_create_stream(StreamConfig {
-                name: cfg.stream_name.clone(),
-                subjects: vec![consumer_subject_filter(&cfg.subject_prefix)],
-                max_messages: 100_000,
-                ..Default::default()
-            })
-            .await?;
-
-        let subject_filter = consumer_subject_filter(&cfg.subject_prefix);
-        let consumer = stream
-            .get_or_create_consumer(
-                cfg.consumer_name.as_str(),
-                pull::Config {
-                    durable_name: Some(cfg.consumer_name.clone()),
-                    filter_subject: subject_filter,
-                    ack_wait: std::time::Duration::from_secs(600),
-                    ..Default::default()
-                },
-            )
-            .await?;
-
-        let (tx, rx) = mpsc::channel(128);
-
-        tokio::spawn(async move {
-            loop {
-                let mut messages = match consumer.messages().await {
-                    Err(e) => {
-                        tracing::error!("failed to fetch messages: {}", e);
-
-                        let _ = tx
-                            .send(Err(DomainError::InfrastructureError(e.to_string())))
-                            .await;
-                        return;
-                    }
-                    Ok(m) => m,
-                };
-                while let Some(result) = messages.next().await {
-                    let envelope = result
-                        .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-                        .and_then(decode_js);
-
-                    if tx.send(envelope).await.is_err() {
-                        tracing::info!("consumer channel closed, stopping message processing");
-                        return;
-                    }
-
-                    tracing::debug!("message sent to consumer channel");
-                }
-                // messages() stream ended (fetch expired in strict mode) — restart
-            }
-        });
-
-        Ok(Self {
-            rx: Arc::new(Mutex::new(rx)),
-        })
-    }
-}
-
-impl EventConsumer for NatsJetStreamConsumer {
-    fn consume(&self) -> BoxStream<'_, Result<EventEnvelope, DomainError>> {
-        consume_from_rx(Arc::clone(&self.rx))
-    }
-}
-
-// ── Core NATS consumer ────────────────────────────────────────────────────────
-
-pub struct NatsCoreConsumer {
-    rx: EnvelopeRx,
-}
-
-impl NatsCoreConsumer {
-    pub async fn create(cfg: &NatsConfig, client: Client) -> anyhow::Result<Self> {
-        let subject = consumer_subject_filter(&cfg.subject_prefix);
-        let mut subscriber = client.subscribe(subject).await?;
-
-        let (tx, rx) = mpsc::channel(128);
-
-        tokio::spawn(async move {
-            while let Some(msg) = subscriber.next().await {
-                let envelope = decode_core(msg);
-
-                tracing::debug!("message received and decoded, sending to consumer channel");
-
-                if tx.send(envelope).await.is_err() {
-                    tracing::info!("consumer channel closed, stopping message processing");
-                    break;
-                }
-            }
-        });
-
-        Ok(Self {
-            rx: Arc::new(Mutex::new(rx)),
-        })
-    }
-}
-
-impl EventConsumer for NatsCoreConsumer {
-    fn consume(&self) -> BoxStream<'_, Result<EventEnvelope, DomainError>> {
-        consume_from_rx(Arc::clone(&self.rx))
-    }
-}
-
-fn _assert_send_sync() {
-    fn check<T: Send + Sync>() {}
-    check::<NatsJetStreamConsumer>();
-    check::<NatsCoreConsumer>();
-}

crates/adapters/nats/src/lib.rs

@@ -1,52 +0,0 @@
-mod config;
-mod consumer;
-mod payload;
-mod publisher;
-mod subject;
-
-pub use config::{NatsConfig, NatsMode};
-pub use consumer::{NatsCoreConsumer, NatsJetStreamConsumer};
-pub use publisher::NatsEventPublisher;
-
-use std::sync::Arc;
-
-use domain::ports::{EventConsumer, EventPublisher};
-
-pub async fn create_publisher(cfg: NatsConfig) -> anyhow::Result<Arc<dyn EventPublisher>> {
-    let client = async_nats::connect(&cfg.url).await?;
-    let publisher: Arc<dyn EventPublisher> = match cfg.mode {
-        NatsMode::Core => Arc::new(NatsEventPublisher::new_core(client, cfg.subject_prefix)),
-        NatsMode::JetStream => Arc::new(NatsEventPublisher::new_jetstream(
-            client,
-            cfg.subject_prefix,
-        )),
-    };
-
-    tracing::info!("NATS publisher created (mode: {:?})", cfg.mode);
-    Ok(publisher)
-}
-
-pub async fn create_channel(
-    cfg: NatsConfig,
-) -> anyhow::Result<(Arc<dyn EventPublisher>, Arc<dyn EventConsumer>)> {
-    let client = async_nats::connect(&cfg.url).await?;
-
-    let publisher: Arc<dyn EventPublisher> = match cfg.mode {
-        NatsMode::Core => Arc::new(NatsEventPublisher::new_core(
-            client.clone(),
-            cfg.subject_prefix.clone(),
-        )),
-        NatsMode::JetStream => Arc::new(NatsEventPublisher::new_jetstream(
-            client.clone(),
-            cfg.subject_prefix.clone(),
-        )),
-    };
-
-    let consumer: Arc<dyn EventConsumer> = match cfg.mode {
-        NatsMode::Core => Arc::new(NatsCoreConsumer::create(&cfg, client).await?),
-        NatsMode::JetStream => Arc::new(NatsJetStreamConsumer::create(&cfg, client).await?),
-    };
-
-    tracing::info!("NATS channel created (mode: {:?})", cfg.mode);
-    Ok((publisher, consumer))
-}

crates/adapters/nats/src/payload.rs

@@ -1 +0,0 @@
-pub use event_payload::EventPayload as NatsEventPayload;

crates/adapters/nats/src/publisher.rs

@@ -1,60 +0,0 @@
-use async_nats::{Client, jetstream};
-use async_trait::async_trait;
-use domain::{errors::DomainError, events::DomainEvent, ports::EventPublisher};
-
-use crate::{payload::NatsEventPayload, subject::event_to_subject};
-
-enum PublisherMode {
-    Core(Client),
-    JetStream(jetstream::Context),
-}
-
-pub struct NatsEventPublisher {
-    mode: PublisherMode,
-    subject_prefix: String,
-}
-
-impl NatsEventPublisher {
-    pub fn new_core(client: Client, subject_prefix: String) -> Self {
-        Self {
-            mode: PublisherMode::Core(client),
-            subject_prefix,
-        }
-    }
-
-    pub fn new_jetstream(client: Client, subject_prefix: String) -> Self {
-        Self {
-            mode: PublisherMode::JetStream(jetstream::new(client)),
-            subject_prefix,
-        }
-    }
-}
-
-#[async_trait]
-impl EventPublisher for NatsEventPublisher {
-    async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> {
-        let subject = event_to_subject(&self.subject_prefix, event);
-        let payload = serde_json::to_vec(&NatsEventPayload::from(event))
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-
-        match &self.mode {
-            PublisherMode::Core(client) => client
-                .publish(subject, payload.into())
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-
-            PublisherMode::JetStream(js) => js
-                .publish(subject, payload.into())
-                .await
-                .map_err(|e| DomainError::InfrastructureError(e.to_string()))?
-                .await
-                .map(|_| ())
-                .map_err(|e| DomainError::InfrastructureError(e.to_string())),
-        }
-    }
-}
-
-fn _assert_send_sync() {
-    fn check<T: Send + Sync>() {}
-    check::<NatsEventPublisher>();
-}

crates/adapters/nats/src/subject.rs

@@ -1,45 +0,0 @@
-use domain::events::DomainEvent;
-
-pub fn event_to_subject(prefix: &str, event: &DomainEvent) -> String {
-    let suffix = match event {
-        DomainEvent::ReviewLogged { .. } => "review.logged",
-        DomainEvent::ReviewUpdated { .. } => "review.updated",
-        DomainEvent::ReviewDeleted { .. } => "review.deleted",
-        DomainEvent::MovieDiscovered { .. } => "movie.discovered",
-        DomainEvent::MovieDeleted { .. } => "movie.deleted",
-        DomainEvent::UserUpdated { .. } => "user.updated",
-        DomainEvent::MovieEnrichmentRequested { .. } => "movie.enrichment.requested",
-        DomainEvent::ImageStored { .. } => "image.stored",
-        DomainEvent::WatchlistEntryAdded { .. } => "watchlist.entry.added",
-        DomainEvent::WatchlistEntryRemoved { .. } => "watchlist.entry.removed",
-        DomainEvent::FollowRequested { .. } => "follow.requested",
-        DomainEvent::FollowAccepted { .. } => "follow.accepted",
-        DomainEvent::FollowRejected { .. } => "follow.rejected",
-        DomainEvent::Unfollowed { .. } => "follow.unfollowed",
-        DomainEvent::FollowerRemoved { .. } => "follower.removed",
-        DomainEvent::ActorBlocked { .. } => "actor.blocked",
-        DomainEvent::ActorUnblocked { .. } => "actor.unblocked",
-        DomainEvent::BackfillFollower { .. } => "backfill.follower",
-        DomainEvent::FederationDeliveryRequested { .. } => "federation.delivery.requested",
-        DomainEvent::WatchEventIngested { .. } => "watch.event.ingested",
-        DomainEvent::WrapUpRequested { .. } => "wrapup.requested",
-        DomainEvent::WrapUpCompleted { .. } => "wrapup.completed",
-        DomainEvent::SearchReindexRequested => "search.reindex.requested",
-        DomainEvent::PosterSynced { .. } => "poster.synced",
-        DomainEvent::GoalCreated { .. } => "goal.created",
-        DomainEvent::GoalUpdated { .. } => "goal.updated",
-        DomainEvent::GoalDeleted { .. } => "goal.deleted",
-        DomainEvent::PersonEnrichmentRequested { .. } => "person.enrichment.requested",
-        DomainEvent::UserDeleted { .. } => "user.deleted",
-        DomainEvent::UserAccountMoved { .. } => "user.account.moved",
-    };
-    format!("{prefix}.{suffix}")
-}
-
-pub fn consumer_subject_filter(prefix: &str) -> String {
-    format!("{prefix}.>")
-}
-
-#[cfg(test)]
-#[path = "tests/subject.rs"]
-mod tests;

crates/adapters/nats/src/tests/config.rs

@@ -1,30 +0,0 @@
-use super::*;
-
-#[test]
-fn errors_without_nats_url() {
-    assert!(NatsConfig::from_vars(None, None, None, None, None).is_err());
-}
-
-#[test]
-fn defaults_with_only_url() {
-    let cfg = NatsConfig::from_vars(Some("nats://localhost:4222"), None, None, None, None).unwrap();
-    assert_eq!(cfg.url, "nats://localhost:4222");
-    assert_eq!(cfg.mode, NatsMode::JetStream);
-    assert_eq!(cfg.subject_prefix, "movies-diary.events");
-    assert_eq!(cfg.stream_name, "MOVIES_DIARY_EVENTS");
-    assert_eq!(cfg.consumer_name, "worker");
-}
-
-#[test]
-fn core_mode_parsed() {
-    let cfg =
-        NatsConfig::from_vars(Some("nats://test:4222"), Some("core"), None, None, None).unwrap();
-    assert_eq!(cfg.mode, NatsMode::Core);
-}
-
-#[test]
-fn invalid_mode_errors() {
-    assert!(
-        NatsConfig::from_vars(Some("nats://test:4222"), Some("kafka"), None, None, None).is_err()
-    );
-}

crates/adapters/nats/src/tests/subject.rs

@@ -1,60 +0,0 @@
-use super::*;
-use chrono::NaiveDateTime;
-use domain::value_objects::{ExternalMetadataId, MovieId, Rating, ReviewId, UserId};
-use uuid::Uuid;
-
-fn dt() -> NaiveDateTime {
-    chrono::DateTime::from_timestamp(1_700_000_000, 0)
-        .unwrap()
-        .naive_utc()
-}
-
-#[test]
-fn review_logged_subject() {
-    let event = DomainEvent::ReviewLogged {
-        review_id: ReviewId::from_uuid(Uuid::new_v4()),
-        movie_id: MovieId::from_uuid(Uuid::new_v4()),
-        user_id: UserId::from_uuid(Uuid::new_v4()),
-        rating: Rating::new(3).unwrap(),
-        watched_at: dt(),
-    };
-    assert_eq!(
-        event_to_subject("movies-diary.events", &event),
-        "movies-diary.events.review.logged"
-    );
-}
-
-#[test]
-fn review_updated_subject() {
-    let event = DomainEvent::ReviewUpdated {
-        review_id: ReviewId::from_uuid(Uuid::new_v4()),
-        movie_id: MovieId::from_uuid(Uuid::new_v4()),
-        user_id: UserId::from_uuid(Uuid::new_v4()),
-        rating: Rating::new(5).unwrap(),
-        watched_at: dt(),
-    };
-    assert_eq!(
-        event_to_subject("movies-diary.events", &event),
-        "movies-diary.events.review.updated"
-    );
-}
-
-#[test]
-fn movie_discovered_subject() {
-    let event = DomainEvent::MovieDiscovered {
-        movie_id: MovieId::from_uuid(Uuid::new_v4()),
-        external_metadata_id: ExternalMetadataId::new("tt0000001".into()).unwrap(),
-    };
-    assert_eq!(
-        event_to_subject("movies-diary.events", &event),
-        "movies-diary.events.movie.discovered"
-    );
-}
-
-#[test]
-fn consumer_subject_filter_appends_wildcard() {
-    assert_eq!(
-        consumer_subject_filter("movies-diary.events"),
-        "movies-diary.events.>"
-    );
-}

crates/adapters/object-storage/src/config.rs

@@ -1,64 +0,0 @@
-use anyhow::Context;
-use object_store::{ObjectStore, aws::AmazonS3Builder, local::LocalFileSystem};
-use std::sync::Arc;
-
-pub struct StorageConfig(Arc<dyn ObjectStore>);
-
-impl StorageConfig {
-    pub fn from_env() -> anyhow::Result<Self> {
-        let backend = std::env::var("IMAGE_STORAGE_BACKEND").unwrap_or_else(|_| "local".into());
-
-        let store: Arc<dyn ObjectStore> = match backend.as_str() {
-            "s3" => build_s3_store(
-                &std::env::var("MINIO_ENDPOINT").context("MINIO_ENDPOINT required")?,
-                &std::env::var("MINIO_ACCESS_KEY_ID").context("MINIO_ACCESS_KEY_ID required")?,
-                &std::env::var("MINIO_SECRET_ACCESS_KEY")
-                    .context("MINIO_SECRET_ACCESS_KEY required")?,
-                &std::env::var("MINIO_BUCKET").context("MINIO_BUCKET required")?,
-                &std::env::var("MINIO_REGION").unwrap_or_else(|_| "minio".to_string()),
-            )?,
-            "local" => build_local_store(
-                &std::env::var("IMAGE_STORAGE_PATH").unwrap_or_else(|_| "./images".into()),
-            )?,
-            other => {
-                anyhow::bail!("Unknown IMAGE_STORAGE_BACKEND: {other:?}. Valid values: s3, local")
-            }
-        };
-
-        Ok(Self(store))
-    }
-
-    pub fn build_store(self) -> Arc<dyn ObjectStore> {
-        self.0
-    }
-}
-
-fn build_s3_store(
-    endpoint: &str,
-    access_key_id: &str,
-    secret_access_key: &str,
-    bucket: &str,
-    region: &str,
-) -> anyhow::Result<Arc<dyn ObjectStore>> {
-    let store = AmazonS3Builder::new()
-        .with_endpoint(endpoint)
-        .with_access_key_id(access_key_id)
-        .with_secret_access_key(secret_access_key)
-        .with_bucket_name(bucket)
-        .with_region(region)
-        .with_allow_http(true)
-        .build()
-        .context("Failed to build S3/Minio store")?;
-    Ok(Arc::new(store))
-}
-
-fn build_local_store(path: &str) -> anyhow::Result<Arc<dyn ObjectStore>> {
-    std::fs::create_dir_all(path).context("Failed to create image storage directory")?;
-    let store = LocalFileSystem::new_with_prefix(path)
-        .context("Failed to initialise local file system store")?;
-    Ok(Arc::new(store))
-}
-
-#[cfg(test)]
-#[path = "tests/config.rs"]
-mod tests;

crates/adapters/object-storage/src/lib.rs

@@ -1,139 +0,0 @@
-mod config;
-pub use config::StorageConfig;
-
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    events::DomainEvent,
-    ports::{EventHandler, ObjectStorage},
-};
-use futures::StreamExt;
-use object_store::{ObjectStore, path::Path};
-use std::sync::Arc;
-
-pub struct ObjectStorageAdapter {
-    store: Arc<dyn ObjectStore>,
-}
-
-impl ObjectStorageAdapter {
-    pub fn new(store: Arc<dyn ObjectStore>) -> Self {
-        Self { store }
-    }
-
-    pub fn from_config(config: StorageConfig) -> Self {
-        Self::new(config.build_store())
-    }
-
-    async fn get_exact(&self, key: &str) -> Result<Vec<u8>, DomainError> {
-        let path = Path::from(key);
-        let result = self.store.get(&path).await.map_err(|e| match e {
-            object_store::Error::NotFound { .. } => DomainError::NotFound("Image not found".into()),
-            _ => DomainError::InfrastructureError(e.to_string()),
-        })?;
-        result
-            .bytes()
-            .await
-            .map(|b| b.to_vec())
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-    }
-}
-
-#[async_trait]
-impl ObjectStorage for ObjectStorageAdapter {
-    async fn store(&self, key: &str, image_bytes: &[u8]) -> Result<String, DomainError> {
-        let path = Path::from(key);
-        self.store
-            .put(&path, image_bytes.to_vec().into())
-            .await
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        Ok(key.to_string())
-    }
-
-    async fn get(&self, key: &str) -> Result<Vec<u8>, DomainError> {
-        match self.get_exact(key).await {
-            Ok(bytes) => return Ok(bytes),
-            Err(DomainError::NotFound(_)) if !has_image_ext(key) => {}
-            Err(e) => return Err(e),
-        }
-        // Key may reference a pre-conversion path; try converted extensions.
-        for ext in [".webp", ".avif"] {
-            let candidate = format!("{key}{ext}");
-            if let Ok(bytes) = self.get_exact(&candidate).await {
-                return Ok(bytes);
-            }
-        }
-        Err(DomainError::NotFound("Image not found".into()))
-    }
-
-    async fn get_stream(
-        &self,
-        key: &str,
-    ) -> Result<futures::stream::BoxStream<'static, Result<bytes::Bytes, DomainError>>, DomainError>
-    {
-        let path = Path::from(key);
-        let result = self.store.get(&path).await.map_err(|e| match e {
-            object_store::Error::NotFound { .. } => DomainError::NotFound("not found".into()),
-            _ => DomainError::InfrastructureError(e.to_string()),
-        })?;
-        let stream = result.into_stream().map(|chunk| {
-            chunk
-                .map(|b| bytes::Bytes::from(b.to_vec()))
-                .map_err(|e| DomainError::InfrastructureError(e.to_string()))
-        });
-        Ok(Box::pin(stream))
-    }
-
-    async fn delete(&self, key: &str) -> Result<(), DomainError> {
-        let path = Path::from(key);
-        match self.store.delete(&path).await {
-            Ok(()) => Ok(()),
-            Err(object_store::Error::NotFound { .. }) => Ok(()),
-            Err(e) => Err(DomainError::InfrastructureError(e.to_string())),
-        }
-    }
-}
-
-fn has_image_ext(key: &str) -> bool {
-    key.ends_with(".webp")
-        || key.ends_with(".avif")
-        || key.ends_with(".png")
-        || key.ends_with(".jpg")
-        || key.ends_with(".jpeg")
-}
-
-pub struct ImageCleanupHandler {
-    object_storage: Arc<dyn ObjectStorage>,
-}
-
-impl ImageCleanupHandler {
-    pub fn new(object_storage: Arc<dyn ObjectStorage>) -> Self {
-        Self { object_storage }
-    }
-}
-
-#[async_trait]
-impl EventHandler for ImageCleanupHandler {
-    async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
-        let poster_path = match event {
-            DomainEvent::MovieDeleted { poster_path, .. } => poster_path,
-            _ => return Ok(()),
-        };
-        let Some(path) = poster_path else {
-            return Ok(());
-        };
-        if let Err(e) = self.object_storage.delete(path.value()).await {
-            tracing::warn!("image cleanup failed for {}: {e}", path.value());
-        }
-        Ok(())
-    }
-}
-
-pub fn create() -> anyhow::Result<Arc<dyn ObjectStorage>> {
-    Ok(Arc::new(ObjectStorageAdapter::from_config(
-        StorageConfig::from_env()?,
-    )))
-}
-
-#[cfg(test)]
-#[path = "tests/lib.rs"]
-mod tests;

crates/adapters/object-storage/src/tests/config.rs

@@ -1,17 +0,0 @@
-use super::*;
-
-#[test]
-fn local_store_creates_dir_and_succeeds() {
-    let dir = std::env::temp_dir().join(format!("image_test_{}", uuid::Uuid::new_v4()));
-    let result = build_local_store(dir.to_str().unwrap());
-    assert!(result.is_ok(), "expected Ok, got: {:?}", result.err());
-    assert!(dir.exists(), "directory should have been created");
-}
-
-#[test]
-fn local_store_succeeds_if_dir_already_exists() {
-    let dir = std::env::temp_dir().join(format!("image_test_{}", uuid::Uuid::new_v4()));
-    std::fs::create_dir_all(&dir).unwrap();
-    let result = build_local_store(dir.to_str().unwrap());
-    assert!(result.is_ok());
-}

crates/adapters/object-storage/src/tests/lib.rs

@@ -1,61 +0,0 @@
-use super::*;
-use object_store::memory::InMemory;
-
-fn adapter() -> ObjectStorageAdapter {
-    ObjectStorageAdapter::new(Arc::new(InMemory::new()))
-}
-
-#[tokio::test]
-async fn store_and_retrieve_round_trip() {
-    let adapter = adapter();
-    let bytes = b"fake-image-bytes";
-    let path = adapter.store("posters/abc123", bytes).await.unwrap();
-    assert_eq!(path, "posters/abc123");
-    let retrieved = adapter.get("posters/abc123").await.unwrap();
-    assert_eq!(retrieved, bytes);
-}
-
-#[tokio::test]
-async fn get_missing_returns_not_found() {
-    let adapter = adapter();
-    let result = adapter.get("nonexistent").await;
-    assert!(matches!(result, Err(DomainError::NotFound(_))));
-}
-
-#[tokio::test]
-async fn delete_removes_key() {
-    let adapter = adapter();
-    adapter.store("avatars/user1", b"img").await.unwrap();
-    adapter.delete("avatars/user1").await.unwrap();
-    let result = adapter.get("avatars/user1").await;
-    assert!(matches!(result, Err(DomainError::NotFound(_))));
-}
-
-#[tokio::test]
-async fn delete_missing_returns_ok() {
-    let adapter = adapter();
-    assert!(adapter.delete("does-not-exist").await.is_ok());
-}
-
-#[tokio::test]
-async fn cleanup_handler_deletes_on_movie_deleted() {
-    use domain::{
-        events::DomainEvent,
-        value_objects::{MovieId, PosterPath},
-    };
-    let inner = Arc::new(adapter());
-    inner.store("some-uuid", b"img").await.unwrap();
-    let path = PosterPath::new("some-uuid".to_string()).unwrap();
-    let handler = ImageCleanupHandler::new(Arc::clone(&inner) as Arc<dyn ObjectStorage>);
-    handler
-        .handle(&DomainEvent::MovieDeleted {
-            movie_id: MovieId::from_uuid(uuid::Uuid::new_v4()),
-            poster_path: Some(path.clone()),
-        })
-        .await
-        .unwrap();
-    assert!(matches!(
-        inner.get("some-uuid").await,
-        Err(DomainError::NotFound(_))
-    ));
-}

crates/adapters/plex/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "plex"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-domain = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }

crates/adapters/plex/src/lib.rs

@@ -1,172 +0,0 @@
-use domain::{errors::DomainError, models::ParsedPlaybackEvent, ports::MediaServerParser};
-use serde::Deserialize;
-
-pub struct PlexParser;
-
-impl MediaServerParser for PlexParser {
-    /// Plex sends multipart form data with a `payload` JSON field.
-    /// The caller must extract the JSON string from the multipart body
-    /// and pass it here as raw bytes.
-    fn parse_playback_event(
-        &self,
-        body: &[u8],
-    ) -> Result<Option<ParsedPlaybackEvent>, DomainError> {
-        let payload: PlexPayload = serde_json::from_slice(body)
-            .map_err(|e| DomainError::ValidationError(format!("invalid Plex payload: {e}")))?;
-
-        if payload.event != "media.scrobble" {
-            return Ok(None);
-        }
-
-        let metadata = match payload.metadata {
-            Some(m) => m,
-            None => return Ok(None),
-        };
-
-        if metadata.media_type != "movie" {
-            return Ok(None);
-        }
-
-        if metadata.title.is_empty() {
-            return Ok(None);
-        }
-
-        let mut tmdb_id = None;
-        let mut imdb_id = None;
-        for guid in &metadata.guids {
-            if let Some(id) = guid.id.strip_prefix("tmdb://") {
-                tmdb_id = Some(format!("tmdb:{id}"));
-            } else if let Some(id) = guid.id.strip_prefix("imdb://") {
-                imdb_id = Some(id.to_string());
-            }
-        }
-
-        Ok(Some(ParsedPlaybackEvent {
-            title: metadata.title,
-            year: metadata.year.map(|y| y as u16),
-            tmdb_id,
-            imdb_id,
-        }))
-    }
-}
-
-#[derive(Deserialize)]
-struct PlexPayload {
-    event: String,
-    #[serde(rename = "Metadata")]
-    metadata: Option<PlexMetadata>,
-}
-
-#[derive(Deserialize)]
-struct PlexMetadata {
-    #[serde(rename = "type")]
-    media_type: String,
-    title: String,
-    year: Option<i32>,
-    #[serde(rename = "Guid", default)]
-    guids: Vec<PlexGuid>,
-}
-
-#[derive(Deserialize)]
-struct PlexGuid {
-    id: String,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parses_movie_scrobble() {
-        let body = serde_json::json!({
-            "event": "media.scrobble",
-            "Metadata": {
-                "type": "movie",
-                "title": "Blade Runner",
-                "year": 1982,
-                "Guid": [
-                    {"id": "tmdb://78"},
-                    {"id": "imdb://tt0083658"}
-                ]
-            }
-        });
-        let parser = PlexParser;
-        let result = parser
-            .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
-            .unwrap();
-        let event = result.expect("should parse");
-        assert_eq!(event.title, "Blade Runner");
-        assert_eq!(event.year, Some(1982));
-        assert_eq!(event.tmdb_id, Some("tmdb:78".into()));
-        assert_eq!(event.imdb_id, Some("tt0083658".into()));
-    }
-
-    #[test]
-    fn ignores_tv_episode() {
-        let body = serde_json::json!({
-            "event": "media.scrobble",
-            "Metadata": {
-                "type": "episode",
-                "title": "Pilot",
-                "grandparentTitle": "Breaking Bad",
-                "year": 2008,
-                "Guid": []
-            }
-        });
-        let parser = PlexParser;
-        let result = parser
-            .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
-            .unwrap();
-        assert!(result.is_none());
-    }
-
-    #[test]
-    fn ignores_play_event() {
-        let body = serde_json::json!({
-            "event": "media.play",
-            "Metadata": {
-                "type": "movie",
-                "title": "Blade Runner",
-                "year": 1982,
-                "Guid": []
-            }
-        });
-        let parser = PlexParser;
-        let result = parser
-            .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
-            .unwrap();
-        assert!(result.is_none());
-    }
-
-    #[test]
-    fn handles_no_guids() {
-        let body = serde_json::json!({
-            "event": "media.scrobble",
-            "Metadata": {
-                "type": "movie",
-                "title": "Some Indie Film",
-                "year": 2023
-            }
-        });
-        let parser = PlexParser;
-        let result = parser
-            .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
-            .unwrap();
-        let event = result.expect("should parse");
-        assert_eq!(event.title, "Some Indie Film");
-        assert!(event.tmdb_id.is_none());
-        assert!(event.imdb_id.is_none());
-    }
-
-    #[test]
-    fn handles_missing_metadata() {
-        let body = serde_json::json!({
-            "event": "media.scrobble"
-        });
-        let parser = PlexParser;
-        let result = parser
-            .parse_playback_event(serde_json::to_vec(&body).unwrap().as_slice())
-            .unwrap();
-        assert!(result.is_none());
-    }
-}

crates/adapters/poster-fetcher/src/lib.rs

@@ -4,11 +4,7 @@ pub use config::PosterFetcherConfig;
 use std::time::Duration;
 
 use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    ports::{ImageFetcher, PosterFetcherClient},
-    value_objects::PosterUrl,
-};
+use domain::{errors::DomainError, ports::PosterFetcherClient, value_objects::PosterUrl};
 
 pub struct ReqwestPosterFetcher {
     client: reqwest::Client,
@@ -40,33 +36,3 @@ impl PosterFetcherClient for ReqwestPosterFetcher {
         Ok(bytes.to_vec())
     }
 }
-
-#[async_trait]
-impl ImageFetcher for ReqwestPosterFetcher {
-    async fn fetch_image(&self, url: &str) -> Result<Vec<u8>, DomainError> {
-        let bytes = self
-            .client
-            .get(url)
-            .send()
-            .await
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?
-            .error_for_status()
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?
-            .bytes()
-            .await
-            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
-        Ok(bytes.to_vec())
-    }
-}
-
-pub fn create() -> anyhow::Result<std::sync::Arc<dyn domain::ports::PosterFetcherClient>> {
-    Ok(std::sync::Arc::new(ReqwestPosterFetcher::new(
-        PosterFetcherConfig::from_env(),
-    )?))
-}
-
-pub fn create_image_fetcher() -> anyhow::Result<std::sync::Arc<dyn domain::ports::ImageFetcher>> {
-    Ok(std::sync::Arc::new(ReqwestPosterFetcher::new(
-        PosterFetcherConfig::from_env(),
-    )?))
-}

crates/adapters/poster-storage/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "object-storage"
+name = "poster-storage"
 version = "0.1.0"
 edition = "2024"
 
@@ -8,10 +8,7 @@ domain = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 tracing = { workspace = true }
-bytes = { workspace = true }
-futures = { workspace = true }
 object_store = { workspace = true }
-infer = "0.19.0"
 
 [dev-dependencies]
 tokio = { workspace = true }

crates/adapters/poster-storage/src/config.rs

@@ -0,0 +1,38 @@
+use anyhow::Context;
+use object_store::{aws::AmazonS3Builder, ObjectStore};
+use std::sync::Arc;
+
+pub struct StorageConfig {
+    endpoint: String,
+    access_key_id: String,
+    secret_access_key: String,
+    bucket: String,
+    region: String,
+}
+
+impl StorageConfig {
+    pub fn from_env() -> anyhow::Result<Self> {
+        Ok(Self {
+            endpoint: std::env::var("MINIO_ENDPOINT").context("MINIO_ENDPOINT required")?,
+            access_key_id: std::env::var("MINIO_ACCESS_KEY_ID")
+                .context("MINIO_ACCESS_KEY_ID required")?,
+            secret_access_key: std::env::var("MINIO_SECRET_ACCESS_KEY")
+                .context("MINIO_SECRET_ACCESS_KEY required")?,
+            bucket: std::env::var("MINIO_BUCKET").context("MINIO_BUCKET required")?,
+            region: std::env::var("MINIO_REGION").unwrap_or_else(|_| "minio".to_string()),
+        })
+    }
+
+    pub fn build_store(self) -> anyhow::Result<Arc<dyn ObjectStore>> {
+        let store = AmazonS3Builder::new()
+            .with_endpoint(self.endpoint)
+            .with_access_key_id(self.access_key_id)
+            .with_secret_access_key(self.secret_access_key)
+            .with_bucket_name(self.bucket)
+            .with_region(self.region)
+            .with_allow_http(true)
+            .build()
+            .context("Failed to build S3/Minio store")?;
+        Ok(Arc::new(store))
+    }
+}

crates/adapters/poster-storage/src/lib.rs

@@ -0,0 +1,85 @@
+mod config;
+pub use config::StorageConfig;
+
+use async_trait::async_trait;
+use domain::{
+    errors::DomainError,
+    ports::PosterStorage,
+    value_objects::{MovieId, PosterPath},
+};
+use object_store::{path::Path, ObjectStore};
+use std::sync::Arc;
+
+pub struct PosterStorageAdapter {
+    store: Arc<dyn ObjectStore>,
+}
+
+impl PosterStorageAdapter {
+    pub fn new(store: Arc<dyn ObjectStore>) -> Self {
+        Self { store }
+    }
+
+    pub fn from_config(config: StorageConfig) -> anyhow::Result<Self> {
+        Ok(Self::new(config.build_store()?))
+    }
+}
+
+#[async_trait]
+impl PosterStorage for PosterStorageAdapter {
+    async fn store_poster(
+        &self,
+        movie_id: &MovieId,
+        image_bytes: &[u8],
+    ) -> Result<PosterPath, DomainError> {
+        let path = Path::from(movie_id.value().to_string());
+        self.store
+            .put(&path, image_bytes.to_vec().into())
+            .await
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))?;
+        PosterPath::new(path.to_string())
+    }
+
+    async fn get_poster(&self, poster_path: &PosterPath) -> Result<Vec<u8>, DomainError> {
+        let path = Path::from(poster_path.value().to_string());
+        let result = self.store.get(&path).await.map_err(|e| match e {
+            object_store::Error::NotFound { .. } => DomainError::NotFound("Poster not found".into()),
+            _ => DomainError::InfrastructureError(e.to_string()),
+        })?;
+        result
+            .bytes()
+            .await
+            .map(|b| b.to_vec())
+            .map_err(|e| DomainError::InfrastructureError(e.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use object_store::memory::InMemory;
+    use uuid::Uuid;
+
+    fn adapter() -> PosterStorageAdapter {
+        PosterStorageAdapter::new(Arc::new(InMemory::new()))
+    }
+
+    #[tokio::test]
+    async fn store_and_retrieve_round_trip() {
+        let adapter = adapter();
+        let movie_id = MovieId::from_uuid(Uuid::new_v4());
+        let bytes = b"fake-image-bytes";
+
+        let path = adapter.store_poster(&movie_id, bytes).await.unwrap();
+        let retrieved = adapter.get_poster(&path).await.unwrap();
+
+        assert_eq!(retrieved, bytes);
+    }
+
+    #[tokio::test]
+    async fn get_missing_returns_not_found() {
+        let adapter = adapter();
+        let path = PosterPath::new("nonexistent".into()).unwrap();
+        let result = adapter.get_poster(&path).await;
+        assert!(matches!(result, Err(DomainError::NotFound(_))));
+    }
+}

crates/adapters/poster-sync/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "poster-sync"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-domain = { workspace = true }
-async-trait = { workspace = true }
-tracing = { workspace = true }
-tokio = { workspace = true }

crates/adapters/poster-sync/src/lib.rs

@@ -1,167 +0,0 @@
-use std::{sync::Arc, time::Duration};
-
-use async_trait::async_trait;
-use domain::{
-    errors::DomainError,
-    events::DomainEvent,
-    ports::{
-        EventHandler, EventPublisher, MetadataClient, MovieCommand, MovieQuery, ObjectStorage,
-        PosterFetcherClient,
-    },
-    value_objects::{ExternalMetadataId, MovieId, PosterPath},
-};
-
-pub struct PosterSyncHandler {
-    movie_command: Arc<dyn MovieCommand>,
-    movie_query: Arc<dyn MovieQuery>,
-    metadata_client: Arc<dyn MetadataClient>,
-    poster_fetcher: Arc<dyn PosterFetcherClient>,
-    object_storage: Arc<dyn ObjectStorage>,
-    event_publisher: Arc<dyn EventPublisher>,
-    max_retries: u32,
-}
-
-impl PosterSyncHandler {
-    pub fn new(
-        movie_command: Arc<dyn MovieCommand>,
-        movie_query: Arc<dyn MovieQuery>,
-        metadata_client: Arc<dyn MetadataClient>,
-        poster_fetcher: Arc<dyn PosterFetcherClient>,
-        object_storage: Arc<dyn ObjectStorage>,
-        event_publisher: Arc<dyn EventPublisher>,
-        max_retries: u32,
-    ) -> Self {
-        Self {
-            movie_command,
-            movie_query,
-            metadata_client,
-            poster_fetcher,
-            object_storage,
-            event_publisher,
-            max_retries,
-        }
-    }
-
-    async fn sync(
-        &self,
-        movie_id: MovieId,
-        external_metadata_id: ExternalMetadataId,
-    ) -> Result<(), DomainError> {
-        let mut movie = match self.movie_query.get_movie_by_id(&movie_id).await? {
-            Some(m) => m,
-            None => {
-                tracing::warn!("Sync cancelled: Movie {} not found", movie_id.value());
-                return Err(DomainError::NotFound("Movie not found".into()));
-            }
-        };
-
-        let poster_url = match self
-            .metadata_client
-            .get_poster_url(&external_metadata_id)
-            .await
-        {
-            Ok(Some(url)) => url,
-            Ok(None) => return Ok(()),
-            Err(e) => {
-                tracing::warn!("Failed to find poster URL: {:?}", e);
-                return Err(e);
-            }
-        };
-
-        let image_bytes = self.poster_fetcher.fetch_poster_bytes(&poster_url).await?;
-        let stored_path = self
-            .object_storage
-            .store(&movie_id.value().to_string(), &image_bytes)
-            .await?;
-        if let Err(e) = self
-            .event_publisher
-            .publish(&DomainEvent::ImageStored {
-                key: stored_path.clone(),
-            })
-            .await
-        {
-            tracing::warn!("failed to emit ImageStored for {stored_path}: {e}");
-        }
-        let poster_path = PosterPath::new(stored_path)?;
-
-        movie.update_poster(poster_path);
-        self.movie_command.upsert_movie(&movie).await?;
-
-        if let Err(e) = self
-            .event_publisher
-            .publish(&DomainEvent::PosterSynced {
-                movie_id: movie.id().clone(),
-            })
-            .await
-        {
-            tracing::warn!(
-                "failed to emit PosterSynced for {}: {e}",
-                movie.id().value()
-            );
-        }
-
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl EventHandler for PosterSyncHandler {
-    async fn handle(&self, event: &DomainEvent) -> Result<(), DomainError> {
-        let (movie_id, external_metadata_id) = match event {
-            DomainEvent::MovieDiscovered {
-                movie_id,
-                external_metadata_id,
-            } => (movie_id.value(), external_metadata_id.value().to_owned()),
-            DomainEvent::MovieEnrichmentRequested {
-                movie_id,
-                external_metadata_id,
-            } => {
-                // Only sync poster if the movie doesn't have one yet
-                let already_has_poster = self
-                    .movie_query
-                    .get_movie_by_id(&MovieId::from_uuid(movie_id.value()))
-                    .await?
-                    .map(|m| m.poster_path().is_some())
-                    .unwrap_or(false);
-                if already_has_poster {
-                    return Ok(());
-                }
-                (movie_id.value(), external_metadata_id.value().to_owned())
-            }
-            _ => return Ok(()),
-        };
-
-        let movie_id = MovieId::from_uuid(movie_id);
-        let external_metadata_id = ExternalMetadataId::new(external_metadata_id)?;
-
-        let mut last_err: Option<DomainError> = None;
-        for attempt in 0..=self.max_retries {
-            match self
-                .sync(movie_id.clone(), external_metadata_id.clone())
-                .await
-            {
-                Ok(()) => return Ok(()),
-                Err(e) => {
-                    if attempt < self.max_retries {
-                        let delay = Duration::from_secs(2u64.pow(attempt));
-                        tracing::warn!(
-                            attempt = attempt + 1,
-                            max_attempts = self.max_retries + 1,
-                            delay_secs = delay.as_secs(),
-                            "poster sync failed, retrying: {e}"
-                        );
-                        tokio::time::sleep(delay).await;
-                    }
-                    last_err = Some(e);
-                }
-            }
-        }
-
-        let err = last_err.expect("loop runs at least once");
-        tracing::error!(
-            attempts = self.max_retries + 1,
-            "poster sync failed after all attempts: {err}"
-        );
-        Err(err)
-    }
-}