Compare commits
2
Commits
No files matched your search
@@ -36,7 +36,7 @@ export default function FavoritesScreen() {
|
||||
const colors = useThemeColors()
|
||||
const { config } = useServerConfig()
|
||||
const favorites = useCachedQuery(api.favorites.browseFavoritesPlaylistDetail)
|
||||
const songs = favorites?.songs ?? []
|
||||
const songs = useMemo(() => favorites?.songs.flat() ?? [], [favorites])
|
||||
const { playInOrder, playShuffled, playFromSong } = usePlaybackActions()
|
||||
const { isSongFavorite } = useFavorites()
|
||||
const { handleSongAction } = useMediaMenuActions()
|
||||
@@ -45,8 +45,8 @@ export default function FavoritesScreen() {
|
||||
usePlaylistSearch(songs)
|
||||
|
||||
useEffect(() => {
|
||||
if (favorites) rememberSongs(favorites.songs)
|
||||
}, [favorites])
|
||||
rememberSongs(songs)
|
||||
}, [songs])
|
||||
|
||||
const handlePlaySong = useCallback(
|
||||
(song: BrowseSong) => void playFromSong(song.id, songIds),
|
||||
|
||||
@@ -23,19 +23,16 @@ type LibraryKind = (typeof LIBRARY_KINDS)[number]
|
||||
const PAGE_SIZE = 500
|
||||
type CatalogPage = FunctionReturnType<typeof api.intentCatalog.page>
|
||||
|
||||
type Favorites = {
|
||||
favoriteSongs: string[]
|
||||
favoriteAlbums: string[]
|
||||
favoriteArtists: string[]
|
||||
}
|
||||
type Favorites = FunctionReturnType<typeof api.favorites.getUserFavorites>
|
||||
|
||||
function favoriteIds(favorites: Favorites, kind: LibraryKind) {
|
||||
return new Set<string>(
|
||||
kind === "song"
|
||||
(kind === "song"
|
||||
? favorites.favoriteSongs
|
||||
: kind === "album"
|
||||
? favorites.favoriteAlbums
|
||||
: favorites.favoriteArtists
|
||||
).flat()
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
@@ -214,12 +214,13 @@ export function useIntentDispatch() {
|
||||
)
|
||||
}
|
||||
if (kind === "artist") {
|
||||
return fetchCachedQuery(
|
||||
const chunks = await fetchCachedQuery(
|
||||
convex,
|
||||
cacheScope,
|
||||
api.playlists.getOrderedArtistSongIds,
|
||||
{ artistId: id as Id<"artists"> }
|
||||
)
|
||||
return chunks.flat()
|
||||
}
|
||||
if (kind === "playlist") {
|
||||
if (id === FAVORITES_PLAYLIST_ID) {
|
||||
@@ -229,7 +230,7 @@ export function useIntentDispatch() {
|
||||
api.favorites.getUserFavorites,
|
||||
{}
|
||||
)
|
||||
return favorites.favoriteSongs
|
||||
return favorites.favoriteSongs.flat()
|
||||
}
|
||||
return fetchCachedQuery(
|
||||
convex,
|
||||
@@ -391,17 +392,18 @@ export function useIntentDispatch() {
|
||||
api.favorites.getUserFavorites,
|
||||
{}
|
||||
)
|
||||
if (favorites.favoriteSongs.length === 0) {
|
||||
const favoriteSongs = favorites.favoriteSongs.flat()
|
||||
if (favoriteSongs.length === 0) {
|
||||
throw new IntentRejected(
|
||||
"Nothing is queued, and your favorites are empty."
|
||||
)
|
||||
}
|
||||
if (shuffled) {
|
||||
ensureActive(invocation)
|
||||
await actions.playShuffled(favorites.favoriteSongs)
|
||||
await actions.playShuffled(favoriteSongs)
|
||||
} else {
|
||||
ensureActive(invocation)
|
||||
await actions.playInOrder(favorites.favoriteSongs)
|
||||
await actions.playInOrder(favoriteSongs)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
@@ -150,7 +150,7 @@ export function AddToPlaylistProvider({ children }: { children: ReactNode }) {
|
||||
{ artistId }
|
||||
)
|
||||
if (selectionRequestIdRef.current !== requestId) return
|
||||
setPendingSongIds(songIds)
|
||||
setPendingSongIds(songIds.flat())
|
||||
setOpen(true)
|
||||
} catch (error) {
|
||||
if (selectionRequestIdRef.current !== requestId) return
|
||||
|
||||
@@ -100,15 +100,15 @@ export function FavoritesProvider({ children }: { children: ReactNode }) {
|
||||
)
|
||||
|
||||
const songIds = useMemo(
|
||||
() => new Set(favorites?.favoriteSongs.map(String) ?? []),
|
||||
() => new Set<string>(favorites?.favoriteSongs.flat()),
|
||||
[favorites?.favoriteSongs]
|
||||
)
|
||||
const albumIds = useMemo(
|
||||
() => new Set(favorites?.favoriteAlbums.map(String) ?? []),
|
||||
() => new Set<string>(favorites?.favoriteAlbums.flat()),
|
||||
[favorites?.favoriteAlbums]
|
||||
)
|
||||
const artistIds = useMemo(
|
||||
() => new Set(favorites?.favoriteArtists.map(String) ?? []),
|
||||
() => new Set<string>(favorites?.favoriteArtists.flat()),
|
||||
[favorites?.favoriteArtists]
|
||||
)
|
||||
const idsRef = useRef({ songIds, albumIds, artistIds })
|
||||
|
||||
@@ -401,7 +401,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
cacheScope,
|
||||
api.playlists.getOrderedArtistSongIds,
|
||||
{ artistId }
|
||||
),
|
||||
).then((chunks) => chunks.flat()),
|
||||
recorded: { entity: { kind: "artist", id: artistId } },
|
||||
}))
|
||||
const playlist = collection(
|
||||
@@ -482,12 +482,14 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
|
||||
let songIds: Id<"songs">[]
|
||||
try {
|
||||
songIds = await fetchCachedQuery(
|
||||
convex,
|
||||
cacheScope,
|
||||
api.library.browseSortedSongIds,
|
||||
sort
|
||||
)
|
||||
songIds = (
|
||||
await fetchCachedQuery(
|
||||
convex,
|
||||
cacheScope,
|
||||
api.library.browseSortedSongIds,
|
||||
sort
|
||||
)
|
||||
).flat()
|
||||
} catch {
|
||||
return
|
||||
}
|
||||
|
||||
@@ -173,7 +173,7 @@ export function useMediaMenuActions() {
|
||||
api.playlists.getOrderedArtistSongIds,
|
||||
{ artistId: artist.id as Id<"artists"> }
|
||||
)
|
||||
await runQueueAction(action, songIds)
|
||||
await runQueueAction(action, songIds.flat())
|
||||
break
|
||||
}
|
||||
default:
|
||||
|
||||
@@ -32,7 +32,7 @@ export default function Page() {
|
||||
<ContentCarousel
|
||||
title="Recently Added"
|
||||
href="/recently-added"
|
||||
content={recentlyAdded}
|
||||
content={recentlyAdded.flat()}
|
||||
/>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
@@ -18,7 +18,7 @@ export default function Page() {
|
||||
) : (
|
||||
<div className="flex-1 overflow-y-auto p-6 pb-28">
|
||||
<div className={albumGridClassName}>
|
||||
{albums.map((album) => (
|
||||
{albums.flat().map((album) => (
|
||||
<AlbumCard key={album.id} album={album} />
|
||||
))}
|
||||
</div>
|
||||
|
||||
@@ -18,7 +18,7 @@ export default function Page() {
|
||||
) : (
|
||||
<div className="flex-1 overflow-y-auto p-6 pb-28">
|
||||
<div className={albumGridClassName}>
|
||||
{albums.map((album) => (
|
||||
{albums.flat().map((album) => (
|
||||
<AlbumCard key={album.id} album={album} />
|
||||
))}
|
||||
</div>
|
||||
|
||||
@@ -184,7 +184,7 @@ export function AddToPlaylistProvider({
|
||||
}
|
||||
)
|
||||
if (requestId === selectionRequestRef.current) {
|
||||
showAddToPlaylist(songIds)
|
||||
showAddToPlaylist(songIds.flat())
|
||||
}
|
||||
} catch (error) {
|
||||
if (requestId === selectionRequestRef.current) {
|
||||
|
||||
@@ -32,8 +32,8 @@ export function ArtistsPage() {
|
||||
<ArtistsSkeleton />
|
||||
) : (
|
||||
<ArtistsView
|
||||
artists={artists}
|
||||
albums={albums}
|
||||
artists={artists.flat()}
|
||||
albums={albums.flat()}
|
||||
artistId={artistIdFromPathname(pathname)}
|
||||
onSelectArtist={selectArtist}
|
||||
/>
|
||||
|
||||
@@ -86,15 +86,15 @@ export function FavoritesProvider({ children }: { children: React.ReactNode }) {
|
||||
)
|
||||
|
||||
const songIds = React.useMemo(
|
||||
() => new Set(favorites?.favoriteSongs.map(String) ?? []),
|
||||
() => new Set<string>(favorites?.favoriteSongs.flat()),
|
||||
[favorites?.favoriteSongs]
|
||||
)
|
||||
const albumIds = React.useMemo(
|
||||
() => new Set(favorites?.favoriteAlbums.map(String) ?? []),
|
||||
() => new Set<string>(favorites?.favoriteAlbums.flat()),
|
||||
[favorites?.favoriteAlbums]
|
||||
)
|
||||
const artistIds = React.useMemo(
|
||||
() => new Set(favorites?.favoriteArtists.map(String) ?? []),
|
||||
() => new Set<string>(favorites?.favoriteArtists.flat()),
|
||||
[favorites?.favoriteArtists]
|
||||
)
|
||||
|
||||
|
||||
@@ -1233,12 +1233,14 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
|
||||
let songIds: Id<"songs">[]
|
||||
try {
|
||||
songIds = await fetchCachedQuery(
|
||||
convex,
|
||||
cacheScope,
|
||||
api.library.browseSortedSongIds,
|
||||
sort
|
||||
)
|
||||
songIds = (
|
||||
await fetchCachedQuery(
|
||||
convex,
|
||||
cacheScope,
|
||||
api.library.browseSortedSongIds,
|
||||
sort
|
||||
)
|
||||
).flat()
|
||||
} catch {
|
||||
return
|
||||
}
|
||||
@@ -1268,7 +1270,7 @@ export function PlaybackProvider({ children }: { children: ReactNode }) {
|
||||
cacheScope,
|
||||
api.playlists.getOrderedArtistSongIds,
|
||||
{ artistId }
|
||||
),
|
||||
).then((chunks) => chunks.flat()),
|
||||
[convex, cacheScope]
|
||||
)
|
||||
|
||||
|
||||
@@ -34,5 +34,7 @@ export function FavoritesPlaylistPage() {
|
||||
return <PageMessage>Sign in to view your favorites.</PageMessage>
|
||||
}
|
||||
|
||||
return <PlaylistView playlist={favorites} />
|
||||
return (
|
||||
<PlaylistView playlist={{ ...favorites, songs: favorites.songs.flat() }} />
|
||||
)
|
||||
}
|
||||
@@ -64,7 +64,7 @@ export function useMediaActions() {
|
||||
api.playlists.getOrderedArtistSongIds,
|
||||
{ artistId: artistId as Id<"artists"> }
|
||||
)
|
||||
void runQueueAction(action, songIds)
|
||||
void runQueueAction(action, songIds.flat())
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,63 +1,54 @@
|
||||
import type { OptimisticLocalStore, OptimisticUpdate } from "convex/browser"
|
||||
import type { FunctionArgs, FunctionReference } from "convex/server"
|
||||
import type {
|
||||
FunctionArgs,
|
||||
FunctionReference,
|
||||
FunctionReturnType,
|
||||
} from "convex/server"
|
||||
|
||||
import { api } from "../convex/_generated/api"
|
||||
import type { Id } from "../convex/_generated/dataModel"
|
||||
import { chunk } from "../convex/limits"
|
||||
|
||||
type FavoriteIds = {
|
||||
favoriteSongs: Id<"songs">[]
|
||||
favoriteAlbums: Id<"albums">[]
|
||||
favoriteArtists: Id<"artists">[]
|
||||
}
|
||||
type UserFavorites = FunctionReturnType<typeof api.favorites.getUserFavorites>
|
||||
type FavoriteList = keyof UserFavorites
|
||||
|
||||
type FavoriteList = keyof FavoriteIds
|
||||
|
||||
function patchFavorites<List extends FavoriteList>(
|
||||
/** Rewrites one list of the cached `getUserFavorites` result, if loaded. */
|
||||
function patchFavorites(
|
||||
store: OptimisticLocalStore,
|
||||
list: List,
|
||||
update: (ids: FavoriteIds[List]) => FavoriteIds[List]
|
||||
list: FavoriteList,
|
||||
update: (ids: string[]) => string[]
|
||||
) {
|
||||
const current = store.getQuery(api.favorites.getUserFavorites, {})
|
||||
if (!current) return
|
||||
const next = update(current[list])
|
||||
if (next !== current[list]) {
|
||||
store.setQuery(
|
||||
api.favorites.getUserFavorites,
|
||||
{},
|
||||
{
|
||||
...current,
|
||||
[list]: next,
|
||||
}
|
||||
)
|
||||
const ids: string[] = current[list].flat()
|
||||
const next = update(ids)
|
||||
if (next !== ids) {
|
||||
// `next` only holds ids of this list's kind, which TS cannot follow here.
|
||||
store.setQuery(api.favorites.getUserFavorites, {}, {
|
||||
...current,
|
||||
[list]: chunk(next),
|
||||
} as UserFavorites)
|
||||
}
|
||||
}
|
||||
|
||||
function addFavorites<List extends FavoriteList>(
|
||||
function addFavorites(
|
||||
store: OptimisticLocalStore,
|
||||
list: List,
|
||||
ids: FavoriteIds[List]
|
||||
list: FavoriteList,
|
||||
ids: string[]
|
||||
) {
|
||||
patchFavorites(store, list, (current) => {
|
||||
const added = ids.filter((id) => !(current as string[]).includes(id))
|
||||
return added.length === 0
|
||||
? current
|
||||
: ([...new Set([...current, ...added])] as FavoriteIds[List])
|
||||
const added = ids.filter((id) => !current.includes(id))
|
||||
return added.length === 0 ? current : [...new Set([...current, ...added])]
|
||||
})
|
||||
}
|
||||
|
||||
function removeFavorites<List extends FavoriteList>(
|
||||
function removeFavorites(
|
||||
store: OptimisticLocalStore,
|
||||
list: List,
|
||||
ids: FavoriteIds[List]
|
||||
list: FavoriteList,
|
||||
ids: string[]
|
||||
) {
|
||||
const removed = new Set<string>(ids)
|
||||
patchFavorites(
|
||||
store,
|
||||
list,
|
||||
(current) =>
|
||||
(current as string[]).filter(
|
||||
(id) => !removed.has(id)
|
||||
) as FavoriteIds[List]
|
||||
const removed = new Set(ids)
|
||||
patchFavorites(store, list, (current) =>
|
||||
current.filter((id) => !removed.has(id))
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
+2
@@ -11,6 +11,7 @@
|
||||
import type * as actions from "../actions.js";
|
||||
import type * as auth from "../auth.js";
|
||||
import type * as crons from "../crons.js";
|
||||
import type * as favoriteStore from "../favoriteStore.js";
|
||||
import type * as favorites from "../favorites.js";
|
||||
import type * as http from "../http.js";
|
||||
import type * as intentCatalog from "../intentCatalog.js";
|
||||
@@ -34,6 +35,7 @@ declare const fullApi: ApiFromModules<{
|
||||
actions: typeof actions;
|
||||
auth: typeof auth;
|
||||
crons: typeof crons;
|
||||
favoriteStore: typeof favoriteStore;
|
||||
favorites: typeof favorites;
|
||||
http: typeof http;
|
||||
intentCatalog: typeof intentCatalog;
|
||||
|
||||
@@ -29,7 +29,7 @@ function playlistMutation() {
|
||||
mutation: (definition) => definition,
|
||||
query: (definition) => definition,
|
||||
}
|
||||
if (name === "./library") return {}
|
||||
if (name === "./library" || name === "./limits") return {}
|
||||
throw new Error(`Unexpected import ${name}`)
|
||||
},
|
||||
})
|
||||
|
||||
@@ -0,0 +1,274 @@
|
||||
import type { WithoutSystemFields } from "convex/server"
|
||||
import { ConvexError, v } from "convex/values"
|
||||
import { internal } from "./_generated/api"
|
||||
import type { Doc, Id } from "./_generated/dataModel"
|
||||
import type { MutationCtx, QueryCtx } from "./_generated/server"
|
||||
import { internalMutation } from "./_generated/server"
|
||||
import { chunk, type Chunked } from "./limits"
|
||||
|
||||
export type FavoriteKind = Doc<"favorites">["kind"]
|
||||
|
||||
type FavoriteEntityId = {
|
||||
[Kind in FavoriteKind]: Extract<Doc<"favorites">, { kind: Kind }>["entityId"]
|
||||
}
|
||||
|
||||
/** A user's favorites, each list oldest first. */
|
||||
export type FavoriteIds = {
|
||||
favoriteSongs: Id<"songs">[]
|
||||
favoriteAlbums: Id<"albums">[]
|
||||
favoriteArtists: Id<"artists">[]
|
||||
}
|
||||
|
||||
/** `FavoriteIds` as `favorites.getUserFavorites` returns it. */
|
||||
export type FavoriteIdChunks = {
|
||||
[List in keyof FavoriteIds]: Chunked<FavoriteIds[List][number]>
|
||||
}
|
||||
|
||||
function legacyFavorites(user: Doc<"users"> | null): FavoriteIds {
|
||||
return {
|
||||
favoriteSongs: user?.favoriteSongs ?? [],
|
||||
favoriteAlbums: user?.favoriteAlbums ?? [],
|
||||
favoriteArtists: user?.favoriteArtists ?? [],
|
||||
}
|
||||
}
|
||||
|
||||
export function hasLegacyFavorites(user: Doc<"users">) {
|
||||
return (
|
||||
user.favoriteSongs !== undefined ||
|
||||
user.favoriteAlbums !== undefined ||
|
||||
user.favoriteArtists !== undefined
|
||||
)
|
||||
}
|
||||
|
||||
/** Favorited ids of one kind, oldest first. */
|
||||
async function readKind<Kind extends FavoriteKind>(
|
||||
ctx: QueryCtx,
|
||||
userId: Id<"users">,
|
||||
kind: Kind
|
||||
): Promise<FavoriteEntityId[Kind][]> {
|
||||
const rows = await ctx.db
|
||||
.query("favorites")
|
||||
.withIndex("by_user_kind", (q) => q.eq("userId", userId).eq("kind", kind))
|
||||
.collect()
|
||||
return rows.map((row) => row.entityId as FavoriteEntityId[Kind])
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads every favorite, oldest first. Users without rows fall back to the
|
||||
* legacy arrays on `users` until `migrations.migrateUsers` moves them, so
|
||||
* migrated users never read (or rerun on) their user doc here.
|
||||
*/
|
||||
export async function readFavorites(
|
||||
ctx: QueryCtx,
|
||||
userId: Id<"users">
|
||||
): Promise<FavoriteIds> {
|
||||
const [favoriteSongs, favoriteAlbums, favoriteArtists] = await Promise.all([
|
||||
readKind(ctx, userId, "song"),
|
||||
readKind(ctx, userId, "album"),
|
||||
readKind(ctx, userId, "artist"),
|
||||
])
|
||||
if (
|
||||
favoriteSongs.length > 0 ||
|
||||
favoriteAlbums.length > 0 ||
|
||||
favoriteArtists.length > 0
|
||||
) {
|
||||
return { favoriteSongs, favoriteAlbums, favoriteArtists }
|
||||
}
|
||||
return legacyFavorites(await ctx.db.get(userId))
|
||||
}
|
||||
|
||||
/**
|
||||
* Above this many ids, one scan of the user's list beats a lookup per id, and
|
||||
* keeps bulk writes under Convex's 4,096 reads per function.
|
||||
*/
|
||||
const MAX_POINT_LOOKUPS = 64
|
||||
|
||||
/** Maps each of `ids` the user has favorited to its row. */
|
||||
async function favoriteRows<Kind extends FavoriteKind>(
|
||||
ctx: QueryCtx,
|
||||
userId: Id<"users">,
|
||||
kind: Kind,
|
||||
ids: ReadonlySet<FavoriteEntityId[Kind]>
|
||||
): Promise<Map<string, Id<"favorites">>> {
|
||||
const rows =
|
||||
ids.size <= MAX_POINT_LOOKUPS
|
||||
? await Promise.all(
|
||||
[...ids].map((entityId) =>
|
||||
ctx.db
|
||||
.query("favorites")
|
||||
.withIndex("by_user_entity", (q) =>
|
||||
q.eq("userId", userId).eq("entityId", entityId)
|
||||
)
|
||||
.unique()
|
||||
)
|
||||
)
|
||||
: await ctx.db
|
||||
.query("favorites")
|
||||
.withIndex("by_user_kind", (q) =>
|
||||
q.eq("userId", userId).eq("kind", kind)
|
||||
)
|
||||
.collect()
|
||||
return new Map(
|
||||
rows.flatMap((row) =>
|
||||
row && ids.has(row.entityId as FavoriteEntityId[Kind])
|
||||
? [[row.entityId, row._id] as const]
|
||||
: []
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
/** True when `ids` is non-empty and the user has favorited every one. */
|
||||
export async function allFavorited<Kind extends FavoriteKind>(
|
||||
ctx: QueryCtx,
|
||||
userId: Id<"users">,
|
||||
kind: Kind,
|
||||
ids: FavoriteEntityId[Kind][]
|
||||
) {
|
||||
const unique = new Set(ids)
|
||||
if (unique.size === 0) {
|
||||
return false
|
||||
}
|
||||
const rows = await favoriteRows(ctx, userId, kind, unique)
|
||||
return rows.size === unique.size
|
||||
}
|
||||
|
||||
/** Appends ids that are not favorited yet, keeping existing ones in place. */
|
||||
export async function addFavorites<Kind extends FavoriteKind>(
|
||||
ctx: MutationCtx,
|
||||
userId: Id<"users">,
|
||||
kind: Kind,
|
||||
ids: FavoriteEntityId[Kind][]
|
||||
) {
|
||||
const unique = new Set(ids)
|
||||
const existing = await favoriteRows(ctx, userId, kind, unique)
|
||||
for (const entityId of unique) {
|
||||
if (!existing.has(entityId)) {
|
||||
// TS cannot tie a generic `kind` to its `entityId` union member.
|
||||
await ctx.db.insert("favorites", {
|
||||
userId,
|
||||
kind,
|
||||
entityId,
|
||||
} as WithoutSystemFields<Doc<"favorites">>)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export async function removeFavorites<Kind extends FavoriteKind>(
|
||||
ctx: MutationCtx,
|
||||
userId: Id<"users">,
|
||||
kind: Kind,
|
||||
ids: FavoriteEntityId[Kind][]
|
||||
) {
|
||||
const rows = await favoriteRows(ctx, userId, kind, new Set(ids))
|
||||
await deleteFavoriteRows(ctx, [...rows.values()])
|
||||
}
|
||||
|
||||
/**
|
||||
* Rows one call deletes before scheduling the rest. Convex counts each delete
|
||||
* as a read, so unfavoriting a huge artist cannot happen in one mutation.
|
||||
*/
|
||||
const MAX_INLINE_DELETES = 1_000
|
||||
|
||||
async function deleteFavoriteRows(ctx: MutationCtx, rowIds: Id<"favorites">[]) {
|
||||
for (const rowId of rowIds.slice(0, MAX_INLINE_DELETES)) {
|
||||
await ctx.db.delete(rowId)
|
||||
}
|
||||
for (const rest of chunk(rowIds.slice(MAX_INLINE_DELETES))) {
|
||||
await ctx.scheduler.runAfter(0, internal.favoriteStore.deleteRows, {
|
||||
rowIds: rest,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/** Finishes deletes `deleteFavoriteRows` could not fit in one mutation. */
|
||||
export const deleteRows = internalMutation({
|
||||
args: { rowIds: v.array(v.id("favorites")) },
|
||||
handler: async (ctx, { rowIds }) => {
|
||||
// Rows can disappear in between, e.g. when the scanner purges a song.
|
||||
for (const rowId of rowIds.slice(0, MAX_INLINE_DELETES)) {
|
||||
if (await ctx.db.get(rowId)) {
|
||||
await ctx.db.delete(rowId)
|
||||
}
|
||||
}
|
||||
const rest = rowIds.slice(MAX_INLINE_DELETES)
|
||||
if (rest.length > 0) {
|
||||
await ctx.scheduler.runAfter(0, internal.favoriteStore.deleteRows, {
|
||||
rowIds: rest,
|
||||
})
|
||||
}
|
||||
},
|
||||
})
|
||||
|
||||
/**
|
||||
* Moves a user's legacy favorite arrays into `favorites` rows, keeping their
|
||||
* order, then clears them. Safe to call repeatedly.
|
||||
*/
|
||||
export async function migrateUserFavorites(
|
||||
ctx: MutationCtx,
|
||||
user: Doc<"users">
|
||||
) {
|
||||
if (!hasLegacyFavorites(user)) {
|
||||
return
|
||||
}
|
||||
const legacy = legacyFavorites(user)
|
||||
await addFavorites(ctx, user._id, "song", legacy.favoriteSongs)
|
||||
await addFavorites(ctx, user._id, "album", legacy.favoriteAlbums)
|
||||
await addFavorites(ctx, user._id, "artist", legacy.favoriteArtists)
|
||||
await ctx.db.patch(user._id, {
|
||||
favoriteSongs: undefined,
|
||||
favoriteAlbums: undefined,
|
||||
favoriteArtists: undefined,
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Called before every favorites write, so a user toggling a favorite before
|
||||
* the boot migration reaches them does not end up with half their favorites
|
||||
* in rows and half on `users`.
|
||||
*/
|
||||
export async function requireMigratedFavorites(
|
||||
ctx: MutationCtx,
|
||||
userId: Id<"users">
|
||||
) {
|
||||
const user = await ctx.db.get(userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
await migrateUserFavorites(ctx, user)
|
||||
}
|
||||
|
||||
/** Removes deleted songs, albums or artists from every user's favorites. */
|
||||
export async function purgeFavoriteEntities(
|
||||
ctx: MutationCtx,
|
||||
ids: Iterable<FavoriteEntityId[FavoriteKind]>
|
||||
) {
|
||||
for (const entityId of ids) {
|
||||
const rows = await ctx.db
|
||||
.query("favorites")
|
||||
.withIndex("by_entity", (q) => q.eq("entityId", entityId))
|
||||
.collect()
|
||||
for (const row of rows) {
|
||||
await ctx.db.delete(row._id)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export async function deleteUserFavorites(
|
||||
ctx: MutationCtx,
|
||||
userId: Id<"users">
|
||||
) {
|
||||
const rows = await Promise.all(
|
||||
(["song", "album", "artist"] as const).map((kind) =>
|
||||
ctx.db
|
||||
.query("favorites")
|
||||
.withIndex("by_user_kind", (q) =>
|
||||
q.eq("userId", userId).eq("kind", kind)
|
||||
)
|
||||
.collect()
|
||||
)
|
||||
)
|
||||
await deleteFavoriteRows(
|
||||
ctx,
|
||||
rows.flat().map((row) => row._id)
|
||||
)
|
||||
}
|
||||
+111
-243
@@ -3,18 +3,26 @@ import { ConvexError, v } from "convex/values"
|
||||
import type { Doc, Id } from "./_generated/dataModel"
|
||||
import type { MutationCtx, QueryCtx } from "./_generated/server"
|
||||
import { mutation, query } from "./_generated/server"
|
||||
import type { BrowsePlaylistDetail, BrowsePlaylistSummary } from "./library"
|
||||
import {
|
||||
addFavorites,
|
||||
allFavorited,
|
||||
readFavorites,
|
||||
removeFavorites,
|
||||
requireMigratedFavorites,
|
||||
type FavoriteIdChunks,
|
||||
} from "./favoriteStore"
|
||||
import type { BrowsePlaylistSummary } from "./library"
|
||||
import { browseSongsFromIds } from "./library"
|
||||
import { chunk } from "./limits"
|
||||
import type { BrowseFavoritesDetail } from "./types"
|
||||
|
||||
function uniqueIds<T extends string>(ids: T[]): T[] {
|
||||
return [...new Set(ids)]
|
||||
}
|
||||
|
||||
async function requireAuth(ctx: MutationCtx) {
|
||||
/** Resolves the signed-in user and moves any legacy favorites into rows. */
|
||||
async function requireFavoritesUser(ctx: MutationCtx) {
|
||||
const userId = await getAuthUserId(ctx)
|
||||
if (userId === null) {
|
||||
throw new ConvexError("Not authenticated")
|
||||
}
|
||||
await requireMigratedFavorites(ctx, userId)
|
||||
return userId
|
||||
}
|
||||
|
||||
@@ -42,112 +50,46 @@ async function getSongIdsForArtist(ctx: QueryCtx, artistId: Id<"artists">) {
|
||||
return songs.map((song) => song._id)
|
||||
}
|
||||
|
||||
function allAlbumSongsFavorited(
|
||||
albumSongIds: Id<"songs">[],
|
||||
favoriteSongs: Id<"songs">[]
|
||||
) {
|
||||
if (albumSongIds.length === 0) {
|
||||
return false
|
||||
}
|
||||
const favorited = new Set(favoriteSongs)
|
||||
return albumSongIds.every((id) => favorited.has(id))
|
||||
}
|
||||
|
||||
function allArtistAlbumsFavorited(
|
||||
artistAlbumIds: Id<"albums">[],
|
||||
favoriteAlbums: Id<"albums">[]
|
||||
) {
|
||||
if (artistAlbumIds.length === 0) {
|
||||
return false
|
||||
}
|
||||
const favorited = new Set(favoriteAlbums)
|
||||
return artistAlbumIds.every((id) => favorited.has(id))
|
||||
}
|
||||
|
||||
async function promoteAlbumIfAllSongsFavorited(
|
||||
ctx: MutationCtx,
|
||||
favoriteSongs: Id<"songs">[],
|
||||
favoriteAlbums: Id<"albums">[],
|
||||
albumId: Id<"albums">
|
||||
) {
|
||||
const albumSongIds = await getSongIdsForAlbum(ctx, albumId)
|
||||
if (!allAlbumSongsFavorited(albumSongIds, favoriteSongs)) {
|
||||
return favoriteAlbums
|
||||
}
|
||||
return uniqueIds([...favoriteAlbums, albumId])
|
||||
}
|
||||
|
||||
async function promoteArtistIfAllAlbumsFavorited(
|
||||
ctx: MutationCtx,
|
||||
favoriteAlbums: Id<"albums">[],
|
||||
favoriteArtists: Id<"artists">[],
|
||||
userId: Id<"users">,
|
||||
artistId: Id<"artists">
|
||||
) {
|
||||
const artistAlbumIds = await getAlbumIdsForArtist(ctx, artistId)
|
||||
if (!allArtistAlbumsFavorited(artistAlbumIds, favoriteAlbums)) {
|
||||
return favoriteArtists
|
||||
const albumIds = await getAlbumIdsForArtist(ctx, artistId)
|
||||
if (await allFavorited(ctx, userId, "album", albumIds)) {
|
||||
await addFavorites(ctx, userId, "artist", [artistId])
|
||||
}
|
||||
return uniqueIds([...favoriteArtists, artistId])
|
||||
}
|
||||
|
||||
/** Favorites albums whose songs are now all favorited, then their artists. */
|
||||
async function cascadeUpFromSongs(
|
||||
ctx: MutationCtx,
|
||||
favoriteSongs: Id<"songs">[],
|
||||
favoriteAlbums: Id<"albums">[],
|
||||
favoriteArtists: Id<"artists">[],
|
||||
userId: Id<"users">,
|
||||
songs: Doc<"songs">[]
|
||||
) {
|
||||
let albums = favoriteAlbums
|
||||
let artists = favoriteArtists
|
||||
|
||||
const albumIds = new Set(songs.map((song) => song.album))
|
||||
for (const albumId of albumIds) {
|
||||
albums = await promoteAlbumIfAllSongsFavorited(
|
||||
ctx,
|
||||
favoriteSongs,
|
||||
albums,
|
||||
albumId
|
||||
)
|
||||
for (const albumId of new Set(songs.map((song) => song.album))) {
|
||||
const songIds = await getSongIdsForAlbum(ctx, albumId)
|
||||
if (await allFavorited(ctx, userId, "song", songIds)) {
|
||||
await addFavorites(ctx, userId, "album", [albumId])
|
||||
}
|
||||
}
|
||||
|
||||
const artistIds = new Set(songs.map((song) => song.albumArtist))
|
||||
for (const artistId of artistIds) {
|
||||
artists = await promoteArtistIfAllAlbumsFavorited(
|
||||
ctx,
|
||||
albums,
|
||||
artists,
|
||||
artistId
|
||||
)
|
||||
for (const artistId of new Set(songs.map((song) => song.albumArtist))) {
|
||||
await promoteArtistIfAllAlbumsFavorited(ctx, userId, artistId)
|
||||
}
|
||||
|
||||
return { favoriteAlbums: albums, favoriteArtists: artists }
|
||||
}
|
||||
|
||||
export const getUserFavorites = query({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
handler: async (ctx): Promise<FavoriteIdChunks> => {
|
||||
const userId = await getAuthUserId(ctx)
|
||||
if (userId === null) {
|
||||
return {
|
||||
favoriteSongs: [] as Id<"songs">[],
|
||||
favoriteAlbums: [] as Id<"albums">[],
|
||||
favoriteArtists: [] as Id<"artists">[],
|
||||
}
|
||||
return { favoriteSongs: [], favoriteAlbums: [], favoriteArtists: [] }
|
||||
}
|
||||
|
||||
const user = await ctx.db.get("users", userId)
|
||||
if (!user) {
|
||||
return {
|
||||
favoriteSongs: [] as Id<"songs">[],
|
||||
favoriteAlbums: [] as Id<"albums">[],
|
||||
favoriteArtists: [] as Id<"artists">[],
|
||||
}
|
||||
}
|
||||
|
||||
const favorites = await readFavorites(ctx, userId)
|
||||
return {
|
||||
favoriteSongs: user.favoriteSongs ?? [],
|
||||
favoriteAlbums: user.favoriteAlbums ?? [],
|
||||
favoriteArtists: user.favoriteArtists ?? [],
|
||||
favoriteSongs: chunk(favorites.favoriteSongs),
|
||||
favoriteAlbums: chunk(favorites.favoriteAlbums),
|
||||
favoriteArtists: chunk(favorites.favoriteArtists),
|
||||
}
|
||||
},
|
||||
})
|
||||
@@ -165,6 +107,7 @@ async function browseFavoritesSummaryHandler(
|
||||
return null
|
||||
}
|
||||
|
||||
const { favoriteSongs } = await readFavorites(ctx, userId)
|
||||
return {
|
||||
id: null,
|
||||
isFavorites: true,
|
||||
@@ -176,13 +119,13 @@ async function browseFavoritesSummaryHandler(
|
||||
cover: null,
|
||||
isOwner: true,
|
||||
isSubscribed: false,
|
||||
songIds: user.favoriteSongs ?? [],
|
||||
songIds: favoriteSongs,
|
||||
}
|
||||
}
|
||||
|
||||
export const browseFavoritesPlaylistDetail = query({
|
||||
args: {},
|
||||
handler: async (ctx): Promise<BrowsePlaylistDetail | null> => {
|
||||
handler: async (ctx): Promise<BrowseFavoritesDetail | null> => {
|
||||
const summary = await browseFavoritesSummaryHandler(ctx)
|
||||
if (!summary) {
|
||||
return null
|
||||
@@ -196,7 +139,7 @@ export const browseFavoritesPlaylistDetail = query({
|
||||
title: summary.title,
|
||||
owner: summary.owner,
|
||||
cover: summary.cover,
|
||||
songs,
|
||||
songs: chunk(songs),
|
||||
isOwner: summary.isOwner,
|
||||
isSubscribed: summary.isSubscribed,
|
||||
}
|
||||
@@ -206,69 +149,35 @@ export const browseFavoritesPlaylistDetail = query({
|
||||
export const favoriteSong = mutation({
|
||||
args: { songId: v.id("songs") },
|
||||
handler: async (ctx, { songId }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get("users", userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const userId = await requireFavoritesUser(ctx)
|
||||
const song = await ctx.db.get("songs", songId)
|
||||
if (!song) {
|
||||
throw new ConvexError("Song not found")
|
||||
}
|
||||
|
||||
const favoriteSongs = uniqueIds([...(user.favoriteSongs ?? []), songId])
|
||||
const cascaded = await cascadeUpFromSongs(
|
||||
ctx,
|
||||
favoriteSongs,
|
||||
user.favoriteAlbums ?? [],
|
||||
user.favoriteArtists ?? [],
|
||||
[song]
|
||||
)
|
||||
|
||||
await ctx.db.patch(userId, {
|
||||
favoriteSongs,
|
||||
favoriteAlbums: cascaded.favoriteAlbums,
|
||||
favoriteArtists: cascaded.favoriteArtists,
|
||||
})
|
||||
await addFavorites(ctx, userId, "song", [songId])
|
||||
await cascadeUpFromSongs(ctx, userId, [song])
|
||||
},
|
||||
})
|
||||
|
||||
export const favoriteSongs = mutation({
|
||||
args: { songIds: v.array(v.id("songs")) },
|
||||
handler: async (ctx, { songIds }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get("users", userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const uniqueRequestedIds = uniqueIds(songIds)
|
||||
const userId = await requireFavoritesUser(ctx)
|
||||
const loadedSongs = await Promise.all(
|
||||
uniqueRequestedIds.map((id) => ctx.db.get("songs", id))
|
||||
[...new Set(songIds)].map((id) => ctx.db.get("songs", id))
|
||||
)
|
||||
const songs = loadedSongs.filter(
|
||||
(song): song is Doc<"songs"> => song !== null
|
||||
)
|
||||
const validSongIds = songs.map((song) => song._id)
|
||||
|
||||
const favoriteSongs = uniqueIds([
|
||||
...(user.favoriteSongs ?? []),
|
||||
...validSongIds,
|
||||
])
|
||||
const cascaded = await cascadeUpFromSongs(
|
||||
await addFavorites(
|
||||
ctx,
|
||||
favoriteSongs,
|
||||
user.favoriteAlbums ?? [],
|
||||
user.favoriteArtists ?? [],
|
||||
songs
|
||||
userId,
|
||||
"song",
|
||||
songs.map((song) => song._id)
|
||||
)
|
||||
|
||||
await ctx.db.patch(userId, {
|
||||
favoriteSongs,
|
||||
favoriteAlbums: cascaded.favoriteAlbums,
|
||||
favoriteArtists: cascaded.favoriteArtists,
|
||||
})
|
||||
await cascadeUpFromSongs(ctx, userId, songs)
|
||||
},
|
||||
})
|
||||
|
||||
@@ -286,159 +195,118 @@ export const unfavoriteSongs = mutation({
|
||||
},
|
||||
})
|
||||
|
||||
/** Unfavorites songs along with their albums and artists. */
|
||||
async function unfavoriteSongsHandler(
|
||||
ctx: MutationCtx,
|
||||
songIds: Id<"songs">[]
|
||||
) {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get("users", userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const removeSongs = new Set(songIds)
|
||||
const userId = await requireFavoritesUser(ctx)
|
||||
const loadedSongs = await Promise.all(
|
||||
[...removeSongs].map((songId) => ctx.db.get("songs", songId))
|
||||
[...new Set(songIds)].map((songId) => ctx.db.get("songs", songId))
|
||||
)
|
||||
const removeAlbums = new Set(
|
||||
loadedSongs.flatMap((song) => (song ? [song.album] : []))
|
||||
)
|
||||
const removeArtists = new Set(
|
||||
loadedSongs.flatMap((song) => (song ? [song.albumArtist] : []))
|
||||
const songs = loadedSongs.filter(
|
||||
(song): song is Doc<"songs"> => song !== null
|
||||
)
|
||||
|
||||
await ctx.db.patch(userId, {
|
||||
favoriteSongs: (user.favoriteSongs ?? []).filter(
|
||||
(id) => !removeSongs.has(id)
|
||||
),
|
||||
favoriteAlbums: (user.favoriteAlbums ?? []).filter(
|
||||
(id) => !removeAlbums.has(id)
|
||||
),
|
||||
favoriteArtists: (user.favoriteArtists ?? []).filter(
|
||||
(id) => !removeArtists.has(id)
|
||||
),
|
||||
})
|
||||
await removeFavorites(ctx, userId, "song", songIds)
|
||||
await removeFavorites(
|
||||
ctx,
|
||||
userId,
|
||||
"album",
|
||||
songs.map((song) => song.album)
|
||||
)
|
||||
await removeFavorites(
|
||||
ctx,
|
||||
userId,
|
||||
"artist",
|
||||
songs.map((song) => song.albumArtist)
|
||||
)
|
||||
}
|
||||
|
||||
export const favoriteAlbum = mutation({
|
||||
args: { albumId: v.id("albums") },
|
||||
handler: async (ctx, { albumId }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get("users", userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const userId = await requireFavoritesUser(ctx)
|
||||
const album = await ctx.db.get("albums", albumId)
|
||||
if (!album) {
|
||||
throw new ConvexError("Album not found")
|
||||
}
|
||||
|
||||
const songIds = await getSongIdsForAlbum(ctx, albumId)
|
||||
|
||||
const favoriteAlbums = uniqueIds([...(user.favoriteAlbums ?? []), albumId])
|
||||
const favoriteSongs = uniqueIds([...(user.favoriteSongs ?? []), ...songIds])
|
||||
const favoriteArtists = await promoteArtistIfAllAlbumsFavorited(
|
||||
await addFavorites(ctx, userId, "album", [albumId])
|
||||
await addFavorites(
|
||||
ctx,
|
||||
favoriteAlbums,
|
||||
user.favoriteArtists ?? [],
|
||||
album.artist
|
||||
userId,
|
||||
"song",
|
||||
await getSongIdsForAlbum(ctx, albumId)
|
||||
)
|
||||
|
||||
await ctx.db.patch(userId, {
|
||||
favoriteAlbums,
|
||||
favoriteSongs,
|
||||
favoriteArtists,
|
||||
})
|
||||
await promoteArtistIfAllAlbumsFavorited(ctx, userId, album.artist)
|
||||
},
|
||||
})
|
||||
|
||||
/** Unfavorites an album along with its songs and artist. */
|
||||
export const unfavoriteAlbum = mutation({
|
||||
args: { albumId: v.id("albums") },
|
||||
handler: async (ctx, { albumId }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get("users", userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const userId = await requireFavoritesUser(ctx)
|
||||
const album = await ctx.db.get("albums", albumId)
|
||||
if (!album) {
|
||||
return
|
||||
}
|
||||
|
||||
const albumSongIds = await getSongIdsForAlbum(ctx, albumId)
|
||||
const removeSongs = new Set(albumSongIds)
|
||||
|
||||
const favoriteAlbums = (user.favoriteAlbums ?? []).filter(
|
||||
(id) => id !== albumId
|
||||
await removeFavorites(ctx, userId, "album", [albumId])
|
||||
await removeFavorites(ctx, userId, "artist", [album.artist])
|
||||
await removeFavorites(
|
||||
ctx,
|
||||
userId,
|
||||
"song",
|
||||
await getSongIdsForAlbum(ctx, albumId)
|
||||
)
|
||||
const favoriteSongs = (user.favoriteSongs ?? []).filter(
|
||||
(id) => !removeSongs.has(id)
|
||||
)
|
||||
let favoriteArtists = user.favoriteArtists ?? []
|
||||
|
||||
if (favoriteArtists.includes(album.artist)) {
|
||||
favoriteArtists = favoriteArtists.filter((id) => id !== album.artist)
|
||||
}
|
||||
|
||||
await ctx.db.patch(userId, {
|
||||
favoriteSongs,
|
||||
favoriteAlbums,
|
||||
favoriteArtists,
|
||||
})
|
||||
},
|
||||
})
|
||||
|
||||
/** Favorites an artist along with all of their albums and songs. */
|
||||
export const favoriteArtist = mutation({
|
||||
args: { artistId: v.id("artists") },
|
||||
handler: async (ctx, { artistId }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get("users", userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const userId = await requireFavoritesUser(ctx)
|
||||
const artist = await ctx.db.get("artists", artistId)
|
||||
if (!artist) {
|
||||
throw new ConvexError("Artist not found")
|
||||
}
|
||||
|
||||
const albumIds = await getAlbumIdsForArtist(ctx, artistId)
|
||||
const songIds = await getSongIdsForArtist(ctx, artistId)
|
||||
|
||||
await ctx.db.patch(userId, {
|
||||
favoriteArtists: uniqueIds([...(user.favoriteArtists ?? []), artistId]),
|
||||
favoriteAlbums: uniqueIds([...(user.favoriteAlbums ?? []), ...albumIds]),
|
||||
favoriteSongs: uniqueIds([...(user.favoriteSongs ?? []), ...songIds]),
|
||||
})
|
||||
await addFavorites(ctx, userId, "artist", [artistId])
|
||||
await addFavorites(
|
||||
ctx,
|
||||
userId,
|
||||
"album",
|
||||
await getAlbumIdsForArtist(ctx, artistId)
|
||||
)
|
||||
await addFavorites(
|
||||
ctx,
|
||||
userId,
|
||||
"song",
|
||||
await getSongIdsForArtist(ctx, artistId)
|
||||
)
|
||||
},
|
||||
})
|
||||
|
||||
/** Unfavorites an artist along with all of their albums and songs. */
|
||||
export const unfavoriteArtist = mutation({
|
||||
args: { artistId: v.id("artists") },
|
||||
handler: async (ctx, { artistId }) => {
|
||||
const userId = await requireAuth(ctx)
|
||||
const user = await ctx.db.get("users", userId)
|
||||
if (!user) {
|
||||
throw new ConvexError("User not found")
|
||||
}
|
||||
|
||||
const albumIds = await getAlbumIdsForArtist(ctx, artistId)
|
||||
const songIds = await getSongIdsForArtist(ctx, artistId)
|
||||
const removeAlbums = new Set(albumIds)
|
||||
const removeSongs = new Set(songIds)
|
||||
|
||||
await ctx.db.patch(userId, {
|
||||
favoriteArtists: (user.favoriteArtists ?? []).filter(
|
||||
(id) => id !== artistId
|
||||
),
|
||||
favoriteAlbums: (user.favoriteAlbums ?? []).filter(
|
||||
(id) => !removeAlbums.has(id)
|
||||
),
|
||||
favoriteSongs: (user.favoriteSongs ?? []).filter(
|
||||
(id) => !removeSongs.has(id)
|
||||
),
|
||||
})
|
||||
const userId = await requireFavoritesUser(ctx)
|
||||
await removeFavorites(ctx, userId, "artist", [artistId])
|
||||
await removeFavorites(
|
||||
ctx,
|
||||
userId,
|
||||
"album",
|
||||
await getAlbumIdsForArtist(ctx, artistId)
|
||||
)
|
||||
await removeFavorites(
|
||||
ctx,
|
||||
userId,
|
||||
"song",
|
||||
await getSongIdsForArtist(ctx, artistId)
|
||||
)
|
||||
},
|
||||
})
|
||||
@@ -21,6 +21,8 @@ import type {
|
||||
SearchTopResultItem,
|
||||
SidebarPlaylists,
|
||||
} from "./types"
|
||||
import { purgeFavoriteEntities } from "./favoriteStore"
|
||||
import { chunk, type Chunked } from "./limits"
|
||||
import { recordIntentCatalogChanges } from "./intentCatalogChanges"
|
||||
|
||||
export type {
|
||||
@@ -154,10 +156,19 @@ function toBrowseAlbum(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Past this many songs, scanning the library takes fewer reads than a get per
|
||||
* song, album and artist, which would hit Convex's 4,096 reads per function.
|
||||
*/
|
||||
const MAX_SONG_GETS = 1_000
|
||||
|
||||
export async function browseSongsFromIds(
|
||||
ctx: QueryCtx,
|
||||
songIds: Id<"songs">[]
|
||||
): Promise<BrowseSong[]> {
|
||||
if (songIds.length > MAX_SONG_GETS) {
|
||||
return browseSongsByScan(ctx, songIds)
|
||||
}
|
||||
const songs = await Promise.all(
|
||||
songIds.map((songId) => ctx.db.get("songs", songId))
|
||||
)
|
||||
@@ -167,6 +178,27 @@ export async function browseSongsFromIds(
|
||||
)
|
||||
}
|
||||
|
||||
async function browseSongsByScan(
|
||||
ctx: QueryCtx,
|
||||
songIds: Id<"songs">[]
|
||||
): Promise<BrowseSong[]> {
|
||||
const [songs, albums, artistMap] = await Promise.all([
|
||||
ctx.db.query("songs").collect(),
|
||||
ctx.db.query("albums").collect(),
|
||||
loadArtistMap(ctx),
|
||||
])
|
||||
const songMap = new Map(songs.map((song) => [song._id, song]))
|
||||
const albumMap = new Map(albums.map((album) => [album._id, album]))
|
||||
return songIds.flatMap((songId) => {
|
||||
const song = songMap.get(songId)
|
||||
const album = song && albumMap.get(song.album)
|
||||
const albumArtist = song && artistMap.get(song.albumArtist)
|
||||
return song && album && albumArtist
|
||||
? [toBrowseSong(song, album, albumArtist)]
|
||||
: []
|
||||
})
|
||||
}
|
||||
|
||||
async function browseSongDocs(
|
||||
ctx: QueryCtx,
|
||||
songs: Doc<"songs">[]
|
||||
@@ -214,32 +246,34 @@ function toBrowseSong(
|
||||
|
||||
export const browseAlbums = query({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
handler: async (ctx): Promise<Chunked<BrowseAlbum>> => {
|
||||
if (!(await isSignedIn(ctx))) {
|
||||
return []
|
||||
}
|
||||
const artistMap = await loadArtistMap(ctx)
|
||||
const albums = await ctx.db.query("albums").collect()
|
||||
|
||||
return albums
|
||||
.flatMap((album) => {
|
||||
const artist = artistMap.get(album.artist)
|
||||
return artist ? [toBrowseAlbum(album, artist)] : []
|
||||
})
|
||||
.sort((a, b) => a.title.localeCompare(b.title))
|
||||
return chunk(
|
||||
albums
|
||||
.flatMap((album) => {
|
||||
const artist = artistMap.get(album.artist)
|
||||
return artist ? [toBrowseAlbum(album, artist)] : []
|
||||
})
|
||||
.sort((a, b) => a.title.localeCompare(b.title))
|
||||
)
|
||||
},
|
||||
})
|
||||
|
||||
export const browseArtists = query({
|
||||
args: {},
|
||||
handler: async (ctx) => {
|
||||
handler: async (ctx): Promise<Chunked<BrowseArtist>> => {
|
||||
if (!(await isSignedIn(ctx))) {
|
||||
return []
|
||||
}
|
||||
const artists = await ctx.db.query("artists").collect()
|
||||
return artists
|
||||
.map(toBrowseArtist)
|
||||
.sort((a, b) => a.name.localeCompare(b.name))
|
||||
return chunk(
|
||||
artists.map(toBrowseArtist).sort((a, b) => a.name.localeCompare(b.name))
|
||||
)
|
||||
},
|
||||
})
|
||||
|
||||
@@ -508,7 +542,9 @@ export const browseSortedSongIds = query({
|
||||
},
|
||||
handler: async (ctx, args) => {
|
||||
await requireSignedIn(ctx)
|
||||
return getSortedLibrarySongIds(ctx, args.sortKey, args.sortDirection)
|
||||
return chunk(
|
||||
await getSortedLibrarySongIds(ctx, args.sortKey, args.sortDirection)
|
||||
)
|
||||
},
|
||||
})
|
||||
|
||||
@@ -605,6 +641,12 @@ function matchScoreSongArtists(
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Results kept per search section. Broad queries like "a" match most of the
|
||||
* library, which would overflow Convex's array limit and is too long to scroll.
|
||||
*/
|
||||
const MAX_SEARCH_RESULTS = 500
|
||||
|
||||
export const searchLibrary = query({
|
||||
args: { query: v.string() },
|
||||
handler: async (ctx, args) => {
|
||||
@@ -700,9 +742,15 @@ export const searchLibrary = query({
|
||||
|
||||
const result: LibrarySearchResults = {
|
||||
topResults,
|
||||
artists: artistResults.map((result) => result.item),
|
||||
albums: albumResults.map((result) => result.item),
|
||||
songs: songResults.map((result) => result.item),
|
||||
artists: artistResults
|
||||
.slice(0, MAX_SEARCH_RESULTS)
|
||||
.map((result) => result.item),
|
||||
albums: albumResults
|
||||
.slice(0, MAX_SEARCH_RESULTS)
|
||||
.map((result) => result.item),
|
||||
songs: songResults
|
||||
.slice(0, MAX_SEARCH_RESULTS)
|
||||
.map((result) => result.item),
|
||||
}
|
||||
return result
|
||||
},
|
||||
@@ -710,7 +758,7 @@ export const searchLibrary = query({
|
||||
|
||||
export const browseRecentlyAdded = query({
|
||||
args: { limit: v.optional(v.number()) },
|
||||
handler: async (ctx, args) => {
|
||||
handler: async (ctx, args): Promise<Chunked<BrowseAlbum>> => {
|
||||
if (!(await isSignedIn(ctx))) {
|
||||
return []
|
||||
}
|
||||
@@ -723,10 +771,12 @@ export const browseRecentlyAdded = query({
|
||||
albums.map((album) => album.artist)
|
||||
)
|
||||
|
||||
return albums.flatMap((album) => {
|
||||
const artist = artistMap.get(album.artist)
|
||||
return artist ? [toBrowseAlbum(album, artist)] : []
|
||||
})
|
||||
return chunk(
|
||||
albums.flatMap((album) => {
|
||||
const artist = artistMap.get(album.artist)
|
||||
return artist ? [toBrowseAlbum(album, artist)] : []
|
||||
})
|
||||
)
|
||||
},
|
||||
})
|
||||
|
||||
@@ -1161,7 +1211,10 @@ async function purgeSongsFromUsersAndPlaylists(
|
||||
}
|
||||
}
|
||||
|
||||
// Legacy queue fields stay until `migrations.migrateUsers` clears them.
|
||||
await purgeFavoriteEntities(ctx, remove)
|
||||
|
||||
// Legacy favorite and queue fields stay until `migrations.migrateUsers`
|
||||
// clears them.
|
||||
for (const user of await ctx.db.query("users").collect()) {
|
||||
const favoriteSongs = user.favoriteSongs
|
||||
const songQueue = user.songQueue
|
||||
@@ -1202,6 +1255,9 @@ async function purgeAlbumsFromUsers(
|
||||
return
|
||||
}
|
||||
|
||||
await purgeFavoriteEntities(ctx, remove)
|
||||
|
||||
// Legacy `favoriteAlbums` stays until `migrations.migrateUsers` clears it.
|
||||
for (const user of await ctx.db.query("users").collect()) {
|
||||
const favoriteAlbums = user.favoriteAlbums
|
||||
const recentlyPlayed = user.recentlyPlayed
|
||||
@@ -1232,6 +1288,9 @@ async function purgeArtistsFromUsers(
|
||||
return
|
||||
}
|
||||
|
||||
await purgeFavoriteEntities(ctx, remove)
|
||||
|
||||
// Legacy `favoriteArtists` stays until `migrations.migrateUsers` clears it.
|
||||
for (const user of await ctx.db.query("users").collect()) {
|
||||
const favoriteArtists = user.favoriteArtists
|
||||
if (favoriteArtists?.some((artistId) => remove.has(artistId))) {
|
||||
|
||||
@@ -8,3 +8,20 @@ export const MAX_QUEUE_LENGTH = 5_000
|
||||
|
||||
/** Largest profile photo accepted, in bytes after base64 decoding. */
|
||||
export const MAX_PROFILE_IMAGE_BYTES = 2 * 1024 * 1024
|
||||
|
||||
/** Most values Convex accepts in a single array. */
|
||||
export const MAX_ARRAY_LENGTH = 8_192
|
||||
|
||||
/**
|
||||
* A list split into arrays of at most `MAX_ARRAY_LENGTH` values, so a query can
|
||||
* return more than one array allows. Read it back with `.flat()`.
|
||||
*/
|
||||
export type Chunked<T> = T[][]
|
||||
|
||||
export function chunk<T>(items: readonly T[]): Chunked<T> {
|
||||
const chunks: Chunked<T> = []
|
||||
for (let start = 0; start < items.length; start += MAX_ARRAY_LENGTH) {
|
||||
chunks.push(items.slice(start, start + MAX_ARRAY_LENGTH))
|
||||
}
|
||||
return chunks
|
||||
}
|
||||
@@ -1,13 +1,15 @@
|
||||
import { v } from "convex/values"
|
||||
import { internal } from "./_generated/api"
|
||||
import { internalMutation } from "./_generated/server"
|
||||
import { hasLegacyFavorites, migrateUserFavorites } from "./favoriteStore"
|
||||
import { hasLegacyPlayback, migrateUserPlayback } from "./playbackState"
|
||||
|
||||
const BATCH_SIZE = 25
|
||||
|
||||
/**
|
||||
* Moves playback state off `users` into `playbackStates`/`playbackProgress`
|
||||
* and legacy data URL avatars into file storage. Idempotent; the Docker
|
||||
* Moves playback state off `users` into `playbackStates`/`playbackProgress`,
|
||||
* favorite arrays into `favorites` rows, and legacy data URL avatars into
|
||||
* file storage. Idempotent; the Docker
|
||||
* entrypoint runs it on every boot. Run manually with
|
||||
* `npx convex run migrations:migrateUsers`.
|
||||
*/
|
||||
@@ -22,6 +24,12 @@ export const migrateUsers = internalMutation({
|
||||
if (hasLegacyPlayback(user)) {
|
||||
await migrateUserPlayback(ctx, user)
|
||||
}
|
||||
if (hasLegacyFavorites(user)) {
|
||||
// One mutation per user: a large library can mean thousands of rows.
|
||||
await ctx.scheduler.runAfter(0, internal.migrations.migrateFavorites, {
|
||||
userId: user._id,
|
||||
})
|
||||
}
|
||||
if (!user.imageStorageId && user.image?.startsWith("data:")) {
|
||||
await ctx.scheduler.runAfter(0, internal.users.storeProfileImage, {
|
||||
userId: user._id,
|
||||
@@ -37,3 +45,14 @@ export const migrateUsers = internalMutation({
|
||||
}
|
||||
},
|
||||
})
|
||||
|
||||
/** Moves one user's favorites into rows. Scheduled by `migrateUsers`. */
|
||||
export const migrateFavorites = internalMutation({
|
||||
args: { userId: v.id("users") },
|
||||
handler: async (ctx, { userId }) => {
|
||||
const user = await ctx.db.get(userId)
|
||||
if (user) {
|
||||
await migrateUserFavorites(ctx, user)
|
||||
}
|
||||
},
|
||||
})
|
||||
@@ -3,6 +3,7 @@ import { ConvexError, v } from "convex/values"
|
||||
import type { Doc, Id } from "./_generated/dataModel"
|
||||
import type { MutationCtx, QueryCtx } from "./_generated/server"
|
||||
import { mutation, query } from "./_generated/server"
|
||||
import { chunk } from "./limits"
|
||||
import type {
|
||||
BrowsePlaylistDetail,
|
||||
BrowsePlaylistSummary,
|
||||
@@ -290,7 +291,7 @@ export const getArtistSongIds = query({
|
||||
.query("songs")
|
||||
.withIndex("by_artist", (q) => q.eq("albumArtist", args.artistId))
|
||||
.collect()
|
||||
return songs.map((song) => song._id)
|
||||
return chunk(songs.map((song) => song._id))
|
||||
},
|
||||
})
|
||||
|
||||
@@ -321,7 +322,7 @@ export const getOrderedArtistSongIds = query({
|
||||
return a.name.localeCompare(b.name)
|
||||
})
|
||||
|
||||
return songs.map((song) => song._id)
|
||||
return chunk(songs.map((song) => song._id))
|
||||
},
|
||||
})
|
||||
|
||||
|
||||
@@ -27,6 +27,8 @@ export default defineSchema({
|
||||
),
|
||||
preferAtmos: v.optional(v.boolean()),
|
||||
subscribedPlaylists: v.optional(v.array(v.id("playlists"))),
|
||||
// Legacy favorites, now rows in `favorites`. `migrations.migrateUsers`
|
||||
// clears them; drop them once every deployment has run it.
|
||||
favoriteArtists: v.optional(v.array(v.id("artists"))),
|
||||
favoriteAlbums: v.optional(v.array(v.id("albums"))),
|
||||
favoriteSongs: v.optional(v.array(v.id("songs"))),
|
||||
@@ -58,6 +60,31 @@ export default defineSchema({
|
||||
songId: v.optional(v.id("songs")),
|
||||
progressSeconds: v.number(),
|
||||
}).index("by_user", ["userId"]),
|
||||
// One row per favorite. `by_user_kind` lists them in the order they were
|
||||
// favorited (the Favorites playlist order), `by_user_entity` answers "is this
|
||||
// favorited", and `by_entity` lets the scanner purge deleted media.
|
||||
favorites: defineTable(
|
||||
v.union(
|
||||
v.object({
|
||||
userId: v.id("users"),
|
||||
kind: v.literal("song"),
|
||||
entityId: v.id("songs"),
|
||||
}),
|
||||
v.object({
|
||||
userId: v.id("users"),
|
||||
kind: v.literal("album"),
|
||||
entityId: v.id("albums"),
|
||||
}),
|
||||
v.object({
|
||||
userId: v.id("users"),
|
||||
kind: v.literal("artist"),
|
||||
entityId: v.id("artists"),
|
||||
})
|
||||
)
|
||||
)
|
||||
.index("by_user_kind", ["userId", "kind"])
|
||||
.index("by_user_entity", ["userId", "entityId"])
|
||||
.index("by_entity", ["entityId"]),
|
||||
authVerifiers: defineTable({
|
||||
sessionId: v.optional(v.id("authSessions")),
|
||||
signature: v.optional(v.string()),
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import type { Id } from "./_generated/dataModel"
|
||||
import type { Chunked } from "./limits"
|
||||
|
||||
export type BrowseArtist = {
|
||||
id: Id<"artists">
|
||||
@@ -75,6 +76,11 @@ export type BrowsePlaylistDetail = {
|
||||
isSubscribed: boolean
|
||||
}
|
||||
|
||||
/** Favorites can outgrow one array, so its songs come back chunked. */
|
||||
export type BrowseFavoritesDetail = Omit<BrowsePlaylistDetail, "songs"> & {
|
||||
songs: Chunked<BrowseSong>
|
||||
}
|
||||
|
||||
export type BrowsePlaylistSummary = Omit<BrowsePlaylistDetail, "songs"> & {
|
||||
songIds: Id<"songs">[]
|
||||
}
|
||||
|
||||
@@ -16,6 +16,7 @@ import {
|
||||
import type { Doc, Id } from "./_generated/dataModel"
|
||||
import type { ActionCtx, MutationCtx } from "./_generated/server"
|
||||
import { MAX_PROFILE_IMAGE_BYTES } from "./limits"
|
||||
import { deleteUserFavorites } from "./favoriteStore"
|
||||
import { deleteUserPlayback } from "./playbackState"
|
||||
|
||||
const playbackQualityValidator = v.union(
|
||||
@@ -400,6 +401,7 @@ export const deleteUser = mutation({
|
||||
}
|
||||
await deleteOwnedPlaylists(ctx, userId)
|
||||
await deleteUserPlayback(ctx, userId)
|
||||
await deleteUserFavorites(ctx, userId)
|
||||
await setProfileImage(ctx, userId, null)
|
||||
await deleteUserAuthData(ctx, userId)
|
||||
},
|
||||
|
||||
Reference in new issue
Block a user