Whole-library and favorites queries return lists split into chunks of at most 8,192 values, and search keeps the top 500 per section. Favorite writes and song detail lookups read whole ranges instead of one id at a time, and large unfavorites finish in scheduled batches, so they stay under Convex's 4,096 reads per function. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
196 lines
6.3 KiB
TypeScript
196 lines
6.3 KiB
TypeScript
import { useConvex, useQuery } from "convex/react"
|
|
import * as AppIntents from "expo-app-intents"
|
|
import type { AppIntentEntity } from "expo-app-intents"
|
|
import { useEffect, useRef } from "react"
|
|
import { AppState } from "react-native"
|
|
|
|
import { useCacheScope } from "@/contexts/persistent-cache"
|
|
import {
|
|
loadCatalogCursors,
|
|
saveCatalogCursors,
|
|
type CatalogCursors,
|
|
} from "@/lib/app-intent-handled"
|
|
import {
|
|
publishMusicCatalog,
|
|
readMusicCatalog,
|
|
trackMusicCatalogSync,
|
|
} from "@/lib/app-intents"
|
|
import { api } from "@otunes/convex/_generated/api"
|
|
import type { FunctionReturnType } from "convex/server"
|
|
|
|
const LIBRARY_KINDS = ["artist", "album", "song"] as const
|
|
type LibraryKind = (typeof LIBRARY_KINDS)[number]
|
|
const PAGE_SIZE = 500
|
|
type CatalogPage = FunctionReturnType<typeof api.intentCatalog.page>
|
|
|
|
type Favorites = FunctionReturnType<typeof api.favorites.getUserFavorites>
|
|
|
|
function favoriteIds(favorites: Favorites, kind: LibraryKind) {
|
|
return new Set<string>(
|
|
(kind === "song"
|
|
? favorites.favoriteSongs
|
|
: kind === "album"
|
|
? favorites.favoriteAlbums
|
|
: favorites.favoriteArtists
|
|
).flat()
|
|
)
|
|
}
|
|
|
|
/** Stamps `metadata.favorite`, which Siri uses to rank suggestions. */
|
|
function withFavorite(entity: AppIntentEntity, favorite: boolean) {
|
|
const flag = favorite ? "1" : "0"
|
|
return entity.metadata?.favorite === flag
|
|
? entity
|
|
: { ...entity, metadata: { ...entity.metadata, favorite: flag } }
|
|
}
|
|
|
|
/**
|
|
* Keeps the on-device Siri catalog in step with the server. `intentCatalog.head`
|
|
* is a live subscription, so the library is fetched only when it changes, and
|
|
* then only the records changed since the stored cursor. Favorites are applied
|
|
* locally from the existing favorites subscription.
|
|
*/
|
|
export function useMusicCatalogSync() {
|
|
const convex = useConvex()
|
|
const scope = useCacheScope()
|
|
const head = useQuery(api.intentCatalog.head)
|
|
const favorites = useQuery(api.favorites.getUserFavorites)
|
|
const playlists = useQuery(api.intentCatalog.playlists)
|
|
const latest = useRef({ head, favorites, playlists })
|
|
latest.current = { head, favorites, playlists }
|
|
const schedule = useRef<() => void>(() => undefined)
|
|
|
|
useEffect(() => {
|
|
if (!AppIntents.isAvailable()) return
|
|
let stopped = false
|
|
let running = false
|
|
let dirty = false
|
|
let cursors: CatalogCursors | null = null
|
|
// What the disk catalog reflects, to skip no-op republishes.
|
|
const appliedFavorites = new Map<LibraryKind, Set<string>>()
|
|
let publishedPlaylists: string | null = null
|
|
|
|
async function fetchChanges(kind: LibraryKind, since: number | undefined) {
|
|
const upserts: AppIntentEntity[] = []
|
|
let removed: string[] = []
|
|
let head = 0
|
|
let cursor: string | null = null
|
|
do {
|
|
const result: CatalogPage = await convex.query(api.intentCatalog.page, {
|
|
kind,
|
|
since,
|
|
paginationOpts: { cursor, numItems: PAGE_SIZE },
|
|
})
|
|
if (stopped) return null
|
|
if (cursor === null) {
|
|
if (result.reset) return fetchChanges(kind, undefined)
|
|
head = result.head ?? 0
|
|
removed = result.removed
|
|
}
|
|
upserts.push(...result.page)
|
|
cursor = result.isDone ? null : result.continueCursor
|
|
} while (cursor !== null)
|
|
return { upserts, removed, head, full: since === undefined }
|
|
}
|
|
|
|
async function syncKind(
|
|
kind: LibraryKind,
|
|
serverHead: number,
|
|
favorites: Favorites
|
|
) {
|
|
if (!cursors) return
|
|
const since = cursors[kind]
|
|
const stale = since === undefined || serverHead > since
|
|
const liked = favoriteIds(favorites, kind)
|
|
const previousLiked = appliedFavorites.get(kind)
|
|
const likesChanged =
|
|
!previousLiked ||
|
|
previousLiked.size !== liked.size ||
|
|
[...liked].some((id) => !previousLiked.has(id))
|
|
if (!stale && !likesChanged) return
|
|
|
|
const changes = stale ? await fetchChanges(kind, since) : null
|
|
if (stopped) return
|
|
const records = new Map<string, AppIntentEntity>()
|
|
if (!changes?.full) {
|
|
for (const entity of await readMusicCatalog(kind)) {
|
|
records.set(entity.id, entity)
|
|
}
|
|
}
|
|
for (const id of changes?.removed ?? []) records.delete(id)
|
|
for (const entity of changes?.upserts ?? [])
|
|
records.set(entity.id, entity)
|
|
|
|
let modified = changes !== null
|
|
for (const [id, entity] of records) {
|
|
const next = withFavorite(entity, liked.has(id))
|
|
if (next !== entity) {
|
|
records.set(id, next)
|
|
modified = true
|
|
}
|
|
}
|
|
if (stopped) return
|
|
if (modified) await publishMusicCatalog(kind, [...records.values()])
|
|
appliedFavorites.set(kind, liked)
|
|
if (changes && !stopped) {
|
|
cursors = { ...cursors, [kind]: changes.head }
|
|
await saveCatalogCursors(scope, cursors)
|
|
}
|
|
}
|
|
|
|
async function syncOnce() {
|
|
const { head, favorites, playlists } = latest.current
|
|
cursors ??= await loadCatalogCursors(scope)
|
|
if (head && favorites) {
|
|
for (const kind of LIBRARY_KINDS) {
|
|
if (stopped) return
|
|
await syncKind(kind, head[kind], favorites)
|
|
}
|
|
}
|
|
if (playlists && !stopped) {
|
|
const json = JSON.stringify(playlists)
|
|
if (json !== publishedPlaylists) {
|
|
await publishMusicCatalog("playlist", playlists)
|
|
publishedPlaylists = json
|
|
}
|
|
}
|
|
}
|
|
|
|
schedule.current = () => {
|
|
if (stopped) return
|
|
if (running) {
|
|
dirty = true
|
|
return
|
|
}
|
|
running = true
|
|
const sync = (async () => {
|
|
do {
|
|
dirty = false
|
|
await syncOnce()
|
|
} while (dirty && !stopped)
|
|
})()
|
|
.catch((error) =>
|
|
console.warn("Could not publish music catalog.", error)
|
|
)
|
|
.finally(() => {
|
|
running = false
|
|
})
|
|
trackMusicCatalogSync(sync)
|
|
}
|
|
schedule.current()
|
|
// Retries a failed sync; a no-op without server queries when current.
|
|
const subscription = AppState.addEventListener("change", (state) => {
|
|
if (state === "active") schedule.current()
|
|
})
|
|
return () => {
|
|
stopped = true
|
|
schedule.current = () => undefined
|
|
subscription.remove()
|
|
}
|
|
}, [convex, scope])
|
|
|
|
useEffect(() => {
|
|
schedule.current()
|
|
}, [head, favorites, playlists])
|
|
}
|