Files
otunes/apps/web/lib/song-cache.ts

174 lines
4.5 KiB
TypeScript

import { useConvex, type ConvexReactClient } from "convex/react"
import { useEffect, useMemo, useSyncExternalStore } from "react"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type { BrowseAlbumDetail, BrowseSong } from "@otunes/convex/types"
import {
isPersistentCacheLoaded,
readCache,
subscribeCacheLoaded,
writeCache,
} from "@/lib/persistent-cache"
const FETCH_BATCH_SIZE = 100
const FETCH_DELAY_MS = 16
const listeners = new Set<() => void>()
const missingSongIds = new Set<string>()
const inFlightSongIds = new Set<string>()
const queuedSongIds = new Set<Id<"songs">>()
let version = 0
let fetchTimer: ReturnType<typeof setTimeout> | null = null
function songKey(songId: string) {
return `song:${songId}`
}
function notify() {
version += 1
for (const listener of listeners) {
listener()
}
}
if (typeof window !== "undefined") {
subscribeCacheLoaded(notify)
}
function subscribe(listener: () => void) {
listeners.add(listener)
return () => {
listeners.delete(listener)
}
}
function sameSong(a: BrowseSong, b: BrowseSong) {
return (
a.title === b.title &&
a.durationSeconds === b.durationSeconds &&
a.explicit === b.explicit &&
a.artist.id === b.artist.id &&
a.artist.name === b.artist.name &&
a.artist.photo === b.artist.photo &&
a.album.id === b.album.id &&
a.album.title === b.album.title &&
a.album.cover === b.album.cover
)
}
export function getCachedSong(songId: string) {
return readCache<BrowseSong>(songKey(songId))
}
/** Stores song metadata so the player and queue can render it offline. */
export function rememberSongs(songs: readonly BrowseSong[]) {
let changed = false
for (const song of songs) {
const existing = getCachedSong(song.id)
if (existing && sameSong(existing, song)) {
continue
}
writeCache(songKey(song.id), song)
missingSongIds.delete(song.id)
changed = true
}
if (changed) {
notify()
}
}
export function albumDetailSongs(album: BrowseAlbumDetail): BrowseSong[] {
return album.tracks.map((track) => ({
id: track.id,
title: track.title,
artist: album.artist,
album: { id: album.id, title: album.title, cover: album.cover },
durationSeconds: track.durationSeconds,
}))
}
async function fetchQueuedSongs(convex: ConvexReactClient) {
fetchTimer = null
const ids = [...queuedSongIds]
queuedSongIds.clear()
for (let start = 0; start < ids.length; start += FETCH_BATCH_SIZE) {
const batch = ids.slice(start, start + FETCH_BATCH_SIZE)
try {
const songs = await convex.query(api.library.browseSongsByIds, {
ids: batch,
})
const found = new Set(songs.map((song) => song.id as string))
for (const id of batch) {
if (!found.has(id)) {
missingSongIds.add(id)
}
}
rememberSongs(songs)
} catch {
// Leave them uncached so a later render retries.
} finally {
for (const id of batch) {
inFlightSongIds.delete(id)
}
}
}
notify()
}
function requestSongs(convex: ConvexReactClient, songIds: Id<"songs">[]) {
for (const songId of songIds) {
if (
getCachedSong(songId) ||
missingSongIds.has(songId) ||
inFlightSongIds.has(songId)
) {
continue
}
inFlightSongIds.add(songId)
queuedSongIds.add(songId)
}
if (queuedSongIds.size > 0 && fetchTimer === null) {
fetchTimer = setTimeout(() => void fetchQueuedSongs(convex), FETCH_DELAY_MS)
}
}
/**
* Resolves song metadata from the persistent song cache, fetching anything
* missing in batches. Entries are `undefined` until loaded.
*/
export function useSongs(songIds: readonly Id<"songs">[]) {
const convex = useConvex()
const songsVersion = useSyncExternalStore(
subscribe,
() => version,
() => 0
)
const songs = useMemo(
() => songIds.map((songId) => getCachedSong(songId)),
// songsVersion invalidates the lookup when the cache changes.
// eslint-disable-next-line react-hooks/exhaustive-deps
[songIds, songsVersion]
)
useEffect(() => {
if (!isPersistentCacheLoaded()) {
return
}
const missing = songIds.filter((songId, index) => !songs[index])
if (missing.length > 0) {
requestSongs(convex, missing)
}
}, [convex, songIds, songs])
return songs
}
export function useSong(songId: Id<"songs"> | null) {
const songIds = useMemo(() => (songId ? [songId] : []), [songId])
return useSongs(songIds)[0] ?? null
}