feat(search): rank results by match quality and split TV/People groups
Neither search backend orders by *where* the query matched, so a mid-word hit could outrank a prefix one — typing "parks" surfaced "Sparks of Love" above "Parks and Recreation". Add `domain/search_rank.rs`, which sorts by match position (prefix → word-start → mid-word substring → no name match), then by media kind so a container outranks its own contents. The sort is stable, so each backend's own relevance still breaks ties it was never overruled on. `repository_search` applies it to both the instant cache result and the merged cache+server union, so the list does not reshuffle when server results land. Ranking lives in Rust because "a better match" is domain vocabulary, not presentation. On the frontend, the combined `tvShows` result group splits into separate Shows and Episodes groups so a show no longer competes with its own episodes for a slot, and a People group is added so searching an actor's name reaches their bio. A stored `tvShows` order expands in place, keeping the position an upgrading user chose for it.
This commit is contained in:
@@ -92,9 +92,11 @@ describe("normalizeGroupOrder", () => {
|
||||
expect(normalizeGroupOrder(["movies", "podcasts", "songs"])).toEqual([
|
||||
"movies",
|
||||
"songs",
|
||||
"shows",
|
||||
"episodes",
|
||||
"albums",
|
||||
"artists",
|
||||
"tvShows",
|
||||
"people",
|
||||
]);
|
||||
});
|
||||
|
||||
@@ -103,9 +105,11 @@ describe("normalizeGroupOrder", () => {
|
||||
expect(normalizeGroupOrder(["movies", "songs"])).toEqual([
|
||||
"movies",
|
||||
"songs",
|
||||
"shows",
|
||||
"episodes",
|
||||
"albums",
|
||||
"artists",
|
||||
"tvShows",
|
||||
"people",
|
||||
]);
|
||||
});
|
||||
|
||||
@@ -113,34 +117,78 @@ describe("normalizeGroupOrder", () => {
|
||||
expect(normalizeGroupOrder(["songs", "songs", "movies"])).toEqual([
|
||||
"songs",
|
||||
"movies",
|
||||
"shows",
|
||||
"episodes",
|
||||
"albums",
|
||||
"artists",
|
||||
"tvShows",
|
||||
"people",
|
||||
]);
|
||||
});
|
||||
|
||||
it("preserves a complete valid order unchanged", () => {
|
||||
const order: SearchGroupId[] = ["tvShows", "movies", "artists", "albums", "songs"];
|
||||
const order: SearchGroupId[] = [
|
||||
"episodes",
|
||||
"shows",
|
||||
"movies",
|
||||
"artists",
|
||||
"albums",
|
||||
"songs",
|
||||
"people",
|
||||
];
|
||||
expect(normalizeGroupOrder(order)).toEqual(order);
|
||||
});
|
||||
|
||||
it("expands a stored `tvShows` into shows + episodes in place", () => {
|
||||
// Migration: the old combined group split, and a user who put TV first
|
||||
// must still get TV first rather than appended at the bottom.
|
||||
expect(normalizeGroupOrder(["tvShows", "movies"])).toEqual([
|
||||
"shows",
|
||||
"episodes",
|
||||
"movies",
|
||||
"songs",
|
||||
"albums",
|
||||
"artists",
|
||||
"people",
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("groupsForScope", () => {
|
||||
it("returns every group in saved order for the all scope", () => {
|
||||
expect(groupsForScope("all", ["movies", "songs", "tvShows", "albums", "artists"])).toEqual([
|
||||
"movies",
|
||||
"songs",
|
||||
"tvShows",
|
||||
"albums",
|
||||
"artists",
|
||||
]);
|
||||
expect(
|
||||
groupsForScope("all", [
|
||||
"movies",
|
||||
"songs",
|
||||
"shows",
|
||||
"episodes",
|
||||
"albums",
|
||||
"artists",
|
||||
"people",
|
||||
])
|
||||
).toEqual(["movies", "songs", "shows", "episodes", "albums", "artists", "people"]);
|
||||
});
|
||||
|
||||
it("keeps only in-scope groups, in saved order", () => {
|
||||
const order: SearchGroupId[] = ["artists", "movies", "albums", "tvShows", "songs"];
|
||||
const order: SearchGroupId[] = [
|
||||
"artists",
|
||||
"movies",
|
||||
"albums",
|
||||
"episodes",
|
||||
"shows",
|
||||
"songs",
|
||||
"people",
|
||||
];
|
||||
expect(groupsForScope("music", order)).toEqual(["artists", "albums", "songs"]);
|
||||
expect(groupsForScope("movies", order)).toEqual(["movies"]);
|
||||
expect(groupsForScope("tv", order)).toEqual(["tvShows"]);
|
||||
expect(groupsForScope("tv", order)).toEqual(["episodes", "shows"]);
|
||||
});
|
||||
|
||||
it("surfaces people only under the all scope", () => {
|
||||
// Cast/crew cut across music, film and TV, so no narrow scope claims them.
|
||||
expect(groupsForScope("all", DEFAULT_GROUP_ORDER)).toContain("people");
|
||||
expect(groupsForScope("music", DEFAULT_GROUP_ORDER)).not.toContain("people");
|
||||
expect(groupsForScope("tv", DEFAULT_GROUP_ORDER)).not.toContain("people");
|
||||
expect(groupsForScope("movies", DEFAULT_GROUP_ORDER)).not.toContain("people");
|
||||
});
|
||||
});
|
||||
|
||||
@@ -156,13 +204,29 @@ describe("composeSearchGroups", () => {
|
||||
|
||||
it("renders groups in the configured order", () => {
|
||||
const groups = composeSearchGroups(results, "all", [
|
||||
"tvShows",
|
||||
"shows",
|
||||
"episodes",
|
||||
"movies",
|
||||
"songs",
|
||||
"albums",
|
||||
"artists",
|
||||
"people",
|
||||
]);
|
||||
expect(groups.map((g) => g.id)).toEqual(["tvShows", "movies", "songs", "albums"]);
|
||||
expect(groups.map((g) => g.id)).toEqual([
|
||||
"shows",
|
||||
"episodes",
|
||||
"movies",
|
||||
"songs",
|
||||
"albums",
|
||||
"people",
|
||||
]);
|
||||
});
|
||||
|
||||
it("puts shows ahead of episodes by default", () => {
|
||||
// Searching a show's name should surface the show itself first, not an
|
||||
// arbitrary episode of it.
|
||||
const ids = composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER).map((g) => g.id);
|
||||
expect(ids).toEqual(["shows", "episodes"]);
|
||||
});
|
||||
|
||||
it("omits empty groups", () => {
|
||||
@@ -177,27 +241,44 @@ describe("composeSearchGroups", () => {
|
||||
"albums",
|
||||
]);
|
||||
expect(composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER).map((g) => g.id)).toEqual([
|
||||
"tvShows",
|
||||
"shows",
|
||||
"episodes",
|
||||
]);
|
||||
});
|
||||
|
||||
it("groups series and episodes together under tvShows", () => {
|
||||
it("separates series and episodes into their own groups", () => {
|
||||
const groups = composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER);
|
||||
expect(groups[0].items.map((i) => i.id)).toEqual(["4", "5"]);
|
||||
expect(groups.find((g) => g.id === "shows")?.items.map((i) => i.id)).toEqual(["4"]);
|
||||
expect(groups.find((g) => g.id === "episodes")?.items.map((i) => i.id)).toEqual(["5"]);
|
||||
});
|
||||
|
||||
it("surfaces people so an actor search reaches their bio", () => {
|
||||
// Person items were previously returned by the backend and silently dropped.
|
||||
const all = composeSearchGroups(results, "all", DEFAULT_GROUP_ORDER);
|
||||
expect(all.find((g) => g.id === "people")?.items.map((i) => i.id)).toEqual(["6"]);
|
||||
});
|
||||
|
||||
it("ignores item types that belong to no group", () => {
|
||||
const all = composeSearchGroups(results, "all", DEFAULT_GROUP_ORDER);
|
||||
expect(all.flatMap((g) => g.items).map((i) => i.id)).not.toContain("6");
|
||||
const withFolder = [...results, { id: "7", type: "CollectionFolder" }];
|
||||
const all = composeSearchGroups(withFolder, "all", DEFAULT_GROUP_ORDER);
|
||||
expect(all.flatMap((g) => g.items).map((i) => i.id)).not.toContain("7");
|
||||
});
|
||||
|
||||
it("narrowing then widening restores the full arrangement", () => {
|
||||
// Scope is a filter over the saved order, never a rewrite of it.
|
||||
const order: SearchGroupId[] = ["tvShows", "songs", "movies", "albums", "artists"];
|
||||
const order: SearchGroupId[] = [
|
||||
"shows",
|
||||
"songs",
|
||||
"movies",
|
||||
"albums",
|
||||
"artists",
|
||||
"episodes",
|
||||
"people",
|
||||
];
|
||||
const wide = composeSearchGroups(results, "all", order).map((g) => g.id);
|
||||
composeSearchGroups(results, "music", order);
|
||||
expect(composeSearchGroups(results, "all", order).map((g) => g.id)).toEqual(wide);
|
||||
expect(wide).toEqual(["tvShows", "songs", "movies", "albums"]);
|
||||
expect(wide).toEqual(["shows", "songs", "movies", "albums", "episodes", "people"]);
|
||||
});
|
||||
|
||||
it("survives a stored order containing an unknown id", () => {
|
||||
@@ -205,7 +286,14 @@ describe("composeSearchGroups", () => {
|
||||
"podcasts",
|
||||
"movies",
|
||||
] as unknown as SearchGroupId[]);
|
||||
expect(groups.map((g) => g.id)).toEqual(["movies", "songs", "albums", "tvShows"]);
|
||||
expect(groups.map((g) => g.id)).toEqual([
|
||||
"movies",
|
||||
"shows",
|
||||
"episodes",
|
||||
"songs",
|
||||
"albums",
|
||||
"people",
|
||||
]);
|
||||
});
|
||||
|
||||
it("handles items with a missing type", () => {
|
||||
@@ -219,7 +307,7 @@ describe("composeSearchGroups", () => {
|
||||
});
|
||||
|
||||
describe("moveGroup", () => {
|
||||
const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "tvShows"];
|
||||
const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "shows"];
|
||||
|
||||
it("moves a group up", () => {
|
||||
expect(moveGroup(order, "artists", -1)).toEqual([
|
||||
@@ -227,7 +315,7 @@ describe("moveGroup", () => {
|
||||
"artists",
|
||||
"albums",
|
||||
"movies",
|
||||
"tvShows",
|
||||
"shows",
|
||||
]);
|
||||
});
|
||||
|
||||
@@ -237,13 +325,13 @@ describe("moveGroup", () => {
|
||||
"songs",
|
||||
"artists",
|
||||
"movies",
|
||||
"tvShows",
|
||||
"shows",
|
||||
]);
|
||||
});
|
||||
|
||||
it("is a no-op at the boundaries", () => {
|
||||
expect(moveGroup(order, "songs", -1)).toEqual(order);
|
||||
expect(moveGroup(order, "tvShows", 1)).toEqual(order);
|
||||
expect(moveGroup(order, "shows", 1)).toEqual(order);
|
||||
});
|
||||
|
||||
it("is a no-op for an unknown id", () => {
|
||||
@@ -258,18 +346,18 @@ describe("moveGroup", () => {
|
||||
});
|
||||
|
||||
describe("reorderGroups", () => {
|
||||
const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "tvShows"];
|
||||
const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "shows"];
|
||||
|
||||
it("moves an item from one index to another", () => {
|
||||
expect(reorderGroups(order, 0, 4)).toEqual([
|
||||
"albums",
|
||||
"artists",
|
||||
"movies",
|
||||
"tvShows",
|
||||
"shows",
|
||||
"songs",
|
||||
]);
|
||||
expect(reorderGroups(order, 4, 0)).toEqual([
|
||||
"tvShows",
|
||||
"shows",
|
||||
"songs",
|
||||
"albums",
|
||||
"artists",
|
||||
@@ -282,4 +370,4 @@ describe("reorderGroups", () => {
|
||||
expect(reorderGroups(order, -1, 2)).toEqual(order);
|
||||
expect(reorderGroups(order, 0, 9)).toEqual(order);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -66,47 +66,96 @@ export function resolveSearchScope(pathname: string): SearchScope {
|
||||
// Result groups
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export type SearchGroupId = "songs" | "albums" | "artists" | "movies" | "tvShows";
|
||||
export type SearchGroupId =
|
||||
| "shows"
|
||||
| "episodes"
|
||||
| "movies"
|
||||
| "songs"
|
||||
| "albums"
|
||||
| "artists"
|
||||
| "people";
|
||||
|
||||
/** Shipped default order, per the spec. */
|
||||
/**
|
||||
* Shipped default order.
|
||||
*
|
||||
* TRACES: UR-060 | DR-091
|
||||
*
|
||||
* Containers lead the kinds they contain — a show above its episodes, an album
|
||||
* above nothing (songs are ranked separately) — which matches how people search:
|
||||
* you look for the show, not an arbitrary episode of it. `people` sits last as
|
||||
* a peripheral match; it exists so searching an actor's name reaches their bio
|
||||
* page rather than silently dropping the result.
|
||||
*/
|
||||
export const DEFAULT_GROUP_ORDER: readonly SearchGroupId[] = [
|
||||
"shows",
|
||||
"episodes",
|
||||
"movies",
|
||||
"songs",
|
||||
"albums",
|
||||
"artists",
|
||||
"movies",
|
||||
"tvShows",
|
||||
"people",
|
||||
];
|
||||
|
||||
export const GROUP_LABELS: Record<SearchGroupId, string> = {
|
||||
shows: "TV Shows",
|
||||
episodes: "Episodes",
|
||||
movies: "Movies",
|
||||
songs: "Songs",
|
||||
albums: "Albums",
|
||||
artists: "Artists",
|
||||
movies: "Movies",
|
||||
tvShows: "TV Shows",
|
||||
people: "People",
|
||||
};
|
||||
|
||||
/** Which scopes each group belongs to (`all` always includes everything). */
|
||||
const GROUP_SCOPE: Record<SearchGroupId, Exclude<SearchScope, "all">> = {
|
||||
/**
|
||||
* Which scopes each group belongs to (`all` always includes everything).
|
||||
*
|
||||
* `people` maps to no narrow scope: cast/crew cut across music, film and TV, so
|
||||
* it surfaces only under All rather than being forced into one of them.
|
||||
*/
|
||||
const GROUP_SCOPE: Record<SearchGroupId, Exclude<SearchScope, "all"> | null> = {
|
||||
shows: "tv",
|
||||
episodes: "tv",
|
||||
movies: "movies",
|
||||
songs: "music",
|
||||
albums: "music",
|
||||
artists: "music",
|
||||
movies: "movies",
|
||||
tvShows: "tv",
|
||||
people: null,
|
||||
};
|
||||
|
||||
/** Item types that fall into each group. */
|
||||
const GROUP_ITEM_TYPES: Record<SearchGroupId, string[]> = {
|
||||
shows: ["Series"],
|
||||
episodes: ["Episode"],
|
||||
movies: ["Movie"],
|
||||
songs: ["Audio"],
|
||||
albums: ["MusicAlbum"],
|
||||
artists: ["MusicArtist"],
|
||||
movies: ["Movie"],
|
||||
tvShows: ["Series", "Episode"],
|
||||
people: ["Person"],
|
||||
};
|
||||
|
||||
export function groupItemTypes(group: SearchGroupId): string[] {
|
||||
return [...GROUP_ITEM_TYPES[group]];
|
||||
}
|
||||
|
||||
/**
|
||||
* Stored group ids that no longer exist, mapped to the ids that replaced them.
|
||||
*
|
||||
* `tvShows` was one group holding both Series and Episode; it split so a show
|
||||
* can outrank its own episodes. Expanding in place preserves the position the
|
||||
* user chose for it.
|
||||
*
|
||||
* TRACES: UR-060 | DR-091
|
||||
*/
|
||||
const RETIRED_GROUP_IDS: Record<string, SearchGroupId[]> = {
|
||||
tvShows: ["shows", "episodes"],
|
||||
};
|
||||
|
||||
/** Resolve a stored id to the live id(s) it corresponds to, or none if unknown. */
|
||||
function migrateGroupId(id: string, known: Set<string>): SearchGroupId[] {
|
||||
if (known.has(id)) return [id as SearchGroupId];
|
||||
return RETIRED_GROUP_IDS[id] ?? [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalise a stored order into a usable one.
|
||||
*
|
||||
@@ -123,11 +172,15 @@ export function normalizeGroupOrder(stored: unknown): SearchGroupId[] {
|
||||
|
||||
if (Array.isArray(stored)) {
|
||||
for (const id of stored) {
|
||||
if (typeof id !== "string" || !known.has(id)) continue;
|
||||
const groupId = id as SearchGroupId;
|
||||
if (seen.has(groupId)) continue;
|
||||
seen.add(groupId);
|
||||
order.push(groupId);
|
||||
if (typeof id !== "string") continue;
|
||||
// Retired ids expand in place rather than being dropped, so a user who
|
||||
// dragged the old combined "TV Shows" group to the top keeps TV at the
|
||||
// top instead of having shows/episodes appended to the bottom.
|
||||
for (const groupId of migrateGroupId(id, known)) {
|
||||
if (seen.has(groupId)) continue;
|
||||
seen.add(groupId);
|
||||
order.push(groupId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -143,6 +196,8 @@ export function groupsForScope(
|
||||
scope: SearchScope,
|
||||
order: readonly SearchGroupId[] = DEFAULT_GROUP_ORDER
|
||||
): SearchGroupId[] {
|
||||
// A `null` GROUP_SCOPE (people) belongs to no narrow scope, so it survives
|
||||
// only under `all` — the `=== scope` test already excludes it elsewhere.
|
||||
return normalizeGroupOrder(order as SearchGroupId[]).filter(
|
||||
(id) => scope === "all" || GROUP_SCOPE[id] === scope
|
||||
);
|
||||
|
||||
Reference in New Issue
Block a user