105 lines
3.2 KiB
TypeScript
105 lines
3.2 KiB
TypeScript
import {
|
|
DOWNLOAD_QUALITIES,
|
|
downloadOptions,
|
|
downloadPlan,
|
|
estimatedAacBytes,
|
|
type DownloadOptionsResponse,
|
|
} from "@otunes/convex/download-quality"
|
|
import { audioInfo } from "@/lib/server-audio-info"
|
|
import { getSongSources } from "@/lib/server-song"
|
|
import { NextRequest, NextResponse, userAgent } from "next/server"
|
|
import fs from "node:fs/promises"
|
|
|
|
const MAX_SONGS = 5000
|
|
|
|
type FileSize = { bytes: number; estimated: boolean }
|
|
|
|
/**
|
|
* Sizes every quality the songs can download in. Files sent as-is have exact
|
|
* sizes; re-encodes (including ALAC to FLAC) are estimates.
|
|
*/
|
|
export async function POST(request: NextRequest) {
|
|
const body = (await request.json().catch(() => null)) as {
|
|
songIds?: unknown
|
|
losslessFormat?: unknown
|
|
} | null
|
|
const songIds = body?.songIds
|
|
if (
|
|
!Array.isArray(songIds) ||
|
|
songIds.length > MAX_SONGS ||
|
|
!songIds.every((id) => typeof id === "string")
|
|
) {
|
|
return new Response("Expected songIds", { status: 400 })
|
|
}
|
|
const acceptsAlac =
|
|
userAgent(request).browser.name === "Safari" ||
|
|
body?.losslessFormat === "alac"
|
|
|
|
let songs: Awaited<ReturnType<typeof getSongSources>>
|
|
try {
|
|
songs = await getSongSources(songIds)
|
|
} catch {
|
|
return new Response("Not found", { status: 404 })
|
|
}
|
|
|
|
const fileSizes = new Map<string, Promise<FileSize>>()
|
|
const sizeOf = (path: string, source: string, seconds: number) => {
|
|
let size = fileSizes.get(path)
|
|
if (!size) {
|
|
size = (async () => {
|
|
const { size: bytes } = await fs.stat(path)
|
|
if (source !== "lossless" || acceptsAlac) {
|
|
return { bytes, estimated: false }
|
|
}
|
|
// ALAC is converted to FLAC for clients that cannot play it.
|
|
const estimated = (await audioInfo(path)).codec === "ALAC"
|
|
return { bytes, estimated }
|
|
})().catch(() => ({
|
|
bytes: estimatedAacBytes(seconds, 256),
|
|
estimated: true,
|
|
}))
|
|
fileSizes.set(path, size)
|
|
}
|
|
return size
|
|
}
|
|
|
|
const totals = await Promise.all(
|
|
DOWNLOAD_QUALITIES.map(async (quality) => {
|
|
const sizes = await Promise.all(
|
|
songs.map((song) => {
|
|
const plan = downloadPlan(song.files, quality)
|
|
if (plan.kbps > 0) {
|
|
return {
|
|
bytes: estimatedAacBytes(song.length, plan.kbps),
|
|
estimated: true,
|
|
}
|
|
}
|
|
return sizeOf(song.files[plan.source], plan.source, song.length)
|
|
})
|
|
)
|
|
return {
|
|
quality,
|
|
bytes: sizes.reduce((total, size) => total + size.bytes, 0),
|
|
estimated: sizes.some((size) => size.estimated),
|
|
}
|
|
})
|
|
)
|
|
|
|
const response: DownloadOptionsResponse = {
|
|
songs: songs.map((song) => ({
|
|
id: song._id,
|
|
albumId: song.album,
|
|
files: Object.fromEntries(
|
|
Object.keys(song.files).map((codec) => [codec, true as const])
|
|
),
|
|
})),
|
|
options: downloadOptions(songs.map((song) => song.files)).map((option) => {
|
|
const total = totals.find(({ quality }) => quality === option.quality)!
|
|
return { ...option, bytes: total.bytes, estimated: total.estimated }
|
|
}),
|
|
}
|
|
return NextResponse.json(response, {
|
|
headers: { "Cache-Control": "no-store" },
|
|
})
|
|
}
|