Files
otunes/convex/playback.ts
T

397 lines
9.8 KiB
TypeScript

import { getAuthUserId } from "@convex-dev/auth/server"
import { paginationOptsValidator } from "convex/server"
import { ConvexError, v } from "convex/values"
import type { Id } from "./_generated/dataModel"
import type { MutationCtx } from "./_generated/server"
import { mutation, query } from "./_generated/server"
import {
browseSongsFromIds,
type BrowseSong,
getSortedLibrarySongIds,
songsSortDirectionValidator,
songsSortKeyValidator,
} from "./library"
export type QueueSong = BrowseSong & { queueIndex: number }
function shuffleArray<T>(items: T[]): T[] {
const next = [...items]
for (let i = next.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1))
;[next[i], next[j]] = [next[j], next[i]]
}
return next
}
async function requireAuth(ctx: MutationCtx) {
const userId = await getAuthUserId(ctx)
if (userId === null) {
throw new ConvexError("Not authenticated")
}
return userId
}
function uniqueSongIds(songIds: Id<"songs">[]) {
return [...new Set(songIds)]
}
async function setQueueState(
ctx: MutationCtx,
userId: Id<"users">,
patch: {
songQueue: Id<"songs">[]
shuffleEnabled?: boolean
currentSongProgress?: number
}
) {
await ctx.db.patch(userId, {
songQueue: patch.songQueue,
currentSongProgress: patch.currentSongProgress ?? 0,
...(patch.shuffleEnabled !== undefined
? { shuffleEnabled: patch.shuffleEnabled }
: {}),
})
}
export const getPlaybackState = query({
args: {},
handler: async (ctx) => {
const userId = await getAuthUserId(ctx)
if (userId === null) {
return null
}
const user = await ctx.db.get(userId)
if (!user) {
return null
}
const songIds = user.songQueue ?? []
const currentSong =
songIds.length > 0
? ((await browseSongsFromIds(ctx, [songIds[0]]))[0] ?? null)
: null
return {
queueSongIds: songIds,
currentSong,
shuffleEnabled: user.shuffleEnabled ?? false,
repeatEnabled: user.repeatEnabled ?? ("none" as const),
currentSongProgress: user.currentSongProgress ?? 0,
}
},
})
export const getQueuePaginated = query({
args: {
paginationOpts: paginationOptsValidator,
queueVersion: v.string(),
},
handler: async (ctx, args) => {
const userId = await getAuthUserId(ctx)
if (userId === null) {
return { page: [], isDone: true, continueCursor: "" }
}
const user = await ctx.db.get(userId)
if (!user) {
return { page: [], isDone: true, continueCursor: "" }
}
const songIds = user.songQueue ?? []
const startIndex = args.paginationOpts.cursor
? Number.parseInt(args.paginationOpts.cursor, 10)
: 0
const endIndex = Math.min(
startIndex + args.paginationOpts.numItems,
songIds.length
)
const pageIds = songIds.slice(startIndex, endIndex)
const songs = await browseSongsFromIds(ctx, pageIds)
const page: QueueSong[] = songs.map((song, index) => ({
...song,
queueIndex: startIndex + index,
}))
const isDone = endIndex >= songIds.length
return {
page,
isDone,
continueCursor: isDone ? "" : String(endIndex),
}
},
})
export const playInOrder = mutation({
args: { songIds: v.array(v.id("songs")) },
handler: async (ctx, { songIds }) => {
const userId = await requireAuth(ctx)
const queue = uniqueSongIds(songIds)
await setQueueState(ctx, userId, {
songQueue: queue,
shuffleEnabled: false,
})
},
})
export const playShuffled = mutation({
args: { songIds: v.array(v.id("songs")) },
handler: async (ctx, { songIds }) => {
const userId = await requireAuth(ctx)
const queue = shuffleArray(uniqueSongIds(songIds))
await setQueueState(ctx, userId, { songQueue: queue })
},
})
function orderSongsForInsert(
songIds: Id<"songs">[],
shuffleEnabled: boolean
): Id<"songs">[] {
return shuffleEnabled ? shuffleArray(songIds) : songIds
}
export const addToQueueNext = mutation({
args: { songIds: v.array(v.id("songs")) },
handler: async (ctx, { songIds }) => {
if (songIds.length === 0) {
return
}
const userId = await requireAuth(ctx)
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const toAdd = orderSongsForInsert(songIds, user.shuffleEnabled ?? false)
const queue = user.songQueue ?? []
if (queue.length === 0) {
await setQueueState(ctx, userId, { songQueue: toAdd })
return
}
const [current, ...rest] = queue
await setQueueState(ctx, userId, {
songQueue: [current, ...toAdd, ...rest],
})
},
})
export const addToQueueLast = mutation({
args: { songIds: v.array(v.id("songs")) },
handler: async (ctx, { songIds }) => {
if (songIds.length === 0) {
return
}
const userId = await requireAuth(ctx)
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const toAdd = orderSongsForInsert(songIds, user.shuffleEnabled ?? false)
const queue = user.songQueue ?? []
await setQueueState(ctx, userId, {
songQueue: queue.length === 0 ? toAdd : [...queue, ...toAdd],
})
},
})
export const playFromSong = mutation({
args: {
songId: v.id("songs"),
songIds: v.array(v.id("songs")),
},
handler: async (ctx, { songId, songIds }) => {
const userId = await requireAuth(ctx)
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const index = songIds.indexOf(songId)
const rest = index === -1 ? [] : songIds.slice(index + 1)
const queueRest = user.shuffleEnabled ? shuffleArray(rest) : rest
await setQueueState(ctx, userId, {
songQueue: [songId, ...queueRest],
})
},
})
export const playFromLibrarySong = mutation({
args: {
songId: v.id("songs"),
sortKey: songsSortKeyValidator,
sortDirection: songsSortDirectionValidator,
},
handler: async (ctx, { songId, sortKey, sortDirection }) => {
const userId = await requireAuth(ctx)
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const songIds = await getSortedLibrarySongIds(ctx, sortKey, sortDirection)
const index = songIds.indexOf(songId)
const rest = index === -1 ? [] : songIds.slice(index + 1)
const queueRest = user.shuffleEnabled ? shuffleArray(rest) : rest
await setQueueState(ctx, userId, {
songQueue: [songId, ...queueRest],
})
},
})
export const toggleShuffle = mutation({
args: {},
handler: async (ctx) => {
const userId = await requireAuth(ctx)
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const shuffleEnabled = !(user.shuffleEnabled ?? false)
const queue = user.songQueue ?? []
if (shuffleEnabled && queue.length > 1) {
const [current, ...upNext] = queue
await ctx.db.patch(userId, {
shuffleEnabled: true,
songQueue: [current, ...shuffleArray(upNext)],
})
return
}
await ctx.db.patch(userId, { shuffleEnabled })
},
})
export const cycleRepeat = mutation({
args: {},
handler: async (ctx) => {
const userId = await requireAuth(ctx)
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const current = user.repeatEnabled ?? "none"
const next =
current === "none" ? "once" : current === "once" ? "always" : "none"
await ctx.db.patch(userId, { repeatEnabled: next })
},
})
export const clearQueue = mutation({
args: {},
handler: async (ctx) => {
const userId = await requireAuth(ctx)
await ctx.db.patch(userId, {
songQueue: [],
currentSongProgress: 0,
})
},
})
export const reorderQueue = mutation({
args: { songIds: v.array(v.id("songs")) },
handler: async (ctx, { songIds }) => {
const userId = await requireAuth(ctx)
await ctx.db.patch(userId, { songQueue: songIds })
},
})
export const skipToQueueIndex = mutation({
args: { index: v.number() },
handler: async (ctx, { index }) => {
const userId = await requireAuth(ctx)
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const queue = user.songQueue ?? []
if (index < 0 || index >= queue.length) {
return
}
await ctx.db.patch(userId, {
songQueue: [...queue.slice(index), ...queue.slice(0, index)],
currentSongProgress: 0,
})
},
})
export const skipNext = mutation({
args: {},
handler: async (ctx) => {
const userId = await requireAuth(ctx)
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const queue = user.songQueue ?? []
if (queue.length === 0) {
return
}
const repeat = user.repeatEnabled ?? "none"
if (repeat === "once") {
await ctx.db.patch(userId, { currentSongProgress: 0 })
return
}
if (queue.length === 1 && repeat === "none") {
await ctx.db.patch(userId, {
songQueue: [],
currentSongProgress: 0,
})
return
}
const [current, ...rest] = queue
const nextQueue =
repeat === "always" ? [...rest, current] : rest
await ctx.db.patch(userId, {
songQueue: nextQueue,
currentSongProgress: 0,
})
},
})
export const skipPrevious = mutation({
args: {},
handler: async (ctx) => {
const userId = await requireAuth(ctx)
const user = await ctx.db.get(userId)
if (!user) {
throw new ConvexError("User not found")
}
const queue = user.songQueue ?? []
if (queue.length <= 1) {
await ctx.db.patch(userId, { currentSongProgress: 0 })
return
}
const last = queue[queue.length - 1]
const nextQueue = [last, ...queue.slice(0, -1)]
await ctx.db.patch(userId, {
songQueue: nextQueue,
currentSongProgress: 0,
})
},
})