feat(link-wizard): search-assisted candidate selection

src/api/artistSearch/mergeCandidateSelection.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it } from "vitest";
+import { mergeCandidateSelection } from "./mergeCandidateSelection";
+import type { Candidate } from "./types";
+
+describe("mergeCandidateSelection", () => {
+  it("sets providerUrl.spotify when url is selected for spotify", () => {
+    const candidate = makeCandidate();
+
+    const update = mergeCandidateSelection(candidate, "spotify", ["url"]);
+
+    expect(update.providerUrl).toEqual({ spotify: candidate.url });
+  });
+
+  it("sets providerUrl.soundcloud when url is selected for soundcloud", () => {
+    const candidate = makeCandidate({
+      url: "https://soundcloud.com/artist",
+    });
+
+    const update = mergeCandidateSelection(candidate, "soundcloud", ["url"]);
+
+    expect(update.providerUrl).toEqual({ soundcloud: candidate.url });
+  });
+
+  it("does not set providerUrl when url is not selected", () => {
+    const candidate = makeCandidate();
+
+    const update = mergeCandidateSelection(candidate, "spotify", ["image"]);
+
+    expect(update.providerUrl).toBeUndefined();
+  });
+
+  it("sets image_url when image is selected", () => {
+    const candidate = makeCandidate({
+      imageUrl: "https://example.com/img.jpg",
+    });
+
+    const update = mergeCandidateSelection(candidate, "spotify", ["image"]);
+
+    expect(update.image_url).toBe(candidate.imageUrl);
+  });
+
+  it("does not set image_url when the candidate has none", () => {
+    const candidate = makeCandidate({ imageUrl: null });
+
+    const update = mergeCandidateSelection(candidate, "spotify", ["image"]);
+
+    expect(update.image_url).toBeUndefined();
+  });
+
+  it("sets description when description is selected", () => {
+    const candidate = makeCandidate({ description: "A great artist." });
+
+    const update = mergeCandidateSelection(candidate, "spotify", [
+      "description",
+    ]);
+
+    expect(update.description).toBe(candidate.description);
+  });
+
+  it("does not set description when the candidate has none", () => {
+    const candidate = makeCandidate({ description: null });
+
+    const update = mergeCandidateSelection(candidate, "spotify", [
+      "description",
+    ]);
+
+    expect(update.description).toBeUndefined();
+  });
+
+  it("sets all requested fields when multiple are selected", () => {
+    const candidate = makeCandidate({
+      imageUrl: "https://example.com/img.jpg",
+      description: "A great artist.",
+    });
+
+    const update = mergeCandidateSelection(candidate, "spotify", [
+      "url",
+      "image",
+      "description",
+    ]);
+
+    expect(update.providerUrl).toEqual({ spotify: candidate.url });
+    expect(update.image_url).toBe(candidate.imageUrl);
+    expect(update.description).toBe(candidate.description);
+  });
+
+  it("never writes genres to updates", () => {
+    const candidate = makeCandidate({ genres: ["rock", "pop"] });
+
+    const update = mergeCandidateSelection(candidate, "spotify", [
+      "url",
+      "image",
+      "description",
+    ]);
+
+    expect(update).not.toHaveProperty("genres");
+  });
+
+  it("does not overwrite an already-staged image_url", () => {
+    const candidate = makeCandidate({
+      imageUrl: "https://example.com/other-image.jpg",
+    });
+
+    const update = mergeCandidateSelection(candidate, "spotify", ["image"], {
+      image_url: "https://example.com/first-image.jpg",
+    });
+
+    expect(update.image_url).toBeUndefined();
+  });
+
+  it("does not overwrite an already-staged description", () => {
+    const candidate = makeCandidate({ description: "Another bio." });
+
+    const update = mergeCandidateSelection(
+      candidate,
+      "spotify",
+      ["description"],
+      { description: "First staged bio." },
+    );
+
+    expect(update.description).toBeUndefined();
+  });
+
+  it("still sets providerUrl even when other fields are already staged", () => {
+    const candidate = makeCandidate();
+
+    const update = mergeCandidateSelection(
+      candidate,
+      "spotify",
+      ["url", "image", "description"],
+      {
+        image_url: "https://example.com/first-image.jpg",
+        description: "First staged bio.",
+      },
+    );
+
+    expect(update.providerUrl).toEqual({ spotify: candidate.url });
+  });
+});
+
+function makeCandidate(overrides: Partial<Candidate> = {}): Candidate {
+  return {
+    name: "Test Artist",
+    url: "https://spotify.com/artist/123",
+    imageUrl: "https://example.com/image.jpg",
+    description: "A test artist bio.",
+    followers: 1000,
+    genres: ["rock", "pop"],
+    ...overrides,
+  };
+}

src/api/artistSearch/mergeCandidateSelection.ts

@@ -0,0 +1,41 @@
+import type { Candidate, Provider } from "./types";
+
+export interface CandidateUpdate {
+  providerUrl?: Partial<Record<Provider, string>>;
+  image_url?: string | null;
+  description?: string | null;
+}
+
+export type SelectableField = "url" | "image" | "description";
+
+export interface StagedValues {
+  image_url?: string | null | undefined;
+  description?: string | null | undefined;
+}
+
+export function mergeCandidateSelection(
+  candidate: Candidate,
+  provider: Provider,
+  fields: SelectableField[],
+  staged: StagedValues = {},
+): CandidateUpdate {
+  const updates: CandidateUpdate = {};
+
+  if (fields.includes("url")) {
+    updates.providerUrl = { [provider]: candidate.url };
+  }
+
+  if (fields.includes("image") && candidate.imageUrl && !staged.image_url) {
+    updates.image_url = candidate.imageUrl;
+  }
+
+  if (
+    fields.includes("description") &&
+    candidate.description &&
+    !staged.description
+  ) {
+    updates.description = candidate.description;
+  }
+
+  return updates;
+}

src/api/artistSearch/types.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+
+export const providerSchema = z.enum(["soundcloud", "spotify"]);
+export type Provider = z.infer<typeof providerSchema>;
+
+export const candidateSchema = z.object({
+  name: z.string(),
+  url: z.string(),
+  imageUrl: z.string().nullable(),
+  description: z.string().nullable(),
+  followers: z.number().nullable(),
+  genres: z.array(z.string()),
+});
+export type Candidate = z.infer<typeof candidateSchema>;
+
+export const searchResultSchema = z.object({
+  artistName: z.string(),
+  provider: providerSchema,
+  candidates: z.array(candidateSchema),
+  error: z.string().optional(),
+});
+export type SearchResult = z.infer<typeof searchResultSchema>;
+
+export const searchResponseSchema = z.object({
+  results: z.array(searchResultSchema),
+});
+export type SearchResponse = z.infer<typeof searchResponseSchema>;
+
+export const artistSearchKeys = {
+  all: ["artistSearch"] as const,
+  searches: () => [...artistSearchKeys.all, "search"] as const,
+  search: (artistNames: string[], provider?: Provider) =>
+    [...artistSearchKeys.searches(), { artistNames, provider }] as const,
+};

src/api/artistSearch/usePrefetchNextBatchLinks.ts

@@ -0,0 +1,32 @@
+import { useEffect } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import type { Artist } from "@/api/artists/types";
+import { searchArtistLinksQuery } from "./useSearchArtistLinksQuery";
+
+export function usePrefetchNextBatchLinks(
+  artists: Artist[],
+  currentArtistId: string | undefined,
+) {
+  const queryClient = useQueryClient();
+
+  useEffect(() => {
+    if (!currentArtistId || artists.length === 0) return;
+
+    const currentIdx = Math.max(
+      0,
+      artists.findIndex((a) => a.id === currentArtistId),
+    );
+    const positionInBatch = currentIdx % 10;
+
+    if (positionInBatch < 8) return;
+
+    const nextBatchStart = Math.floor(currentIdx / 10) * 10 + 10;
+    const nextBatchArtists = artists
+      .slice(nextBatchStart, nextBatchStart + 10)
+      .map((a) => a.name);
+
+    if (nextBatchArtists.length > 0) {
+      queryClient.prefetchQuery(searchArtistLinksQuery(nextBatchArtists));
+    }
+  }, [currentArtistId, artists, queryClient]);
+}

src/api/artistSearch/useSearchArtistLinksQuery.ts

@@ -0,0 +1,55 @@
+import { queryOptions, useQuery } from "@tanstack/react-query";
+import { supabase } from "@/integrations/supabase/client";
+import {
+  artistSearchKeys,
+  searchResponseSchema,
+  type SearchResponse,
+  type Provider,
+} from "./types";
+
+async function fetchSearchArtistLinks(
+  artistNames: string[],
+  provider?: Provider,
+): Promise<SearchResponse> {
+  if (artistNames.length === 0) {
+    return { results: [] };
+  }
+
+  const { data, error } = await supabase.functions.invoke(
+    "search-artist-links",
+    {
+      body: {
+        artistNames,
+        provider,
+      },
+    },
+  );
+
+  if (error) {
+    console.error("Error searching artist links:", error);
+    throw new Error("Failed to search artist links");
+  }
+
+  return searchResponseSchema.parse(data);
+}
+
+export function searchArtistLinksQuery(
+  artistNames: string[],
+  provider?: Provider,
+) {
+  return queryOptions({
+    queryKey: artistSearchKeys.search(artistNames, provider),
+    queryFn: () => fetchSearchArtistLinks(artistNames, provider),
+    enabled: artistNames.length > 0,
+    staleTime: 1000 * 60 * 30,
+  });
+}
+
+export function useSearchArtistLinksQuery(
+  artistNames: string[],
+  provider?: Provider,
+) {
+  return useQuery({
+    ...searchArtistLinksQuery(artistNames, provider),
+  });
+}