35442e4aff
Four extractions, each chosen because the two halves have different callers,
different failure modes or different testing needs. Not a line-count exercise.
internal/home out of internal/media
- media serves item RESOURCES (detail, file, cover, progress); home computes
AGGREGATES (the five shelves). The 2328-line package was doing both.
- media keeps POST /items/{id}/view because it is item-scoped and must stay in
the package that authorizes the item; it imports home.RecordView for that one
thing. home does not import media.
- Verified live: all five shelves non-empty, and two consecutive /home calls
return different explore ids, which is the non-determinism the Explore rewrite
exists for.
internal/scanner out of internal/library
- The scanner walks the filesystem and reconciles; library CRUD is an admin HTTP
surface. Different callers (a job vs a request), different failure modes.
- The registry deliberately STAYED in internal/library: three of its four callers
are not the scanner (modules register types, handlers serve the list, metadata
reads the group mode, subsonic calls CleanTitle). It is a property of the kind,
not of the scan. The one genuinely scanner-owned helper became
library.ExtensionsFor.
- Two tests moved with the code rather than being rewritten; they now exercise
the boundary by calling library.ListMissing across it.
- Verified live: first scan updates, rescan reports unchanged=N, so change
detection still short-circuits.
internal/providers out of internal/metadata
- Providers talk to third-party APIs; the enrich job owns the matching policy and
the database writes. The split's whole point is that a provider is testable
WITHOUT a database, so a DB-free test was added and OpenLibrary gained a
BaseURL override to make it possible.
- providers imports zero internal packages — a true leaf.
- The matching policy (searchTitle, artistHint, pickBest) is untouched. It exists
because real false matches were found.
dto packages out of internal/jellyfin and internal/subsonic
- The wire types and their mapping are now separate from the handler logic, so
the contract with clients we do not control is reviewable on its own.
- Both dto packages are PURE: zero references to sql.DB or net/http, verified by
grep. That is what makes them reviewable.
- No field name, tag or error code changed.
internal/arch did its job: it failed the build twice during this phase, once for
each new package that was not yet placed in a layer. That is the rule working,
not an obstacle.
Verified: gofmt clean, build exit 0, vet exit 0, 23 packages pass, svelte-check
0/0, and end to end against a running server — home shelves, a queued scan
reporting unchanged, Jellyfin /Items, and Subsonic ping.
Process note: one agent (dto) stopped mid-task and left the tree red — the dto
packages unlayered and its test still referencing constants that had moved. The
arch test caught it immediately. I finished it by hand: exported constant
references in the test, and both dto packages placed at layer 3.
Still open from Phase 1: internal/jellyfin has no test files, catalog is
item-centric while Subsonic is file-first, and subsonic loadAlbum now scopes to
the item's own library.
78 lines
2.2 KiB
Go
78 lines
2.2 KiB
Go
// Package providers talks to external metadata catalogues.
|
|
//
|
|
// One client per service, no database, no policy: a provider turns a Query into
|
|
// candidates and knows nothing about what the caller does with them. Matching
|
|
// policy and persistence belong to the caller (internal/metadata), which is
|
|
// what keeps these clients testable against an httptest server alone.
|
|
//
|
|
// Providers are optional by design: a library with no network still browses,
|
|
// because a failed lookup is recorded and skipped, never surfaced as a scan or
|
|
// request failure.
|
|
package providers
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"sync"
|
|
)
|
|
|
|
// Query is what a provider is asked to match.
|
|
type Query struct {
|
|
Title string
|
|
Author string
|
|
ISBN string
|
|
Kind string
|
|
}
|
|
|
|
// Candidate is one possible match returned by a provider.
|
|
type Candidate struct {
|
|
Provider string `json:"provider"`
|
|
ExternalID string `json:"external_id"`
|
|
Title string `json:"title"`
|
|
Authors []string `json:"authors"`
|
|
Year int `json:"year"`
|
|
Publisher string `json:"publisher"`
|
|
Language string `json:"language"`
|
|
Description string `json:"description"`
|
|
ISBN string `json:"isbn"`
|
|
CoverURL string `json:"cover_url"`
|
|
}
|
|
|
|
// Provider is one external catalogue.
|
|
type Provider interface {
|
|
// Name is the stable identifier stored in provider_ids.provider.
|
|
Name() string
|
|
// Kinds lists the media kinds this provider can match.
|
|
Kinds() []string
|
|
// Search returns candidates, best first. An empty result is not an error.
|
|
Search(ctx context.Context, q Query) ([]Candidate, error)
|
|
}
|
|
|
|
var (
|
|
mu sync.RWMutex
|
|
providers []Provider
|
|
)
|
|
|
|
// Register adds a provider. Later registrations are consulted later, so
|
|
// registering a primary provider before a fallback gives the intended order.
|
|
func Register(p Provider) {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
providers = append(providers, p)
|
|
}
|
|
|
|
// For returns the providers that handle a media kind, in registration order.
|
|
func For(kind string) []Provider {
|
|
mu.RLock()
|
|
defer mu.RUnlock()
|
|
var out []Provider
|
|
for _, p := range providers {
|
|
for _, k := range p.Kinds() {
|
|
if strings.EqualFold(k, kind) {
|
|
out = append(out, p)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|