Merge pull request 'feat(web): admin area with libraries and scanning (F3a)' (#70) from feat/admin-libraries into main

This commit is contained in:
squidd 2026-11-12 14:49:29 +01:00
commit 0b9d158f2b
2 changed files with 1155 additions and 12 deletions

View file

@ -0,0 +1,111 @@
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { act, renderHook, waitFor } from '@testing-library/react'
import type { ReactNode } from 'react'
import { expect, test } from 'vitest'
import { mockFetch } from '@/test/mockFetch'
import { useAddLibrary, useLibraries, useRemoveLibrary, useScanStatus, useStartScan, useUpdateLibrary } from './libraries'
function setup() {
const client = new QueryClient({ defaultOptions: { queries: { retry: false }, mutations: { retry: false } } })
const wrapper = ({ children }: { children: ReactNode }) => <QueryClientProvider client={client}>{children}</QueryClientProvider>
return { client, wrapper }
}
const lib = (id: number, name = `Lib ${id}`) => ({ id, name, path: `/music/${id}`, created_at: '2026-11-12T10:00:00Z' })
const none = () => new Response(null, { status: 204 })
test('the libraries are listed', async () => {
mockFetch({ 'GET /api/v1/libraries': () => ({ libraries: [lib(1), lib(2)] }) })
const { result } = renderHook(() => useLibraries(), { wrapper: setup().wrapper })
await waitFor(() => expect(result.current.data).toHaveLength(2))
expect(result.current.data?.[0].name).toBe('Lib 1')
})
test('adding sends the name and the folder, and the list is read again', async () => {
let libs = [lib(1)]
const { calls } = mockFetch({
'GET /api/v1/libraries': () => ({ libraries: libs }),
'POST /api/v1/libraries': ({ init }) => {
const body = JSON.parse(String(init.body))
libs = [...libs, { ...lib(2), ...body }]
return new Response(JSON.stringify(libs[1]), { status: 201, headers: { 'Content-Type': 'application/json' } })
},
})
const { wrapper } = setup()
const { result } = renderHook(() => ({ list: useLibraries(), add: useAddLibrary() }), { wrapper })
await waitFor(() => expect(result.current.list.data).toHaveLength(1))
await act(() => result.current.add.mutateAsync({ name: 'Jazz', path: '/music/jazz' }))
await waitFor(() => expect(result.current.list.data).toHaveLength(2))
expect(JSON.parse(String(calls.find((c) => c.key === 'POST /api/v1/libraries')?.init.body))).toEqual({ name: 'Jazz', path: '/music/jazz' })
})
test('renaming sends only the name, moving only the folder', async () => {
const { calls } = mockFetch({ 'PATCH /api/v1/libraries/3': () => lib(3), 'GET /api/v1/libraries': () => ({ libraries: [] }) })
const { result } = renderHook(() => useUpdateLibrary(), { wrapper: setup().wrapper })
await act(() => result.current.mutateAsync({ id: 3, name: 'New name' }))
await act(() => result.current.mutateAsync({ id: 3, path: '/music/new' }))
const bodies = calls.filter((c) => c.key === 'PATCH /api/v1/libraries/3').map((c) => JSON.parse(String(c.init.body)))
expect(bodies).toEqual([{ name: 'New name' }, { path: '/music/new' }])
})
test('removing asks the server to delete that library and the list is read again', async () => {
const { calls } = mockFetch({ 'DELETE /api/v1/libraries/3': none, 'GET /api/v1/libraries': () => ({ libraries: [] }) })
const { wrapper } = setup()
const { result } = renderHook(() => ({ list: useLibraries(), remove: useRemoveLibrary() }), { wrapper })
await waitFor(() => expect(result.current.list.isSuccess).toBe(true))
await act(() => result.current.remove.mutateAsync(3))
await waitFor(() => expect(calls.filter((c) => c.key === 'GET /api/v1/libraries')).toHaveLength(2))
expect(calls.map((c) => c.key)).toContain('DELETE /api/v1/libraries/3')
})
test('a scan of everything is a POST to /library/scan, and "full" is sent only when asked', async () => {
const { calls } = mockFetch({
'POST /api/v1/library/scan': () => new Response(JSON.stringify({ status: 'started' }), { status: 202, headers: { 'Content-Type': 'application/json' } }),
'GET /api/v1/library/scan': () => ({ running: true }),
})
const { result } = renderHook(() => useStartScan(), { wrapper: setup().wrapper })
await act(() => result.current.mutateAsync({ full: false }))
await act(() => result.current.mutateAsync({ full: true }))
const posts = calls.filter((c) => c.key === 'POST /api/v1/library/scan')
expect(posts[0].url.searchParams.has('full')).toBe(false)
expect(posts[1].url.searchParams.get('full')).toBe('true')
})
test('a scan of one library names it', async () => {
const { calls } = mockFetch({
'POST /api/v1/libraries/3/scan': () => new Response(JSON.stringify({ status: 'started' }), { status: 202, headers: { 'Content-Type': 'application/json' } }),
'GET /api/v1/library/scan': () => ({ running: true }),
})
const { result } = renderHook(() => useStartScan(), { wrapper: setup().wrapper })
await act(() => result.current.mutateAsync({ libraryId: 3, full: true }))
const post = calls.find((c) => c.key === 'POST /api/v1/libraries/3/scan')
expect(post?.url.searchParams.get('full')).toBe('true')
})
test('while a scan runs the status is read again and again, and it stops by itself when the scan ends', async () => {
let n = 0
const { calls } = mockFetch({ 'GET /api/v1/library/scan': () => (++n < 3 ? { running: true } : { running: false }) })
const { result } = renderHook(() => useScanStatus({ intervalMs: 20 }), { wrapper: setup().wrapper })
await waitFor(() => expect(result.current.data?.running).toBe(false), { timeout: 2000 })
const seen = calls.length
await new Promise((r) => setTimeout(r, 120))
expect(calls).toHaveLength(seen)
expect(seen).toBe(3)
})
test('starting a scan makes the status be read at once, so the page follows it', async () => {
let running = false
const { calls } = mockFetch({
'GET /api/v1/library/scan': () => ({ running }),
'POST /api/v1/library/scan': () => {
running = true
return new Response(JSON.stringify({ status: 'started' }), { status: 202, headers: { 'Content-Type': 'application/json' } })
},
})
const { wrapper } = setup()
const { result } = renderHook(() => ({ status: useScanStatus({ intervalMs: 20 }), start: useStartScan() }), { wrapper })
await waitFor(() => expect(result.current.status.data?.running).toBe(false))
await act(() => result.current.start.mutateAsync({ full: false }))
await waitFor(() => expect(result.current.status.data?.running).toBe(true))
expect(calls.filter((c) => c.key === 'GET /api/v1/library/scan').length).toBeGreaterThanOrEqual(2)
})

69
web/src/api/libraries.ts Normal file
View file

@ -0,0 +1,69 @@
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import { api } from './client'
import type { components } from './schema'
export type Library = components['schemas']['Library']
export type ScanStatus = components['schemas']['ScanStatus']
export type ScanSummary = components['schemas']['ScanSummary']
const LIBRARIES = ['libraries']
const SCAN = ['library', 'scan']
/** Every library, oldest first. Admins only. */
export function useLibraries() {
return useQuery({
queryKey: LIBRARIES,
queryFn: () => api.get<{ libraries: Library[] }>('/libraries'),
select: (data) => data.libraries,
})
}
export function useAddLibrary() {
const client = useQueryClient()
return useMutation({
mutationFn: (body: { name: string; path: string }) => api.post<Library>('/libraries', body),
onSuccess: () => client.invalidateQueries({ queryKey: LIBRARIES }),
})
}
/** Rename, move, or both: only the fields given are sent. */
export function useUpdateLibrary() {
const client = useQueryClient()
return useMutation({
mutationFn: ({ id, ...changes }: { id: number; name?: string; path?: string }) => api.patch<Library>(`/libraries/${id}`, changes),
onSuccess: () => client.invalidateQueries({ queryKey: LIBRARIES }),
})
}
/** Removes the library from Sonda; the tracks, the history and the music on disk stay. */
export function useRemoveLibrary() {
const client = useQueryClient()
return useMutation({
mutationFn: (id: number) => api.del(`/libraries/${id}`),
onSuccess: () => client.invalidateQueries({ queryKey: LIBRARIES }),
})
}
/** Whether a scan runs and how the last one ended. While one runs it is read again every `intervalMs`. */
export function useScanStatus({ intervalMs = 2000 }: { intervalMs?: number } = {}) {
return useQuery({
queryKey: SCAN,
queryFn: () => api.get<ScanStatus>('/library/scan'),
refetchInterval: (query) => (query.state.data?.running ? intervalMs : false),
})
}
/**
* Starts a scan in the background: of one library, or of all. `full` reads every file again. Whatever the
* answer (also "a scan is already running"), the status is read at once so the page follows the scan.
*/
export function useStartScan() {
const client = useQueryClient()
return useMutation({
mutationFn: ({ libraryId, full }: { libraryId?: number; full: boolean }) => {
const path = libraryId === undefined ? '/library/scan' : `/libraries/${libraryId}/scan`
return api.post<{ status: 'started' }>(full ? `${path}?full=true` : path)
},
onSettled: () => client.invalidateQueries({ queryKey: SCAN }),
})
}