feat: playlist cover artwork

Playlists draw a 2x2 of their first albums automatically. Owners can pick
from random grids, reshuffle, or upload an image on web and mobile.
Covers are rendered once into Convex storage and redrawn only when the
playlist's albums change. Web and iPad sidebars show playlist covers.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
joshuafhigginsandClaude Opus 5.5 committed 2026-11-19 18:11:59 -05:00 Verified
1 parent 76409b9c3e
commit 86235a11c4
34 files changed
+1459 -92

No files matched your search

@@ -68,6 +68,7 @@ const OWNER_MENU_ACTIONS: MediaAction[] = [
"play-last",
"shuffle",
"favorite",
"change-cover",
"delete-playlist",
]
@@ -83,7 +84,11 @@ export default function PlaylistScreen() {
const songs = playlist?.songs
const coverUri =
config && playlistId
? playlistCoverUrl(config.serverUrl, playlist?.id ?? playlistId)
? playlistCoverUrl(
config.serverUrl,
playlist?.id ?? playlistId,
playlist?.cover ?? null
)
: ""
const { palette: artworkPalette, settled } = useCoverPalette(
coverUri,
@@ -261,6 +266,15 @@ function PlaylistContent({
void handleDelete()
return
}
if (action === "change-cover") {
if (playlistId) {
router.push({
pathname: "/playlist-cover",
params: { id: playlistId },
})
}
return
}
void handlePlaylistDetailAction(songIds, action)
}
+16
View File
@@ -106,6 +106,22 @@ export default function AppLayout() {
contentStyle: { backgroundColor: "#000" },
}}
/>
<Stack.Screen
name="playlist-cover"
options={{
title: "Cover",
headerTitleAlign: "center",
presentation:
Platform.OS === "ios" ? "modal" : "fullScreenModal",
animation: "slide_from_bottom",
headerLargeTitle: false,
headerTransparent: false,
headerShadowVisible: false,
headerStyle: { backgroundColor: "#000" },
headerTintColor: "#fff",
contentStyle: { backgroundColor: "#000" },
}}
/>
<Stack.Screen
name="player"
options={{
+391
View File
@@ -0,0 +1,391 @@
import { useMutation } from "convex/react"
import { Image } from "expo-image"
import * as ImagePicker from "expo-image-picker"
import { router, Stack, useLocalSearchParams } from "expo-router"
import { useMemo, useState, type ReactNode } from "react"
import {
Pressable,
ScrollView,
StyleSheet,
Text,
useWindowDimensions,
View,
} from "react-native"
import { CoverImage } from "@/components/cover-image"
import { Button, LoadingView } from "@/components/ui/primitives"
import { useServerConfig } from "@/contexts/server-config"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { showError } from "@/lib/toast"
import { albumCoverUrl, playlistCoverUrl } from "@/lib/urls"
import { radius, spacing, useThemeColors } from "@/lib/theme"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import {
COVER_GRID_ALBUMS,
playlistCoverAlbums,
randomPlaylistCovers,
} from "@otunes/convex/client/playlist-cover"
type Choice =
| { kind: "current" }
| { kind: "albums"; albumIds: Id<"albums">[] }
| { kind: "upload"; uri: string; image: string }
const STRIP_GAP = spacing.sm
/** Selection border and padding around each thumb, both sides. */
const THUMB_CHROME = 6
/**
* Full screen cover editor for a playlist owner: a large preview of the
* selected cover, the current cover pinned apart from four random album
* grids, and Save in the header. Opened from the playlist's menu.
*/
export default function PlaylistCoverScreen() {
const { id } = useLocalSearchParams<{ id: string }>()
const playlistId = id as Id<"playlists">
const playlist = useCachedQuery(api.playlists.browsePlaylistDetail, {
id: playlistId,
})
const { config } = useServerConfig()
const colors = useThemeColors()
const { width } = useWindowDimensions()
const setCoverAlbums = useMutation(api.playlists.setPlaylistCoverAlbums)
const uploadCover = useMutation(api.playlists.uploadPlaylistCover)
const albums = useMemo(
() => (playlist ? playlistCoverAlbums(playlist.songs) : []),
[playlist]
)
const [options, setOptions] = useState<Id<"albums">[][] | null>(null)
const [selected, setSelected] = useState<Choice | null>(null)
const [saving, setSaving] = useState(false)
// Draw options once the songs arrive.
if (options === null && playlist) {
setOptions(randomPlaylistCovers(albums))
}
const hasCurrent = playlist?.cover != null
const choice: Choice | null =
selected ??
(hasCurrent
? { kind: "current" }
: options?.[0]
? { kind: "albums", albumIds: options[0] }
: null)
async function pickImage() {
const result = await ImagePicker.launchImageLibraryAsync({
mediaTypes: ["images"],
allowsEditing: true,
aspect: [1, 1],
quality: 0.7,
base64: true,
})
const asset = result.canceled ? undefined : result.assets[0]
if (!asset?.base64) return
setSelected({
kind: "upload",
uri: asset.uri,
image: `data:${asset.mimeType ?? "image/jpeg"};base64,${asset.base64}`,
})
}
async function save() {
if (!choice || choice.kind === "current") {
router.back()
return
}
setSaving(true)
try {
if (choice.kind === "albums") {
await setCoverAlbums({ playlistId, albumIds: choice.albumIds })
} else {
await uploadCover({ playlistId, image: choice.image })
}
router.back()
} catch (error) {
showError(
error instanceof Error ? error.message : "Failed to change cover"
)
setSaving(false)
}
}
const header = (
<Stack.Screen
options={{
headerLeft: () => (
<HeaderButton label="Cancel" onPress={() => router.back()} />
),
headerRight: () => (
<HeaderButton
label="Save"
bold
disabled={saving || !choice}
onPress={() => void save()}
/>
),
}}
/>
)
if (!playlist || !config || !options) {
return (
<>
{header}
<LoadingView />
</>
)
}
const serverUrl = config.serverUrl
const currentUri = playlistCoverUrl(serverUrl, playlistId, playlist.cover)
const previewSize = Math.min(width - spacing.lg * 2, 360)
// One row: current | uploaded? | options, thumbs at most 72pt.
const thumbCount =
options.length + (hasCurrent ? 1 : 0) + (choice?.kind === "upload" ? 1 : 0)
const rowItems = thumbCount + (hasCurrent ? 1 : 0)
const thumbSize = Math.min(
72,
Math.floor(
(width - spacing.lg * 2 - STRIP_GAP * (rowItems - 1) - 1) /
Math.max(thumbCount, 1)
) - THUMB_CHROME
)
function renderChoice(item: Choice, size: number) {
if (item.kind === "current") {
return (
<CoverImage
uri={currentUri}
hasCover
style={{ width: size, height: size }}
/>
)
}
if (item.kind === "upload") {
return (
<Image
source={{ uri: item.uri }}
style={{ width: size, height: size }}
/>
)
}
return (
<AlbumGrid serverUrl={serverUrl} albumIds={item.albumIds} size={size} />
)
}
const isSelected = (item: Choice) =>
choice?.kind === item.kind &&
(item.kind !== "albums" ||
(choice.kind === "albums" && choice.albumIds === item.albumIds))
return (
<ScrollView
style={{ backgroundColor: colors.background }}
contentContainerStyle={styles.content}
>
{header}
<View
style={[
styles.preview,
{
width: previewSize,
height: previewSize,
backgroundColor: colors.coverPlaceholder,
},
]}
>
{choice ? renderChoice(choice, previewSize) : null}
</View>
<View style={styles.strip}>
{hasCurrent ? (
<>
<Thumb
size={thumbSize}
selected={isSelected({ kind: "current" })}
label="Current cover"
onPress={() => setSelected({ kind: "current" })}
>
{renderChoice({ kind: "current" }, thumbSize)}
</Thumb>
<View
style={[styles.separator, { backgroundColor: colors.border }]}
/>
</>
) : null}
{choice?.kind === "upload" ? (
<Thumb size={thumbSize} selected label="Uploaded image">
{renderChoice(choice, thumbSize)}
</Thumb>
) : null}
{options.map((albumIds) => {
const item: Choice = { kind: "albums", albumIds }
return (
<Thumb
key={albumIds.join(",")}
size={thumbSize}
selected={isSelected(item)}
label="Album cover option"
onPress={() => setSelected(item)}
>
{renderChoice(item, thumbSize)}
</Thumb>
)
})}
</View>
{albums.length === 0 ? (
<Text style={{ color: colors.mutedForeground, textAlign: "center" }}>
No album artwork in this playlist yet.
</Text>
) : null}
<View style={styles.actions}>
{albums.length >= COVER_GRID_ALBUMS ? (
<Button
title="Shuffle"
icon="shuffle"
variant="secondary"
onPress={() => {
setOptions(randomPlaylistCovers(albums))
if (selected?.kind === "albums") setSelected(null)
}}
/>
) : null}
<Button
title="Upload"
icon="arrow-up"
variant="secondary"
onPress={() => void pickImage()}
/>
</View>
</ScrollView>
)
}
function HeaderButton({
label,
bold = false,
disabled = false,
onPress,
}: {
label: string
bold?: boolean
disabled?: boolean
onPress: () => void
}) {
const colors = useThemeColors()
return (
<Pressable
accessibilityRole="button"
hitSlop={8}
disabled={disabled}
onPress={onPress}
style={{ opacity: disabled ? 0.4 : 1, paddingHorizontal: spacing.xs }}
>
<Text
style={{
color: colors.foreground,
fontSize: 17,
fontWeight: bold ? "600" : "400",
}}
>
{label}
</Text>
</Pressable>
)
}
function Thumb({
size,
selected,
label,
onPress,
children,
}: {
size: number
selected: boolean
label: string
onPress?: () => void
children: ReactNode
}) {
const colors = useThemeColors()
return (
<Pressable
accessibilityRole="button"
accessibilityLabel={label}
accessibilityState={{ selected }}
onPress={onPress}
style={[
styles.thumb,
{
width: size + THUMB_CHROME,
height: size + THUMB_CHROME,
borderColor: selected ? colors.foreground : "transparent",
},
]}
>
<View style={styles.thumbInner}>{children}</View>
</Pressable>
)
}
/** A generated cover option: one album alone, or four tiled 2x2. */
function AlbumGrid({
serverUrl,
albumIds,
size,
}: {
serverUrl: string
albumIds: Id<"albums">[]
size: number
}) {
const tile = albumIds.length > 1 ? size / 2 : size
return (
<View
style={{
width: size,
height: size,
flexDirection: "row",
flexWrap: "wrap",
}}
>
{albumIds.map((albumId) => (
<CoverImage
key={albumId}
uri={albumCoverUrl(serverUrl, albumId)}
hasCover
style={{ width: tile, height: tile }}
/>
))}
</View>
)
}
const styles = StyleSheet.create({
content: {
alignItems: "center",
gap: spacing.xl,
padding: spacing.lg,
},
preview: { borderRadius: radius.lg, overflow: "hidden" },
strip: {
flexDirection: "row",
alignItems: "center",
justifyContent: "center",
gap: STRIP_GAP,
},
separator: { width: StyleSheet.hairlineWidth, alignSelf: "stretch" },
thumb: {
borderWidth: 2,
borderRadius: radius.sm + 2,
padding: 1,
},
thumbInner: { flex: 1, borderRadius: radius.sm, overflow: "hidden" },
actions: { flexDirection: "row", gap: spacing.sm },
})
+5 -1
View File
@@ -200,7 +200,11 @@ export const PlaylistCard = memo(function PlaylistCard({
<Link.AppleZoom>
<View collapsable={false}>
<CoverImage
uri={playlistCoverUrl(config.serverUrl, playlist.id)}
uri={playlistCoverUrl(
config.serverUrl,
playlist.id,
playlist.cover
)}
hasCover={playlist.cover != null}
style={
fluid
@@ -33,6 +33,7 @@ export type MediaAction =
| "go-artist"
| "go-album"
| "remove-from-playlist"
| "change-cover"
| "delete-playlist"
export type MediaNavigation = {
@@ -128,6 +129,11 @@ const MEDIA_ACTION_ITEMS: {
image: "minus.circle",
destructive: true,
},
{
action: "change-cover",
label: () => "Change Cover",
image: "photo",
},
{
action: "delete-playlist",
label: () => "Delete Playlist",
@@ -151,7 +157,7 @@ function isActionIncluded(
return config.includeActions.includes(action)
}
if (action === "delete-playlist") {
if (action === "delete-playlist" || action === "change-cover") {
return false
}
@@ -26,6 +26,7 @@ const actionIcons = {
"go-artist": "person-outline",
"go-album": "disc-outline",
"remove-from-playlist": "remove-circle-outline",
"change-cover": "image-outline",
"delete-playlist": "trash-outline",
} satisfies Record<MediaAction, ComponentProps<typeof Ionicons>["name"]>
+34 -1
View File
@@ -1,13 +1,19 @@
import { useOpenSettings } from "@/hooks/use-open-settings"
import { requireNativeView } from "expo"
import { useIsFocused } from "expo-router"
import { useIsFocused, useRouter } from "expo-router"
import { useMemo } from "react"
import { Platform, type ViewProps } from "react-native"
import { useServerConfig } from "@/contexts/server-config"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { useProfileImageUrl } from "@/hooks/use-profile-image-url"
import { tabPath } from "@/lib/app-navigation"
import { initialsFromName } from "@/lib/format"
import { playlistCoverUrl } from "@/lib/urls"
import { api } from "@otunes/convex/_generated/api"
type SidebarPlaylist = { id: string; title: string; imageURL?: string }
const NativeSidebar =
Platform.OS === "ios"
? requireNativeView<
@@ -16,16 +22,39 @@ const NativeSidebar =
initials: string
imageURL?: string
active: boolean
playlists: SidebarPlaylist[]
onProfilePress: () => void
onPlaylistPress: (event: { nativeEvent: { id: string } }) => void
}
>("TabletSidebar")
: null
/** iPad sidebar extras: the account footer and a row per playlist with its cover. */
export function TabletSidebar() {
const user = useCachedQuery(api.auth.currentUser)
const sidebarPlaylists = useCachedQuery(api.playlists.listSidebarPlaylists)
const { config } = useServerConfig()
const imageUrl = useProfileImageUrl(user?.image)
const openSettings = useOpenSettings()
const router = useRouter()
const active = useIsFocused()
const serverUrl = config?.serverUrl
const playlists = useMemo(
() =>
[
...(sidebarPlaylists?.owned ?? []),
...(sidebarPlaylists?.subscribed ?? []),
].map((playlist): SidebarPlaylist => ({
id: playlist.id,
title: playlist.title,
imageURL:
serverUrl && playlist.cover
? playlistCoverUrl(serverUrl, playlist.id, playlist.cover, 64)
: undefined,
})),
[serverUrl, sidebarPlaylists]
)
if (!NativeSidebar) return null
return (
@@ -35,7 +64,11 @@ export function TabletSidebar() {
initials={initialsFromName(user?.name ?? "Me")}
imageURL={imageUrl}
active={active}
playlists={playlists}
onProfilePress={openSettings}
onPlaylistPress={({ nativeEvent }) =>
router.navigate(tabPath("(playlists)", `/playlist/${nativeEvent.id}`))
}
/>
)
}
+4 -1
View File
@@ -39,12 +39,15 @@ export function albumCoverUrl(
return sizedCoverUrl(`${serverUrl}/api/album/${albumId}/cover`, size)
}
/** `version` is the summary's `cover`; it changes with the artwork. */
export function playlistCoverUrl(
serverUrl: string,
playlistId: string,
version: string | null,
size?: CoverImageSize
) {
return sizedCoverUrl(`${serverUrl}/api/playlist/${playlistId}/cover`, size)
const uri = `${serverUrl}/api/playlist/${playlistId}/cover`
return sizedCoverUrl(version ? `${uri}?v=${version}` : uri, size)
}
export function songAudioSource(
+117 -1
View File
@@ -5,7 +5,11 @@ final class TabletSidebar: Module {
public func definition() -> ExpoModulesCore.ModuleDefinition {
Name("TabletSidebar")
View(TabletSidebarView.self) {
Events("onProfilePress")
Events("onProfilePress", "onPlaylistPress")
Prop("playlists") { (view: TabletSidebarView, value: [SidebarPlaylist]) in
view.playlists = value
view.configure()
}
Prop("accountName") { (view: TabletSidebarView, value: String) in
view.accountName = value
view.configure()
@@ -26,9 +30,23 @@ final class TabletSidebar: Module {
}
}
/// A playlist row under the sidebar's Playlists section.
struct SidebarPlaylist: Record {
@Field var id: String = ""
@Field var title: String = ""
/// Cover URL; changes whenever the artwork does. `nil` shows a list icon.
@Field var imageURL: String?
}
/// Adds UIKit sidebar features not yet exposed by Expo Router's native tabs.
final class TabletSidebarView: ExpoView {
let onProfilePress = EventDispatcher()
let onPlaylistPress = EventDispatcher()
var playlists: [SidebarPlaylist] = []
private let selectionProxy = SidebarSelectionProxy()
private var playlistTabs: [String: UITab] = [:]
private var coverImages: [String: UIImage] = [:]
private var coverTasks: [String: URLSessionDataTask] = [:]
var accountName = ""
var initials = ""
var imageURL: String?
@@ -82,11 +100,13 @@ final class TabletSidebarView: ExpoView {
deinit {
if let tabsObserver { NotificationCenter.default.removeObserver(tabsObserver) }
coverTasks.values.forEach { $0.cancel() }
}
@available(iOS 18.0, *)
private func configure(_ controller: UITabBarController) {
configureGroups(controller)
configurePlaylists(controller)
let footer: SidebarAccountButton
if let existing = controller.sidebar.bottomBarView as? SidebarAccountButton {
@@ -103,6 +123,7 @@ final class TabletSidebarView: ExpoView {
@available(iOS 18.0, *)
private func configureTabBar(_ controller: UITabBarController, footer: SidebarAccountButton) {
let destinations = controller.tabs.compactMap { $0 as? UITabGroup }.flatMap { $0.children }
.filter { !$0.identifier.hasPrefix(playlistTabPrefix) }
let selected = destinations.first { $0 === controller.selectedTab }
let contextualTab = selected ?? footer.contextualTab ?? destinations.first
footer.contextualTab = contextualTab
@@ -160,6 +181,101 @@ final class TabletSidebarView: ExpoView {
}
}
private let playlistTabPrefix = "otunes.playlist."
private let playlistIconSize: CGFloat = 24
extension TabletSidebarView {
/// Lists each playlist under Playlists with its cover. Rows are never
/// selected natively: a tap opens the playlist in the All Playlists stack.
@available(iOS 18.0, *)
fileprivate func configurePlaylists(_ controller: UITabBarController) {
guard let group = controller.tabs.first(where: { $0.identifier == "otunes.playlists" })
as? UITabGroup else { return }
if !(controller.delegate is SidebarSelectionProxy) {
selectionProxy.original = controller.delegate
controller.delegate = selectionProxy
}
selectionProxy.onPlaylist = { [weak self] id in self?.onPlaylistPress(["id": id]) }
var rows: [UITab] = []
for playlist in playlists {
let identifier = playlistTabPrefix + playlist.id
let tab = playlistTabs[identifier] ?? UITab(
title: playlist.title, image: nil, identifier: identifier,
viewControllerProvider: { _ in UIViewController() })
playlistTabs[identifier] = tab
if tab.title != playlist.title { tab.title = playlist.title }
tab.preferredPlacement = .sidebarOnly
tab.image = playlistImage(identifier: identifier, url: playlist.imageURL)
rows.append(tab)
}
let ids = Set(rows.map(\.identifier))
playlistTabs = playlistTabs.filter { ids.contains($0.key) }
let fixed = group.children.filter { !$0.identifier.hasPrefix(playlistTabPrefix) }
let children = fixed + rows
if group.children.map(\.identifier) != children.map(\.identifier) {
group.children = children
}
}
/// The cached cover for `url`, starting a download on a miss.
@available(iOS 18.0, *)
private func playlistImage(identifier: String, url: String?) -> UIImage? {
let placeholder = UIImage(systemName: "music.note.list")
guard let url, let remote = URL(string: url) else { return placeholder }
if let image = coverImages[url] { return image }
if coverTasks[url] == nil {
let task = URLSession.shared.dataTask(with: remote) { [weak self] data, _, _ in
guard let data, let image = UIImage(data: data) else { return }
DispatchQueue.main.async {
guard let self else { return }
self.coverTasks[url] = nil
self.coverImages[url] = roundedIcon(image)
if let tab = self.playlistTabs[identifier] { tab.image = self.coverImages[url] }
}
}
coverTasks[url] = task
task.resume()
}
return placeholder
}
}
/// Square cover shrunk to sidebar icon size with rounded corners, drawn as is
/// rather than tinted like a symbol.
private func roundedIcon(_ image: UIImage) -> UIImage {
let size = CGSize(width: playlistIconSize, height: playlistIconSize)
let rendered = UIGraphicsImageRenderer(size: size).image { _ in
UIBezierPath(roundedRect: CGRect(origin: .zero, size: size), cornerRadius: 4).addClip()
image.draw(in: CGRect(origin: .zero, size: size))
}
return rendered.withRenderingMode(.alwaysOriginal)
}
/// Sits in front of the router's tab controller delegate. Taps on playlist
/// rows go to JS; everything else is forwarded untouched.
private final class SidebarSelectionProxy: NSObject, UITabBarControllerDelegate {
weak var original: UITabBarControllerDelegate?
var onPlaylist: ((String) -> Void)?
override func responds(to aSelector: Selector!) -> Bool {
super.responds(to: aSelector) || (original?.responds(to: aSelector) ?? false)
}
override func forwardingTarget(for aSelector: Selector!) -> Any? { original }
@available(iOS 18.0, *)
func tabBarController(_ tabBarController: UITabBarController, shouldSelectTab tab: UITab) -> Bool {
if tab.identifier.hasPrefix(playlistTabPrefix) {
onPlaylist?(String(tab.identifier.dropFirst(playlistTabPrefix.count)))
return false
}
return original?.tabBarController?(tabBarController, shouldSelectTab: tab) ?? true
}
}
@available(iOS 18.0, *)
private final class SidebarAccountButton: UIView {
var onPress: (() -> Void)?
+11 -6
View File
@@ -1,18 +1,23 @@
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import { getConvexClient } from "@/lib/convex-server"
import { serveCoverFile } from "@/lib/serve-cover"
import { fetchConvexStorageFile, getConvexClient } from "@/lib/convex-server"
import { serveCoverFile, serveStoredCover } from "@/lib/serve-cover"
/** Playlist artwork, drawn or uploaded ahead of time into Convex storage. */
export async function GET(
request: Request,
{ params }: { params: Promise<{ id: string }> }
) {
const { id } = await params
try {
const cover = await getConvexClient().query(api.library.getPlaylistCover, {
id: id as Id<"playlists">,
})
return serveCoverFile(cover, request)
const storageUrl = await getConvexClient().query(
api.library.getPlaylistCover,
{ id: id as Id<"playlists"> }
)
const image = storageUrl ? await fetchConvexStorageFile(storageUrl) : null
return image
? await serveStoredCover(image, request)
: await serveCoverFile(null, request)
} catch {
return new Response("Not found", { status: 404 })
}
+4 -9
View File
@@ -1,7 +1,7 @@
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import sharp from "sharp"
import { getConvexClient, getConvexServerUrl } from "@/lib/convex-server"
import { fetchConvexStorageFile, getConvexClient } from "@/lib/convex-server"
const AVATAR_SIZE = 256
@@ -24,17 +24,12 @@ export async function GET(
return new Response("Not found", { status: 404 })
}
// The backend builds storage URLs from its public origin, which may not
// be reachable from here. Fetch the same path from the internal URL.
const { pathname, search } = new URL(storageUrl)
const upstream = await fetch(
new URL(pathname + search, getConvexServerUrl())
)
if (!upstream.ok) {
const image = await fetchConvexStorageFile(storageUrl)
if (!image) {
return new Response("Not found", { status: 404 })
}
const data = await sharp(Buffer.from(await upstream.arrayBuffer()))
const data = await sharp(image)
.rotate()
.resize(AVATAR_SIZE, AVATAR_SIZE, {
fit: "cover",
+22 -10
View File
@@ -43,6 +43,7 @@ import Link from "next/link"
import { useTheme } from "next-themes"
import * as React from "react"
import { api } from "@otunes/convex/_generated/api"
import { playlistCoverUrl } from "@/lib/cover-urls"
import { useCachedQuery } from "@/hooks/use-cached-query"
import { useMounted } from "@/hooks/use-mounted"
import { clearPersistentCache } from "@/lib/persistent-cache"
@@ -86,17 +87,28 @@ export function AppSidebar() {
const isDark = mounted && resolvedTheme === "dark"
const playlistNav = [
{ title: "All Playlists", path: "/playlists", icon: LayoutGrid },
{ title: "Favorites", path: "/playlist/favorites", icon: Star },
...(sidebarPlaylists?.owned ?? []).map((playlist) => ({
{
title: "All Playlists",
path: "/playlists",
icon: <LayoutGrid />,
},
{ title: "Favorites", path: "/playlist/favorites", icon: <Star /> },
...[
...(sidebarPlaylists?.owned ?? []),
...(sidebarPlaylists?.subscribed ?? []),
].map((playlist) => ({
title: playlist.title,
path: `/playlist/${playlist.id}`,
icon: ListMusic,
})),
...(sidebarPlaylists?.subscribed ?? []).map((playlist) => ({
title: playlist.title,
path: `/playlist/${playlist.id}`,
icon: ListMusic,
icon: playlist.cover ? (
// eslint-disable-next-line @next/next/no-img-element -- versioned cover, already sized by the route
<img
src={playlistCoverUrl(playlist.id, playlist.cover, 64)}
alt=""
className="size-4 shrink-0 rounded-[3px] object-cover"
/>
) : (
<ListMusic />
),
})),
]
@@ -165,7 +177,7 @@ export function AppSidebar() {
<SidebarMenuItem key={item.path}>
<SidebarMenuButton isActive={pathname === item.path} asChild>
<Link href={item.path} onClick={() => setOpenMobile(false)}>
<item.icon />
{item.icon}
<span>{item.title}</span>
</Link>
</SidebarMenuButton>
+1 -1
View File
@@ -43,7 +43,7 @@ import { usePlayback } from "@/components/playback-provider"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import type { PlaybackQuality } from "@otunes/convex/playback-stream"
import { resizeProfileImageToDataUrl } from "@/lib/resize-profile-image"
import { resizeProfileImageToDataUrl } from "@/lib/resize-image"
import { cn } from "@/lib/utils"
type Section = "profile" | "quality" | "users" | "library"
+2 -2
View File
@@ -62,10 +62,10 @@ export function PlaylistCard({ playlist }: { playlist: PlaylistSummary }) {
<div className="group relative aspect-square overflow-hidden rounded-lg ring-1 ring-foreground/10">
<Link className="absolute inset-0" href={"/playlist/" + playlist.id}>
<Image
src={playlistCoverUrl(playlist.id)}
src={playlistCoverUrl(playlist.id, playlist.cover, 384)}
alt={playlist.title}
fill
sizes="(max-width: 640px) 50vw, (max-width: 1024px) 25vw, 16vw"
unoptimized
className="object-cover"
/>
</Link>
@@ -0,0 +1,215 @@
"use client"
import * as React from "react"
import Image from "next/image"
import { useMutation } from "convex/react"
import { ArrowUp, Shuffle } from "lucide-react"
import { toast } from "sonner"
import { Button } from "@/components/ui/button"
import {
Dialog,
DialogContent,
DialogHeader,
DialogTitle,
} from "@/components/ui/dialog"
import { albumCoverUrl, playlistCoverUrl } from "@/lib/cover-urls"
import { resizeImageToDataUrl } from "@/lib/resize-image"
import { cn } from "@/lib/utils"
import { api } from "@otunes/convex/_generated/api"
import type { Id } from "@otunes/convex/_generated/dataModel"
import {
COVER_GRID_ALBUMS,
playlistCoverAlbums,
randomPlaylistCovers,
} from "@otunes/convex/client/playlist-cover"
import type { BrowseSong } from "@otunes/convex/types"
const UPLOAD_SIZE = 1024
/**
* Lets a playlist owner pick generated artwork (random 2x2 grids of the
* playlist's albums, reshuffled on demand) or upload an image. The current
* cover sits apart from the options so the owner can always keep it.
*/
export function PlaylistCoverDialog({
open,
onOpenChange,
playlistId,
title,
coverVersion,
songs,
}: {
open: boolean
onOpenChange: (open: boolean) => void
playlistId: Id<"playlists">
title: string
coverVersion: string | null
songs: BrowseSong[]
}) {
const setCoverAlbums = useMutation(api.playlists.setPlaylistCoverAlbums)
const uploadCover = useMutation(api.playlists.uploadPlaylistCover)
const fileInputRef = React.useRef<HTMLInputElement>(null)
const albums = React.useMemo(() => playlistCoverAlbums(songs), [songs])
const [options, setOptions] = React.useState<Id<"albums">[][]>([])
const canShuffle = albums.length >= COVER_GRID_ALBUMS
function shuffle() {
setOptions(randomPlaylistCovers(albums))
}
// Fresh options each time the dialog opens.
const [wasOpen, setWasOpen] = React.useState(false)
if (open !== wasOpen) {
setWasOpen(open)
if (open) shuffle()
}
async function pick(albumIds: Id<"albums">[]) {
onOpenChange(false)
try {
await setCoverAlbums({ playlistId, albumIds })
} catch (error) {
toast.error(
error instanceof Error ? error.message : "Failed to change cover"
)
}
}
async function upload(file: File) {
if (!file.type.startsWith("image/")) {
toast.error("Choose an image file")
return
}
onOpenChange(false)
try {
const image = await resizeImageToDataUrl(file, UPLOAD_SIZE)
await uploadCover({ playlistId, image })
} catch (error) {
toast.error(
error instanceof Error ? error.message : "Failed to upload cover"
)
}
}
return (
<Dialog open={open} onOpenChange={onOpenChange}>
<DialogContent className="sm:max-w-xl">
<DialogHeader>
<DialogTitle>Playlist Cover</DialogTitle>
</DialogHeader>
<div className="flex items-stretch gap-3">
{coverVersion ? (
<>
<CoverButton
label="Keep current cover"
selected
onClick={() => onOpenChange(false)}
>
<Image
src={playlistCoverUrl(playlistId, coverVersion, 256)}
alt={title}
fill
unoptimized
className="object-cover"
/>
</CoverButton>
<div className="w-px shrink-0 bg-border" />
</>
) : null}
<div className="grid flex-[4] grid-cols-4 gap-3">
{options.map((albumIds) => (
<CoverButton
key={albumIds.join(",")}
label="Use this cover"
onClick={() => void pick(albumIds)}
>
<AlbumGrid albumIds={albumIds} />
</CoverButton>
))}
</div>
</div>
{albums.length === 0 ? (
<p className="text-sm text-muted-foreground">
No album artwork in this playlist yet.
</p>
) : null}
<div className="flex gap-2">
{canShuffle ? (
<Button variant="secondary" onClick={shuffle}>
<Shuffle />
Shuffle
</Button>
) : null}
<Button
variant="secondary"
onClick={() => fileInputRef.current?.click()}
>
<ArrowUp />
Upload Image
</Button>
<input
ref={fileInputRef}
type="file"
accept="image/*"
className="hidden"
onChange={(event) => {
const file = event.target.files?.[0]
event.target.value = ""
if (file) void upload(file)
}}
/>
</div>
</DialogContent>
</Dialog>
)
}
function CoverButton({
label,
selected = false,
onClick,
children,
}: {
label: string
selected?: boolean
onClick: () => void
children: React.ReactNode
}) {
return (
<button
type="button"
aria-label={label}
onClick={onClick}
className={cn(
"relative aspect-square min-w-0 flex-1 overflow-hidden rounded-md ring-offset-2 ring-offset-background transition-shadow outline-none hover:ring-2 hover:ring-foreground/60 focus-visible:ring-2 focus-visible:ring-ring",
selected && "ring-2 ring-foreground hover:ring-foreground"
)}
>
{children}
</button>
)
}
/** Preview of a generated cover: one album alone, or four tiled 2x2. */
function AlbumGrid({ albumIds }: { albumIds: Id<"albums">[] }) {
const grid = albumIds.length > 1
return (
<div className={cn("grid size-full", grid && "grid-cols-2")}>
{albumIds.map((albumId) => (
<div key={albumId} className="relative">
<Image
src={albumCoverUrl(albumId)}
alt=""
fill
sizes={grid ? "64px" : "128px"}
className="object-cover"
/>
</div>
))}
</div>
)
}
+44 -4
View File
@@ -6,7 +6,16 @@ import * as React from "react"
import Image from "next/image"
import { useRouter } from "next/navigation"
import { useMutation } from "convex/react"
import { Play, SearchIcon, Share2, Shuffle, Star, Trash2 } from "lucide-react"
import {
ImageIcon,
Pencil,
Play,
SearchIcon,
Share2,
Shuffle,
Star,
Trash2,
} from "lucide-react"
import { toast } from "sonner"
import { useFavorites } from "@/components/favorites-provider"
@@ -15,6 +24,7 @@ import {
usePlaybackActions,
} from "@/components/playback-provider"
import { MediaCollectionFooter } from "@/components/media-collection-footer"
import { PlaylistCoverDialog } from "@/components/playlist-cover-dialog"
import {
MediaContextMenu,
type MediaContextAction,
@@ -97,6 +107,8 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
const [dragIndex, setDragIndex] = React.useState<number | null>(null)
const [isSubscribed, setIsSubscribed] = React.useState(playlist.isSubscribed)
const [subscriptionPending, setSubscriptionPending] = React.useState(false)
const [coverDialogOpen, setCoverDialogOpen] = React.useState(false)
const canEditCover = isOwner && !isFavorites && playlist.id !== null
if (syncedPlaylist !== playlist) {
setSyncedPlaylist(playlist)
@@ -291,21 +303,32 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
<div className="pb-28">
<div className="mx-auto w-full max-w-9/10 min-w-0">
<div className="flex flex-col gap-8 px-6 pt-6 pb-8 sm:flex-row sm:items-end">
<div className="relative mx-auto aspect-square w-full max-w-60 shrink-0 overflow-hidden rounded-lg ring-1 ring-foreground/10 sm:mx-0">
<div className="group relative mx-auto aspect-square w-full max-w-60 shrink-0 overflow-hidden rounded-lg ring-1 ring-foreground/10 sm:mx-0">
{isFavorites ? (
<div className="flex size-full items-center justify-center bg-muted">
<Star className="size-16 fill-primary text-primary" />
</div>
) : (
<Image
src={playlistCoverUrl(playlist.id!)}
src={playlistCoverUrl(playlist.id!, playlist.cover, 512)}
alt={playlist.title}
fill
sizes="240px"
unoptimized
className="object-cover"
preload
/>
)}
{canEditCover ? (
<Button
variant="secondary"
size="icon"
className="absolute right-2 bottom-2 rounded-full opacity-0 shadow-md transition-opacity group-hover:opacity-100 focus-visible:opacity-100"
aria-label="Change cover"
onClick={() => setCoverDialogOpen(true)}
>
<Pencil />
</Button>
) : null}
</div>
<div className="flex min-w-0 flex-1 flex-col gap-4">
@@ -385,6 +408,13 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
{isOwner && !isFavorites ? (
<>
<DropdownMenuSeparator />
<DropdownMenuItem
className="justify-between"
onClick={() => setCoverDialogOpen(true)}
>
Change Cover
<ImageIcon />
</DropdownMenuItem>
<DropdownMenuItem
variant="destructive"
className="justify-between"
@@ -476,6 +506,16 @@ export function PlaylistView({ playlist }: { playlist: BrowsePlaylistDetail }) {
</div>
</div>
</ScrollArea>
{canEditCover ? (
<PlaylistCoverDialog
open={coverDialogOpen}
onOpenChange={setCoverDialogOpen}
playlistId={playlist.id!}
title={playlist.title}
coverVersion={playlist.cover}
songs={songs}
/>
) : null}
</div>
)
}
+11
View File
@@ -24,3 +24,14 @@ export function getConvexClient() {
}
return client
}
/**
* Downloads a Convex storage file. The backend builds storage URLs from its
* public origin, which may not be reachable from here, so the same path is
* fetched from the internal URL. `null` when it is missing.
*/
export async function fetchConvexStorageFile(storageUrl: string) {
const { pathname, search } = new URL(storageUrl)
const response = await fetch(new URL(pathname + search, getConvexServerUrl()))
return response.ok ? Buffer.from(await response.arrayBuffer()) : null
}
+11 -2
View File
@@ -12,6 +12,15 @@ export function albumCoverUrl(albumId: string, size?: CoverImageSize) {
return withCoverImageSize(`/api/album/${albumId}/cover`, size)
}
export function playlistCoverUrl(playlistId: string, size?: CoverImageSize) {
return withCoverImageSize(`/api/playlist/${playlistId}/cover`, size)
/** `version` is the summary's `cover`; it changes with the artwork. */
export function playlistCoverUrl(
playlistId: string,
version: string | null,
size?: CoverImageSize
) {
const params = new URLSearchParams()
if (version) params.set("v", version)
if (size) params.set("size", String(size))
const query = params.toString()
return `/api/playlist/${playlistId}/cover${query ? `?${query}` : ""}`
}
@@ -1,9 +1,12 @@
const PROFILE_IMAGE_SIZE = 256
/**
* Downscales an image to 256×256 (center-cropped cover) and returns a base64 data URL.
* Downscales an image to `size`×`size` (center-cropped cover) and returns a
* base64 data URL. JPEG, unless `keepLossless` and the file is PNG or WebP.
*/
export function resizeProfileImageToDataUrl(file: File): Promise<string> {
export function resizeImageToDataUrl(
file: File,
size: number,
{ keepLossless = false } = {}
): Promise<string> {
return new Promise((resolve, reject) => {
const url = URL.createObjectURL(file)
const image = new Image()
@@ -12,8 +15,8 @@ export function resizeProfileImageToDataUrl(file: File): Promise<string> {
URL.revokeObjectURL(url)
const canvas = document.createElement("canvas")
canvas.width = PROFILE_IMAGE_SIZE
canvas.height = PROFILE_IMAGE_SIZE
canvas.width = size
canvas.height = size
const ctx = canvas.getContext("2d")
if (!ctx) {
@@ -21,19 +24,20 @@ export function resizeProfileImageToDataUrl(file: File): Promise<string> {
return
}
const scale = Math.max(
PROFILE_IMAGE_SIZE / image.width,
PROFILE_IMAGE_SIZE / image.height
)
const scale = Math.max(size / image.width, size / image.height)
const width = image.width * scale
const height = image.height * scale
const x = (PROFILE_IMAGE_SIZE - width) / 2
const y = (PROFILE_IMAGE_SIZE - height) / 2
ctx.drawImage(image, x, y, width, height)
ctx.drawImage(
image,
(size - width) / 2,
(size - height) / 2,
width,
height
)
const outputType =
file.type === "image/png" || file.type === "image/webp"
keepLossless &&
(file.type === "image/png" || file.type === "image/webp")
? "image/png"
: "image/jpeg"
resolve(
@@ -52,3 +56,7 @@ export function resizeProfileImageToDataUrl(file: File): Promise<string> {
image.src = url
})
}
export function resizeProfileImageToDataUrl(file: File) {
return resizeImageToDataUrl(file, 256, { keepLossless: true })
}
+23
View File
@@ -34,6 +34,29 @@ function requestedCoverSize(request: Request): number | undefined {
return COVER_IMAGE_SIZES.has(size) ? size : undefined
}
/**
* Serves stored playlist artwork as a square WebP, `?size=` pixels a side
* (1024 by default). URLs
* carry the artwork's version (`?v=`), so new artwork gets a new URL and
* versioned responses can be cached for good.
*/
export async function serveStoredCover(image: Buffer, request: Request) {
const size = requestedCoverSize(request) ?? 1024
const data = await sharp(image)
.rotate()
.resize(size, size, { fit: "cover", withoutEnlargement: true })
.webp({ quality: 80 })
.toBuffer()
return new Response(new Uint8Array(data), {
headers: {
"Content-Type": "image/webp",
"Cache-Control": new URL(request.url).searchParams.has("v")
? "public, max-age=31536000, immutable"
: COVER_CACHE_CONTROL,
},
})
}
export async function serveCoverFile(
coverPath: string | null | undefined,
request: Request
+1
View File
@@ -99,6 +99,7 @@ convex_cli deploy --typecheck disable --codegen disable
log "Running data migrations"
convex_cli run migrations:migrateUsers
convex_cli run migrations:migratePlaylists
# `env get` exits 0 with no output when the variable is unset. Any other failure
# must not be read as "no keys": regenerating them signs every user out.
+52
View File
@@ -0,0 +1,52 @@
import type { Id } from "../convex/_generated/dataModel"
import { COVER_GRID_ALBUMS } from "../convex/limits"
import type { BrowseSong } from "../convex/types"
export { COVER_GRID_ALBUMS }
export type CoverAlbum = BrowseSong["album"]
/** Distinct albums that have artwork, in playlist order. */
export function playlistCoverAlbums(songs: readonly BrowseSong[]) {
const albums = new Map<string, CoverAlbum>()
for (const song of songs) {
if (song.album.cover !== null && !albums.has(song.album.id)) {
albums.set(song.album.id, song.album)
}
}
return [...albums.values()]
}
/** `count` distinct items in random order (Fisher-Yates prefix). */
function sample<T>(items: readonly T[], count: number) {
const pool = [...items]
for (let index = 0; index < count; index++) {
const swap = index + Math.floor(Math.random() * (pool.length - index))
;[pool[index], pool[swap]] = [pool[swap], pool[index]]
}
return pool.slice(0, count)
}
/**
* Cover options to pick from, as album ids for `setPlaylistCoverAlbums`.
* With four or more albums: `count` random 2x2 grids, avoiding repeats.
* With fewer: each album's cover alone.
*/
export function randomPlaylistCovers(
albums: readonly CoverAlbum[],
count = 4
): Id<"albums">[][] {
const ids = albums.map((album) => album.id)
if (ids.length < COVER_GRID_ALBUMS) return ids.map((id) => [id])
const options = new Map<string, Id<"albums">[]>()
for (
let attempt = 0;
options.size < count && attempt < count * 10;
attempt++
) {
const option = sample(ids, COVER_GRID_ALBUMS)
options.set(option.join(","), option)
}
return [...options.values()]
}
+6
View File
@@ -14,6 +14,7 @@ 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 images from "../images.js";
import type * as intentCatalog from "../intentCatalog.js";
import type * as intentCatalogChanges from "../intentCatalogChanges.js";
import type * as library from "../library.js";
@@ -21,6 +22,8 @@ import type * as limits from "../limits.js";
import type * as migrations from "../migrations.js";
import type * as playback from "../playback.js";
import type * as playbackState from "../playbackState.js";
import type * as playlistCover from "../playlistCover.js";
import type * as playlistCoverImages from "../playlistCoverImages.js";
import type * as playlists from "../playlists.js";
import type * as types from "../types.js";
import type * as users from "../users.js";
@@ -38,6 +41,7 @@ declare const fullApi: ApiFromModules<{
favoriteStore: typeof favoriteStore;
favorites: typeof favorites;
http: typeof http;
images: typeof images;
intentCatalog: typeof intentCatalog;
intentCatalogChanges: typeof intentCatalogChanges;
library: typeof library;
@@ -45,6 +49,8 @@ declare const fullApi: ApiFromModules<{
migrations: typeof migrations;
playback: typeof playback;
playbackState: typeof playbackState;
playlistCover: typeof playlistCover;
playlistCoverImages: typeof playlistCoverImages;
playlists: typeof playlists;
types: typeof types;
users: typeof users;
+29
View File
@@ -0,0 +1,29 @@
import { ConvexError } from "convex/values"
import { MAX_IMAGE_UPLOAD_BYTES } from "./limits"
const DATA_URL_PATTERN = /^data:(image\/[\w.+-]+);base64,([A-Za-z0-9+/=]+)$/
/**
* Splits an image data URL, rejecting anything over the size cap. `label`
* names the image in error messages ("Profile photo").
*/
export function parseImageDataUrl(image: string, label: string) {
const match = DATA_URL_PATTERN.exec(image)
if (!match) {
throw new ConvexError(`${label} must be an image`)
}
const [, contentType, base64] = match
if (Math.floor((base64.length * 3) / 4) > MAX_IMAGE_UPLOAD_BYTES) {
throw new ConvexError(
`${label} must be ${MAX_IMAGE_UPLOAD_BYTES / 1024 / 1024} MB or smaller`
)
}
return { contentType, base64 }
}
/** Decodes an image data URL for `ctx.storage.store`. */
export function imageDataUrlToBlob(image: string, label: string) {
const { contentType, base64 } = parseImageDataUrl(image, label)
const bytes = Uint8Array.from(atob(base64), (char) => char.charCodeAt(0))
return new Blob([bytes], { type: contentType })
}
+8 -3
View File
@@ -24,6 +24,7 @@ import type {
import { purgeFavoriteEntities } from "./favoriteStore"
import { chunk, type Chunked } from "./limits"
import { recordIntentCatalogChanges } from "./intentCatalogChanges"
import { playlistCoverVersion } from "./playlistCover"
export type {
BrowseAlbum,
@@ -875,7 +876,7 @@ async function browseRecentlyPlayedItems(ctx: QueryCtx, limit?: number) {
id: entry.playlist._id,
title: entry.playlist.name,
owner: ownerMap.get(entry.playlist.owner)?.name ?? "Unknown",
cover: entry.playlist.cover,
cover: playlistCoverVersion(entry.playlist),
})
}
@@ -959,11 +960,15 @@ export const getAlbumCover = query({
},
})
/** Public: share-link previews load covers without a session. */
/**
* Public: share-link previews load covers without a session. A storage URL
* the web server proxies, or `null` when the playlist has no artwork.
*/
export const getPlaylistCover = query({
args: { id: v.id("playlists") },
handler: async (ctx, args) => {
return (await ctx.db.get("playlists", args.id))?.cover ?? null
const storageId = (await ctx.db.get("playlists", args.id))?.coverStorageId
return storageId ? await ctx.storage.getUrl(storageId) : null
},
})
+5 -2
View File
@@ -6,8 +6,11 @@
/** Songs kept in the playback queue, including the current song. */
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
/** Largest uploaded image (profile photo, playlist cover), in bytes after base64 decoding. */
export const MAX_IMAGE_UPLOAD_BYTES = 2 * 1024 * 1024
/** Album covers a generated playlist cover tiles 2x2. */
export const COVER_GRID_ALBUMS = 4
/** Most values Convex accepts in a single array. */
export const MAX_ARRAY_LENGTH = 8_192
+29
View File
@@ -56,3 +56,32 @@ export const migrateFavorites = internalMutation({
}
},
})
/**
* Draws automatic artwork for playlists that have none yet. Idempotent; the
* Docker entrypoint runs it on every boot.
*/
export const migratePlaylists = internalMutation({
args: { cursor: v.optional(v.union(v.string(), v.null())) },
handler: async (ctx, { cursor }) => {
const page = await ctx.db
.query("playlists")
.paginate({ cursor: cursor ?? null, numItems: BATCH_SIZE })
for (const playlist of page.page) {
if (!playlist.coverSource && !playlist.coverAlbums) {
await ctx.scheduler.runAfter(
0,
internal.playlistCover.refreshPlaylistCover,
{ playlistId: playlist._id }
)
}
}
if (!page.isDone) {
await ctx.scheduler.runAfter(0, internal.migrations.migratePlaylists, {
cursor: page.continueCursor,
})
}
},
})
+161
View File
@@ -0,0 +1,161 @@
import { v } from "convex/values"
import { internal } from "./_generated/api"
import type { Doc, Id } from "./_generated/dataModel"
import type { MutationCtx } from "./_generated/server"
import { internalMutation, internalQuery } from "./_generated/server"
import { COVER_GRID_ALBUMS } from "./limits"
/*
* Playlist artwork is a stored image (`coverStorageId`), drawn once and
* redrawn only when its inputs change:
* - automatic (no `coverSource`): the first albums in the playlist, kept in
* sync by `refreshAutomaticCover` whenever the songs change
* - "albums": albums the owner picked
* - "upload": an image the owner uploaded
* `coverAlbums` holds the albums behind the current or pending drawing: four
* tile 2x2, one shows alone. Drawing happens in `playlistCoverImages`.
*/
/**
* What clients put in the cover URL (`?v=`) so new artwork gets a new URL.
* `null` when the playlist has no artwork.
*/
export function playlistCoverVersion(playlist: Doc<"playlists">) {
return playlist.coverStorageId ?? null
}
/** Songs read when picking automatic artwork, so long single-album runs stay cheap. */
const AUTO_COVER_SONG_SCAN = 50
/** First distinct album covers in playlist order: four for a grid, else one. */
async function automaticCoverAlbums(ctx: MutationCtx, songIds: Id<"songs">[]) {
const seen = new Set<Id<"albums">>()
const albums: Id<"albums">[] = []
for (const songId of songIds.slice(0, AUTO_COVER_SONG_SCAN)) {
const song = await ctx.db.get("songs", songId)
if (!song || seen.has(song.album)) continue
seen.add(song.album)
const album = await ctx.db.get("albums", song.album)
if (album?.cover) albums.push(album._id)
if (albums.length === COVER_GRID_ALBUMS) break
}
return albums.length === COVER_GRID_ALBUMS ? albums : albums.slice(0, 1)
}
function sameAlbums(a: Id<"albums">[] | undefined, b: Id<"albums">[]) {
return a?.length === b.length && a.every((id, index) => id === b[index])
}
/**
* Points `coverAlbums` at new albums and queues a drawing of them. The old
* image stays up until the new one lands.
*/
export async function drawCoverAlbums(
ctx: MutationCtx,
playlist: Doc<"playlists">,
albumIds: Id<"albums">[],
coverSource: "albums" | undefined
) {
await ctx.db.patch(playlist._id, { coverAlbums: albumIds, coverSource })
await ctx.scheduler.runAfter(
0,
internal.playlistCoverImages.renderPlaylistCover,
{ playlistId: playlist._id, albumIds }
)
}
/**
* Keeps automatic artwork in step with the playlist's first albums. Call
* after the songs change, with the new order. Draws only when the albums
* differ from the last drawing.
*/
export async function refreshAutomaticCover(
ctx: MutationCtx,
playlist: Doc<"playlists">,
songIds: Id<"songs">[]
) {
if (playlist.coverSource) return
const albums = await automaticCoverAlbums(ctx, songIds)
if (sameAlbums(playlist.coverAlbums, albums)) return
if (albums.length > 0) {
await drawCoverAlbums(ctx, playlist, albums, undefined)
return
}
if (playlist.coverStorageId) await ctx.storage.delete(playlist.coverStorageId)
await ctx.db.patch(playlist._id, {
coverAlbums: undefined,
coverStorageId: undefined,
})
}
/** Album cover file paths for a drawing, or `null` if any lost its artwork. */
export const coverFilePaths = internalQuery({
args: { albumIds: v.array(v.id("albums")) },
handler: async (ctx, { albumIds }) => {
const albums = await Promise.all(
albumIds.map((id) => ctx.db.get("albums", id))
)
const paths = albums.flatMap((album) => (album?.cover ? [album.cover] : []))
return paths.length === albumIds.length ? paths : null
},
})
/** Deletes the image `storageId` replaces. */
async function deleteReplacedImage(
ctx: MutationCtx,
playlist: Doc<"playlists">,
storageId: Id<"_storage">
) {
if (playlist.coverStorageId && playlist.coverStorageId !== storageId) {
await ctx.storage.delete(playlist.coverStorageId)
}
}
/** Saves a finished drawing unless the playlist moved on while it rendered. */
export const attachRenderedCover = internalMutation({
args: {
playlistId: v.id("playlists"),
albumIds: v.array(v.id("albums")),
storageId: v.id("_storage"),
},
handler: async (ctx, { playlistId, albumIds, storageId }) => {
const playlist = await ctx.db.get("playlists", playlistId)
if (
!playlist ||
playlist.coverSource === "upload" ||
!sameAlbums(playlist.coverAlbums, albumIds)
) {
await ctx.storage.delete(storageId)
return
}
await deleteReplacedImage(ctx, playlist, storageId)
await ctx.db.patch(playlist._id, { coverStorageId: storageId })
},
})
/** Saves an uploaded image as the playlist's artwork. */
export const attachUploadedCover = internalMutation({
args: { playlistId: v.id("playlists"), storageId: v.id("_storage") },
handler: async (ctx, { playlistId, storageId }) => {
const playlist = await ctx.db.get("playlists", playlistId)
if (!playlist) {
await ctx.storage.delete(storageId)
return
}
await deleteReplacedImage(ctx, playlist, storageId)
await ctx.db.patch(playlist._id, {
coverSource: "upload",
coverAlbums: undefined,
coverStorageId: storageId,
})
},
})
/** Draws automatic artwork for one playlist. Scheduled by `migratePlaylists`. */
export const refreshPlaylistCover = internalMutation({
args: { playlistId: v.id("playlists") },
handler: async (ctx, { playlistId }) => {
const playlist = await ctx.db.get("playlists", playlistId)
if (playlist) await refreshAutomaticCover(ctx, playlist, playlist.songs)
},
})
@@ -0,0 +1,123 @@
"use node"
import * as fs from "node:fs/promises"
import { v } from "convex/values"
import * as jpeg from "jpeg-js"
import { internal } from "./_generated/api"
import { internalAction } from "./_generated/server"
import { imageDataUrlToBlob } from "./images"
/*
* Draws playlist artwork into storage. Pure JS on purpose: self-hosted Convex
* cannot install native packages like sharp for node actions. Album covers
* are always `cover.jpg` / `folder.jpg`, so JPEG in and out is enough.
*/
/** Stored playlist artwork is square, this many pixels a side. */
const COVER_SIZE = 1024
const JPEG_QUALITY = 88
type Rgba = { width: number; height: number; data: Uint8Array }
/**
* Center-crops `source` to a square and area-averages it into `target` at
* (`left`, `top`), `size` pixels a side. Averaging keeps downscaled covers
* smooth; tiny covers upscale blocky but intact.
*/
function drawSquare(
source: Rgba,
target: Rgba,
left: number,
top: number,
size: number
) {
const side = Math.min(source.width, source.height)
const offsetX = Math.floor((source.width - side) / 2)
const offsetY = Math.floor((source.height - side) / 2)
const scale = side / size
for (let y = 0; y < size; y++) {
const y0 = offsetY + Math.floor(y * scale)
const y1 = Math.max(y0 + 1, offsetY + Math.floor((y + 1) * scale))
for (let x = 0; x < size; x++) {
const x0 = offsetX + Math.floor(x * scale)
const x1 = Math.max(x0 + 1, offsetX + Math.floor((x + 1) * scale))
let r = 0
let g = 0
let b = 0
for (let sy = y0; sy < y1; sy++) {
let index = (sy * source.width + x0) * 4
for (let sx = x0; sx < x1; sx++, index += 4) {
r += source.data[index]
g += source.data[index + 1]
b += source.data[index + 2]
}
}
const count = (x1 - x0) * (y1 - y0)
const out = ((top + y) * target.width + left + x) * 4
target.data[out] = r / count
target.data[out + 1] = g / count
target.data[out + 2] = b / count
target.data[out + 3] = 255
}
}
}
/** One cover alone, or four tiled 2x2 left to right, top to bottom. */
async function drawCover(paths: string[]) {
const canvas: Rgba = {
width: COVER_SIZE,
height: COVER_SIZE,
data: new Uint8Array(COVER_SIZE * COVER_SIZE * 4),
}
const tile = paths.length === 1 ? COVER_SIZE : COVER_SIZE / 2
// One at a time: a decoded 3000px cover is ~36 MB.
for (const [index, path] of paths.entries()) {
const source = jpeg.decode(await fs.readFile(path), { useTArray: true })
drawSquare(
source,
canvas,
(index % 2) * tile,
Math.floor(index / 2) * tile,
tile
)
}
return jpeg.encode(canvas, JPEG_QUALITY).data
}
/** Draws album artwork into storage. Scheduled by `drawCoverAlbums`. */
export const renderPlaylistCover = internalAction({
args: { playlistId: v.id("playlists"), albumIds: v.array(v.id("albums")) },
handler: async (ctx, { playlistId, albumIds }) => {
const paths = await ctx.runQuery(internal.playlistCover.coverFilePaths, {
albumIds,
})
if (!paths) return
const image = await drawCover(paths)
const storageId = await ctx.storage.store(
new Blob([new Uint8Array(image)], { type: "image/jpeg" })
)
await ctx.runMutation(internal.playlistCover.attachRenderedCover, {
playlistId,
albumIds,
storageId,
})
},
})
/**
* Stores an uploaded data URL as is; clients send it square. Scheduled by
* `uploadPlaylistCover`.
*/
export const storeUploadedCover = internalAction({
args: { playlistId: v.id("playlists"), image: v.string() },
handler: async (ctx, { playlistId, image }) => {
const storageId = await ctx.storage.store(
imageDataUrlToBlob(image, "Cover")
)
await ctx.runMutation(internal.playlistCover.attachUploadedCover, {
playlistId,
storageId,
})
},
})
+67 -10
View File
@@ -3,7 +3,14 @@ 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 { internal } from "./_generated/api"
import { parseImageDataUrl } from "./images"
import { chunk, COVER_GRID_ALBUMS } from "./limits"
import {
drawCoverAlbums,
playlistCoverVersion,
refreshAutomaticCover,
} from "./playlistCover"
import type {
BrowsePlaylistDetail,
BrowsePlaylistSummary,
@@ -25,7 +32,7 @@ function toPlaylistSummary(
id: playlist._id,
title: playlist.name,
owner: ownerName,
cover: playlist.cover,
cover: playlistCoverVersion(playlist),
}
}
@@ -106,7 +113,7 @@ async function browsePlaylistSummaryHandler(
id: owner._id,
name: owner.name,
},
cover: playlist.cover,
cover: playlistCoverVersion(playlist),
isOwner,
isSubscribed,
songIds: playlist.songs,
@@ -366,6 +373,8 @@ export const createPlaylist = mutation({
cover: null,
songs: uniqueSongIds,
})
const playlist = await ctx.db.get("playlists", playlistId)
await refreshAutomaticCover(ctx, playlist!, uniqueSongIds)
if (args.invocationId)
await ctx.db.insert("appIntentPlaylists", {
userId,
@@ -388,9 +397,9 @@ export const addSongsToPlaylist = mutation({
const toAdd = uniqueIncoming.filter((songId) => !existing.has(songId))
if (toAdd.length > 0) {
await ctx.db.patch(playlist._id, {
songs: [...playlist.songs, ...toAdd],
})
const songs = [...playlist.songs, ...toAdd]
await ctx.db.patch(playlist._id, { songs })
await refreshAutomaticCover(ctx, playlist, songs)
}
return {
@@ -408,9 +417,9 @@ export const removeSongsFromPlaylist = mutation({
handler: async (ctx, args) => {
const { playlist } = await requirePlaylistOwner(ctx, args.playlistId)
const remove = new Set(args.songIds)
await ctx.db.patch(playlist._id, {
songs: playlist.songs.filter((songId) => !remove.has(songId)),
})
const songs = playlist.songs.filter((songId) => !remove.has(songId))
await ctx.db.patch(playlist._id, { songs })
await refreshAutomaticCover(ctx, playlist, songs)
},
})
@@ -430,13 +439,14 @@ export const reorderPlaylistSongs = mutation({
throw new ConvexError("Invalid song order")
}
await ctx.db.patch(playlist._id, { songs: args.songIds })
await refreshAutomaticCover(ctx, playlist, args.songIds)
},
})
export const deletePlaylist = mutation({
args: { playlistId: v.id("playlists") },
handler: async (ctx, args) => {
await requirePlaylistOwner(ctx, args.playlistId)
const { playlist } = await requirePlaylistOwner(ctx, args.playlistId)
const users = await ctx.db.query("users").collect()
for (const user of users) {
@@ -466,10 +476,57 @@ export const deletePlaylist = mutation({
})
}
if (playlist.coverStorageId) {
await ctx.storage.delete(playlist.coverStorageId)
}
await ctx.db.delete("playlists", args.playlistId)
},
})
/**
* Draws these album covers as the playlist's artwork: one alone, or four
* tiled 2x2. Replaces automatic or uploaded artwork.
*/
export const setPlaylistCoverAlbums = mutation({
args: {
playlistId: v.id("playlists"),
albumIds: v.array(v.id("albums")),
},
handler: async (ctx, { playlistId, albumIds }) => {
const { playlist } = await requirePlaylistOwner(ctx, playlistId)
if (
(albumIds.length !== 1 && albumIds.length !== COVER_GRID_ALBUMS) ||
new Set(albumIds).size !== albumIds.length
) {
throw new ConvexError("Pick one album or four different albums")
}
for (const albumId of albumIds) {
const album = await ctx.db.get("albums", albumId)
if (!album?.cover) {
throw new ConvexError("Album has no artwork")
}
}
await drawCoverAlbums(ctx, playlist, albumIds, "albums")
},
})
/**
* Takes an image data URL. It is cropped into storage in the background and
* the cover version changes once it lands.
*/
export const uploadPlaylistCover = mutation({
args: { playlistId: v.id("playlists"), image: v.string() },
handler: async (ctx, { playlistId, image }) => {
await requirePlaylistOwner(ctx, playlistId)
parseImageDataUrl(image, "Cover")
await ctx.scheduler.runAfter(
0,
internal.playlistCoverImages.storeUploadedCover,
{ playlistId, image }
)
},
})
export const subscribeToPlaylist = mutation({
args: { playlistId: v.id("playlists") },
handler: async (ctx, args) => {
+7
View File
@@ -148,7 +148,14 @@ export default defineSchema({
playlists: defineTable({
name: v.string(),
owner: v.id("users"),
/** Legacy and unused; artwork lives in `coverStorageId`. */
cover: v.nullable(v.string()),
// Artwork, see `playlistCover.ts`. No `coverSource` means automatic.
coverSource: v.optional(v.union(v.literal("albums"), v.literal("upload"))),
/** Albums behind the drawn artwork: four tile 2x2, one shows alone. */
coverAlbums: v.optional(v.array(v.id("albums"))),
/** The drawn or uploaded artwork. */
coverStorageId: v.optional(v.id("_storage")),
songs: v.array(v.id("songs")),
}).index("by_owner", ["owner"]),
})
+6 -22
View File
@@ -15,7 +15,7 @@ import {
} from "./_generated/server"
import type { Doc, Id } from "./_generated/dataModel"
import type { ActionCtx, MutationCtx } from "./_generated/server"
import { MAX_PROFILE_IMAGE_BYTES } from "./limits"
import { imageDataUrlToBlob, parseImageDataUrl } from "./images"
import { deleteUserFavorites } from "./favoriteStore"
import { deleteUserPlayback } from "./playbackState"
@@ -138,6 +138,9 @@ async function deleteOwnedPlaylists(ctx: MutationCtx, userId: Id<"users">) {
}
for (const playlist of owned) {
if (playlist.coverStorageId) {
await ctx.storage.delete(playlist.coverStorageId)
}
await ctx.db.delete(playlist._id)
}
}
@@ -188,23 +191,6 @@ export const listUsers = query({
},
})
const DATA_URL_PATTERN = /^data:(image\/[\w.+-]+);base64,([A-Za-z0-9+/=]+)$/
/** Splits an image data URL, rejecting anything over the size cap. */
function parseImageDataUrl(image: string) {
const match = DATA_URL_PATTERN.exec(image)
if (!match) {
throw new ConvexError("Profile photo must be an image")
}
const [, contentType, base64] = match
if (Math.floor((base64.length * 3) / 4) > MAX_PROFILE_IMAGE_BYTES) {
throw new ConvexError(
`Profile photo must be ${MAX_PROFILE_IMAGE_BYTES / 1024 / 1024} MB or smaller`
)
}
return { contentType, base64 }
}
/**
* Path clients load the avatar from. The web server proxies it from Convex
* storage, since the backend's storage URLs are not reachable from browsers
@@ -231,7 +217,7 @@ export const updateProfileImage = mutation({
await setProfileImage(ctx, userId, null)
return
}
parseImageDataUrl(image)
parseImageDataUrl(image, "Profile photo")
await ctx.scheduler.runAfter(0, internal.users.storeProfileImage, {
userId,
image,
@@ -243,10 +229,8 @@ export const updateProfileImage = mutation({
export const storeProfileImage = internalAction({
args: { userId: v.id("users"), image: v.string() },
handler: async (ctx, { userId, image }) => {
const { contentType, base64 } = parseImageDataUrl(image)
const bytes = Uint8Array.from(atob(base64), (char) => char.charCodeAt(0))
const storageId = await ctx.storage.store(
new Blob([bytes], { type: contentType })
imageDataUrlToBlob(image, "Profile photo")
)
await ctx.runMutation(internal.users.attachProfileImage, {
userId,
+5
View File
@@ -51,6 +51,10 @@
"types": "./client/playback-queue.ts",
"default": "./client/playback-queue.ts"
},
"./client/playlist-cover": {
"types": "./client/playlist-cover.ts",
"default": "./client/playlist-cover.ts"
},
"./client/playback-store": {
"types": "./client/playback-store.ts",
"default": "./client/playback-store.ts"
@@ -74,6 +78,7 @@
"dependencies": {
"@convex-dev/auth": "^0.0.93",
"convex": "^1.40.0",
"jpeg-js": "0.4.4",
"music-metadata": "11.12.3"
},
"devDependencies": {
+3
View File
@@ -523,6 +523,9 @@ importers:
convex:
specifier: ^1.40.0
version: 1.42.1(react@19.3.1)
jpeg-js:
specifier: 0.4.4
version: 0.4.4
music-metadata:
specifier: ^11.16.0
version: 11.16.1(supports-color@8.1.1)