@gigamusic/admin 0.1.0

package/src/handlers/links.ts

@@ -0,0 +1,117 @@
+import type { AdminDeps, RouteHandler } from "../lib/types";
+import type { LinkInput } from "@gigamusic/db";
+import { badRequest, json, notFound, unauthorized } from "../lib/responses";
+import { isAdminAuthenticated } from "../lib/session";
+
+interface LinkBody {
+  id?: unknown;
+  title?: unknown;
+  url?: unknown;
+  position?: unknown;
+  isVisible?: unknown;
+  showOnHero?: unknown;
+}
+
+interface ReorderBody {
+  orderedIds?: unknown;
+}
+
+function toLinkInput(body: LinkBody): LinkInput | null {
+  const title = typeof body.title === "string" ? body.title : null;
+  const url = typeof body.url === "string" ? body.url : null;
+  if (!title || !url) return null;
+  return {
+    id: typeof body.id === "number" && Number.isFinite(body.id) ? body.id : undefined,
+    title,
+    url,
+    position: typeof body.position === "number" ? body.position : undefined,
+    isVisible: typeof body.isVisible === "boolean" ? body.isVisible : undefined,
+    showOnHero: typeof body.showOnHero === "boolean" ? body.showOnHero : undefined,
+  };
+}
+
+/**
+ * GET/POST/PUT/DELETE /api/admin/links — manages the global `/links` page
+ * link list. (Per-release link pages live in `@gigamusic/links`.)
+ *
+ * PUT accepts either a partial single-link update or `{ orderedIds: [...] }`
+ * to reorder the whole list in one round-trip.
+ *
+ * DELETE expects `?id=...`.
+ */
+export function createAdminLinksHandlers(deps: AdminDeps): {
+  GET: RouteHandler;
+  POST: RouteHandler;
+  PUT: RouteHandler;
+  DELETE: RouteHandler;
+} {
+  return {
+    GET: async () => {
+      if (!(await isAdminAuthenticated(deps.adminSessionSecret))) {
+        return unauthorized();
+      }
+      return json(await deps.queries.listAllLinks());
+    },
+    POST: async (req) => {
+      if (!(await isAdminAuthenticated(deps.adminSessionSecret))) {
+        return unauthorized();
+      }
+      const body = (await safeJson(req)) as LinkBody;
+      const input = toLinkInput(body);
+      if (!input) return badRequest("title and url are required");
+      const link = await deps.queries.upsertLink(input);
+      return json(link, { status: 201 });
+    },
+    PUT: async (req) => {
+      if (!(await isAdminAuthenticated(deps.adminSessionSecret))) {
+        return unauthorized();
+      }
+      const body = (await safeJson(req)) as LinkBody & ReorderBody;
+      if (Array.isArray(body.orderedIds)) {
+        const ids = body.orderedIds
+          .map((x) => (typeof x === "number" ? x : Number(x)))
+          .filter((n) => Number.isFinite(n));
+        await deps.queries.reorderLinks(ids);
+        return json({ ok: true });
+      }
+      const id = typeof body.id === "number" && Number.isFinite(body.id) ? body.id : null;
+      if (id == null) return badRequest("id is required");
+      // upsertLink handles partial updates when given an id; pass through
+      // every supplied field.
+      const link = await deps.queries.upsertLink({
+        id,
+        title: typeof body.title === "string" ? body.title : "",
+        url: typeof body.url === "string" ? body.url : "",
+        position: typeof body.position === "number" ? body.position : undefined,
+        isVisible: typeof body.isVisible === "boolean" ? body.isVisible : undefined,
+        showOnHero: typeof body.showOnHero === "boolean" ? body.showOnHero : undefined,
+      });
+      return json(link);
+    },
+    DELETE: async (req) => {
+      if (!(await isAdminAuthenticated(deps.adminSessionSecret))) {
+        return unauthorized();
+      }
+      const url = new URL(req.url);
+      const idRaw = url.searchParams.get("id");
+      if (!idRaw) return badRequest("id is required");
+      const id = Number(idRaw);
+      if (!Number.isFinite(id)) return badRequest("id is required");
+      try {
+        await deps.queries.deleteLink(id);
+      } catch (err) {
+        deps.logger?.warn("deleteLink failed", { error: String(err) });
+        return notFound("Link not found");
+      }
+      return json({ ok: true });
+    },
+  };
+}
+
+async function safeJson(req: Request): Promise<unknown> {
+  try {
+    return await req.json();
+  } catch {
+    return {};
+  }
+}

package/src/handlers/orders.ts

@@ -0,0 +1,21 @@
+import type { AdminDeps, RouteHandler } from "../lib/types";
+import { badRequest, json, unauthorized } from "../lib/responses";
+import { isAdminAuthenticated } from "../lib/session";
+
+/**
+ * GET /api/admin/orders?email=… — returns the order history for a given email
+ * address. The plan only requires an admin "view" surface; this is the small
+ * read endpoint that backs the OrdersPage filter.
+ */
+export function createAdminOrdersHandler(deps: AdminDeps): RouteHandler {
+  return async (req) => {
+    if (!(await isAdminAuthenticated(deps.adminSessionSecret))) {
+      return unauthorized();
+    }
+    const url = new URL(req.url);
+    const email = url.searchParams.get("email");
+    if (!email) return badRequest("email query param is required");
+    const orders = await deps.queries.listOrdersByEmail(email);
+    return json(orders);
+  };
+}

package/src/handlers/releases.ts

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import {
+  ReleaseInputSchema,
+  TrackInputSchema,
+  type ReleaseInput,
+} from "@gigamusic/core";
+import type { AdminDeps, RouteHandler } from "../lib/types";
+import { badRequest, json, notFound, unauthorized } from "../lib/responses";
+import { isAdminAuthenticated } from "../lib/session";
+
+/**
+ * Draft releases skip the strict published-validation rules so an admin can
+ * save in-progress work. We coerce missing numerics to 0 and missing track
+ * arrays to `[]` so the persistence call sees a complete shape.
+ */
+const DraftReleaseSchema = ReleaseInputSchema.extend({
+  isPublished: z.literal(false),
+  price: z.number().int().nonnegative().optional(),
+  slug: z.string().optional(),
+  type: z.enum(["album", "single"]).optional(),
+  tracks: z.array(TrackInputSchema.partial({ files: true, price: true })).optional(),
+});
+
+const ReleasePayloadSchema = z.union([ReleaseInputSchema, DraftReleaseSchema]);
+
+/**
+ * Flatten zod issues into `{ "tracks[0].artist": ["msg", …] }` shape — matches
+ * the field-error format the admin form expects.
+ */
+function flattenIssues(error: z.ZodError): Record<string, string[]> {
+  const out: Record<string, string[]> = {};
+  for (const issue of error.issues) {
+    const key = issue.path
+      .map((seg: PropertyKey) => (typeof seg === "number" ? `[${seg}]` : `.${String(seg)}`))
+      .join("")
+      .replace(/^\./, "");
+    if (!key) continue;
+    (out[key] ??= []).push(issue.message);
+  }
+  return out;
+}
+
+function requireAuth(deps: Pick<AdminDeps, "adminSessionSecret">) {
+  return isAdminAuthenticated(deps.adminSessionSecret);
+}
+
+/** GET /api/admin/releases and POST /api/admin/releases. */
+export function createAdminReleasesHandlers(
+  deps: AdminDeps,
+): { GET: RouteHandler; POST: RouteHandler } {
+  return {
+    GET: async () => {
+      if (!(await requireAuth(deps))) return unauthorized();
+      const releases = await deps.queries.listAllReleases();
+      return json(releases);
+    },
+    POST: async (req) => {
+      if (!(await requireAuth(deps))) return unauthorized();
+      const body = await readJson(req);
+      if (!body.ok) return badRequest("Invalid JSON");
+
+      const parsed = ReleasePayloadSchema.safeParse(body.value);
+      if (!parsed.success) {
+        return badRequest("Validation failed", {
+          fieldErrors: flattenIssues(parsed.error),
+        });
+      }
+      try {
+        const release = await deps.queries.createRelease(parsed.data as ReleaseInput);
+        return json(release, { status: 201 });
+      } catch (err) {
+        if (isUniqueConstraintError(err)) {
+          return badRequest("Slug already exists", {
+            fieldErrors: { slug: ["Slug already exists"] },
+          });
+        }
+        deps.logger?.error("createRelease failed", { error: String(err) });
+        throw err;
+      }
+    },
+  };
+}
+
+/** GET/PUT/DELETE /api/admin/releases/[id]. */
+export function createAdminReleaseByIdHandlers(
+  deps: AdminDeps,
+): { GET: RouteHandler; PUT: RouteHandler; DELETE: RouteHandler } {
+  return {
+    GET: async (_req, ctx) => {
+      if (!(await requireAuth(deps))) return unauthorized();
+      const id = await resolveIdParam(ctx);
+      if (id == null) return badRequest("Missing id");
+      const all = await deps.queries.listAllReleases();
+      const found = all.find((r) => r.id === id);
+      return found ? json(found) : notFound("Release not found");
+    },
+    PUT: async (req, ctx) => {
+      if (!(await requireAuth(deps))) return unauthorized();
+      const id = await resolveIdParam(ctx);
+      if (id == null) return badRequest("Missing id");
+
+      const body = await readJson(req);
+      if (!body.ok) return badRequest("Invalid JSON");
+      const parsed = ReleasePayloadSchema.safeParse(body.value);
+      if (!parsed.success) {
+        return badRequest("Validation failed", {
+          fieldErrors: flattenIssues(parsed.error),
+        });
+      }
+
+      try {
+        const updated = await deps.queries.updateRelease(
+          id,
+          parsed.data as Partial<ReleaseInput>,
+        );
+        return json(updated);
+      } catch (err) {
+        if (isUniqueConstraintError(err)) {
+          return badRequest("Slug already exists", {
+            fieldErrors: { slug: ["Slug already exists"] },
+          });
+        }
+        deps.logger?.error("updateRelease failed", { error: String(err) });
+        throw err;
+      }
+    },
+    DELETE: async (_req, ctx) => {
+      if (!(await requireAuth(deps))) return unauthorized();
+      const id = await resolveIdParam(ctx);
+      if (id == null) return badRequest("Missing id");
+
+      // Snapshot storage keys before the cascade nukes the rows, so we can
+      // clean up the bucket without an orphaned-file scan.
+      const all = await deps.queries.listAllReleases();
+      const release = all.find((r) => r.id === id);
+      if (!release) return notFound("Release not found");
+
+      const keys = collectStorageKeys(release, deps.storage);
+      await deps.queries.deleteRelease(id);
+      await Promise.all(
+        keys.map((key) =>
+          deps.storage
+            .deleteFile(key)
+            .catch((err) =>
+              deps.logger?.warn("storage.deleteFile failed", {
+                key,
+                error: String(err),
+              }),
+            ),
+        ),
+      );
+      return json({ ok: true });
+    },
+  };
+}
+
+interface ReleaseWithFiles {
+  coverImageUrl: string | null;
+  tracks: Array<{ files: Array<{ storageKey: string }> }>;
+}
+
+function collectStorageKeys(
+  release: ReleaseWithFiles,
+  storage: { keyFromPublicUrl: (u: string) => string },
+): string[] {
+  const keys: string[] = [];
+  if (release.coverImageUrl) {
+    try {
+      // Cover image is stored as a public URL — round-trip to the key.
+      keys.push(storage.keyFromPublicUrl(release.coverImageUrl));
+    } catch {
+      // Non-public URL (e.g. external cover) — skip cleanup.
+    }
+  }
+  for (const track of release.tracks) {
+    for (const file of track.files) {
+      keys.push(file.storageKey);
+    }
+  }
+  return keys;
+}
+
+function isUniqueConstraintError(err: unknown): boolean {
+  if (typeof err !== "object" || err === null) return false;
+  const code = (err as { code?: unknown }).code;
+  if (code === "P2002") return true;
+  // Some Queries implementations may surface plain Errors with this prefix.
+  const message = (err as { message?: unknown }).message;
+  return typeof message === "string" && /slug.*(already|exists|unique)/i.test(message);
+}
+
+async function resolveIdParam(
+  ctx?: { params: Promise<Record<string, string>> } | undefined,
+): Promise<number | null> {
+  if (!ctx) return null;
+  const params = await ctx.params;
+  if (params.id == null) return null;
+  const id = Number(params.id);
+  return Number.isFinite(id) ? id : null;
+}
+
+async function readJson(req: Request): Promise<{ ok: true; value: unknown } | { ok: false }> {
+  try {
+    return { ok: true, value: await req.json() };
+  } catch {
+    return { ok: false };
+  }
+}
+

package/src/handlers/settings.ts

@@ -0,0 +1,54 @@
+import type { AdminDeps, RouteHandler } from "../lib/types";
+import { badRequest, json, unauthorized } from "../lib/responses";
+import { isAdminAuthenticated } from "../lib/session";
+
+interface SettingPayload {
+  key?: unknown;
+  value?: unknown;
+}
+
+/**
+ * GET/PUT /api/admin/settings.
+ *
+ * GET returns all known settings as a `Record<string, unknown>`. PUT upserts a
+ * single key/value pair; the consumer's `queries.setSetting` is the source of
+ * truth for serialization (JSON stringification happens inside the db layer).
+ *
+ * Per-key validation is intentionally not done here — settings are
+ * heterogeneous and the admin form for each setting validates before
+ * submitting.
+ */
+export function createAdminSettingsHandlers(
+  deps: AdminDeps,
+): { GET: RouteHandler; PUT: RouteHandler } {
+  return {
+    GET: async (req) => {
+      if (!(await isAdminAuthenticated(deps.adminSessionSecret))) {
+        return unauthorized();
+      }
+      const url = new URL(req.url);
+      const key = url.searchParams.get("key");
+      if (key) {
+        const value = await deps.queries.getSetting(key);
+        return json({ key, value });
+      }
+      return json({});
+    },
+    PUT: async (req) => {
+      if (!(await isAdminAuthenticated(deps.adminSessionSecret))) {
+        return unauthorized();
+      }
+      let body: SettingPayload;
+      try {
+        body = (await req.json()) as SettingPayload;
+      } catch {
+        return badRequest("Invalid JSON");
+      }
+      if (typeof body.key !== "string" || body.key.length === 0) {
+        return badRequest("key is required");
+      }
+      await deps.queries.setSetting(body.key, body.value);
+      return json({ ok: true });
+    },
+  };
+}

package/src/handlers/upload.ts

@@ -0,0 +1,286 @@
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { writeFile, readFile, unlink, stat } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import type { AdminDeps, RouteHandler } from "../lib/types";
+import { badRequest, json, serverError, unauthorized } from "../lib/responses";
+import { isAdminAuthenticated } from "../lib/session";
+
+// Path segments allow the punctuation common in real-world track filenames
+// alongside alphanumerics, dashes, dots, underscores, spaces, parens, and
+// slashes. Must start with a known top-level prefix and end with an allowed
+// extension (case-insensitive). Path traversal is blocked separately.
+const KEY_RE =
+  /^(audio|images|uploads)\/[A-Za-z0-9_.\-() /'&,!+[\]=]+\.(wav|mp3|jpg|jpeg|png|webp)$/i;
+
+const ALLOWED_CONTENT_TYPES = new Set([
+  "audio/wav",
+  "audio/x-wav",
+  "audio/mpeg",
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  // Some browsers serve .wav as octet-stream when the OS has no handler.
+  "application/octet-stream",
+]);
+
+interface ProcessBody {
+  key?: unknown;
+  trackId?: unknown;
+  metadata?: unknown;
+  artDataUrl?: unknown;
+  coverImageUrl?: unknown;
+}
+
+/** Build POST /api/admin/upload/presign. */
+export function createAdminUploadPresignHandler(deps: AdminDeps): RouteHandler {
+  return async (req) => {
+    if (!(await isAdminAuthenticated(deps.adminSessionSecret))) {
+      return unauthorized();
+    }
+
+    const body = (await safeJson(req)) as {
+      key?: unknown;
+      contentType?: unknown;
+    };
+    const key = typeof body.key === "string" ? body.key : "";
+    const contentType =
+      typeof body.contentType === "string" ? body.contentType : "";
+
+    if (!key || !contentType) {
+      return badRequest("key and contentType are required");
+    }
+    if (key.includes("..") || !KEY_RE.test(key)) {
+      return badRequest(
+        "Invalid key — must be under audio/, images/, or uploads/ with an allowed extension",
+      );
+    }
+    if (!ALLOWED_CONTENT_TYPES.has(contentType)) {
+      return badRequest(`Unsupported contentType: ${contentType}`);
+    }
+
+    const result = await deps.storage.getPresignedUploadUrl(key, { contentType });
+    return json(result);
+  };
+}
+
+interface AudioMetadata {
+  title?: string;
+  artist?: string;
+  album?: string;
+  genre?: string;
+  trackNumber?: number;
+  trackTotal?: number;
+  year?: number;
+}
+
+/**
+ * Coerce arbitrary client input into a clean metadata object. String fields
+ * are trimmed: stray whitespace embeds into the file and trips up players
+ * like Apple Music that treat otherwise-identical tracks as separate albums.
+ */
+function parseMetadata(raw: unknown): AudioMetadata | undefined {
+  if (!raw || typeof raw !== "object") return undefined;
+  const r = raw as Record<string, unknown>;
+  const out: AudioMetadata = {};
+  if (typeof r.title === "string" && r.title.trim()) out.title = r.title.trim();
+  if (typeof r.artist === "string" && r.artist.trim()) out.artist = r.artist.trim();
+  if (typeof r.album === "string" && r.album.trim()) out.album = r.album.trim();
+  if (typeof r.genre === "string" && r.genre.trim()) out.genre = r.genre.trim();
+  if (typeof r.trackNumber === "number") out.trackNumber = r.trackNumber;
+  if (typeof r.trackTotal === "number") out.trackTotal = r.trackTotal;
+  if (typeof r.year === "number") out.year = r.year;
+  return Object.keys(out).length ? out : undefined;
+}
+
+/** Decode a `data:<mime>;base64,<data>` URL into a Buffer, or null. */
+function bufferFromDataUrl(value: unknown): Buffer | null {
+  if (typeof value !== "string") return null;
+  const match = /^data:[^;,]*;base64,([A-Za-z0-9+/=]+)$/.exec(value);
+  if (!match) return null;
+  try {
+    return Buffer.from(match[1] ?? "", "base64");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build POST /api/admin/upload/process. After the client direct-uploads a
+ * WAV to R2 via the presigned URL, this handler:
+ *   1. fetches the WAV stream out of storage
+ *   2. transcodes to 320kbps MP3 and embeds ID3 tags (via `@gigamusic/audio`)
+ *   3. uploads the MP3 back to storage at the sibling `.mp3` key
+ *   4. tags the original WAV in place
+ *   5. records both files against `trackId` via `queries.upsertTrackFile`
+ *      (if `trackId` is supplied; new releases call this without an id
+ *      because the track row isn't created yet — the release POST handler
+ *      persists the files alongside the row).
+ */
+export function createAdminUploadProcessHandler(deps: AdminDeps): RouteHandler {
+  return async (req) => {
+    if (!(await isAdminAuthenticated(deps.adminSessionSecret))) {
+      return unauthorized();
+    }
+
+    const body = (await safeJson(req)) as ProcessBody;
+    const key = typeof body.key === "string" ? body.key : "";
+    if (!key.endsWith(".wav")) {
+      return badRequest("A .wav storage key is required");
+    }
+
+    const metadata = parseMetadata(body.metadata);
+    const mp3Key = key.replace(/\.wav$/i, ".mp3");
+    const trackId =
+      typeof body.trackId === "number" && Number.isFinite(body.trackId)
+        ? body.trackId
+        : null;
+
+    let artBuffer = bufferFromDataUrl(body.artDataUrl);
+    if (
+      !artBuffer &&
+      typeof body.coverImageUrl === "string" &&
+      body.coverImageUrl
+    ) {
+      try {
+        artBuffer = await deps.storage.getFileBuffer(
+          deps.storage.keyFromPublicUrl(body.coverImageUrl),
+        );
+      } catch (err) {
+        deps.logger?.warn("cover-image fetch failed; proceeding without art", {
+          error: String(err),
+        });
+      }
+    }
+
+    const tmpId = randomUUID();
+    const wavPath = join(tmpdir(), `${tmpId}.wav`);
+    const taggedWavPath = join(tmpdir(), `${tmpId}.tagged.wav`);
+    const mp3Path = join(tmpdir(), `${tmpId}.mp3`);
+    const coverPath = artBuffer ? join(tmpdir(), `${tmpId}.img`) : undefined;
+
+    try {
+      if (artBuffer && coverPath) await writeFile(coverPath, artBuffer);
+
+      // 1. Pull the WAV down so the tag step can rewrite it in place.
+      const wavBuf = await deps.storage.getFileBuffer(key);
+      await writeFile(wavPath, wavBuf);
+
+      const tags = metadataToTags(metadata);
+
+      // 2. Tag the WAV.
+      await deps.audio.tagWav({
+        inputPath: wavPath,
+        outputPath: taggedWavPath,
+        tags,
+      });
+      await deps.storage.uploadBuffer(
+        await readFile(taggedWavPath),
+        key,
+        "audio/wav",
+      );
+
+      // 3. Generate 320kbps MP3 from the tagged WAV.
+      // We piggy-back on `generatePreview` for the ffmpeg call but request a
+      // ~24h duration so the full track is encoded (ffmpeg stops at EOF). The
+      // post-tag step then attaches ID3 frames + artwork — `generatePreview`
+      // intentionally strips metadata for the public 30s preview case.
+      await deps.audio.generatePreview({
+        inputPath: taggedWavPath,
+        outputPath: mp3Path,
+        startSeconds: 0,
+        durationSeconds: 24 * 60 * 60,
+        bitrateKbps: 320,
+      });
+
+      await deps.audio.tagMp3({
+        inputPath: mp3Path,
+        outputPath: mp3Path,
+        tags,
+        coverArt: artBuffer ?? undefined,
+      });
+
+      const mp3Stream = createReadStream(mp3Path);
+      const mp3Upload = await deps.storage.uploadStream(
+        mp3Stream,
+        mp3Key,
+        "audio/mpeg",
+      );
+
+      let wavFileSize = wavBuf.length;
+      try {
+        wavFileSize = (await stat(taggedWavPath)).size;
+      } catch {
+        // Best-effort; fall back to the pre-tag buffer length.
+      }
+      let mp3FileSize = 0;
+      try {
+        mp3FileSize = (await stat(mp3Path)).size;
+      } catch {
+        // Best-effort.
+      }
+
+      // 4. Persist file rows when the consumer supplied a trackId.
+      if (trackId != null) {
+        await deps.queries.upsertTrackFile({
+          trackId,
+          format: "wav",
+          fileName: basename(key),
+          storageKey: deps.storage.publicUrlFromKey(key),
+          fileSize: wavFileSize,
+        });
+        await deps.queries.upsertTrackFile({
+          trackId,
+          format: "mp3",
+          fileName: basename(mp3Key),
+          storageKey: mp3Upload.url,
+          fileSize: mp3FileSize,
+        });
+      }
+
+      return json({
+        wavUrl: deps.storage.publicUrlFromKey(key),
+        mp3Url: mp3Upload.url,
+        wavFileSize,
+        mp3FileSize,
+      });
+    } catch (err) {
+      deps.logger?.error("upload/process failed", { error: String(err) });
+      const message = err instanceof Error ? err.message : String(err);
+      return serverError("Transcoding failed", { mp3Error: message });
+    } finally {
+      await Promise.allSettled([
+        unlink(wavPath),
+        unlink(taggedWavPath),
+        unlink(mp3Path),
+        coverPath ? unlink(coverPath) : Promise.resolve(),
+      ]);
+    }
+  };
+}
+
+function basename(key: string): string {
+  const slash = key.lastIndexOf("/");
+  return slash < 0 ? key : key.slice(slash + 1);
+}
+
+function metadataToTags(meta: AudioMetadata | undefined) {
+  return {
+    title: meta?.title ?? "",
+    artist: meta?.artist ?? "",
+    album: meta?.album,
+    genre: meta?.genre,
+    trackNumber: meta?.trackNumber,
+    trackTotal: meta?.trackTotal,
+    date: meta?.year != null ? String(meta.year) : undefined,
+  };
+}
+
+async function safeJson(req: Request): Promise<unknown> {
+  try {
+    return await req.json();
+  } catch {
+    return {};
+  }
+}