gerbeur/api/services/dump-service.ts

import {
  APIErrorCode,
  APIException,
  type CreateUrlDumpRequest,
  type Dump,
  type DumpUrlMatch,
  type UpdateDumpRequest,
} from "../model/interfaces.ts";
import {
  db,
  DUMP_SELECT_COLUMNS as SELECT_COLS,
  DUMP_SELECT_COLUMNS_ALIASED as SELECT_COLS_ALIASED,
  dumpApiToRow,
  dumpRowToApi,
  isDumpRow,
} from "../model/db.ts";
import {
  fetchRichContent,
  isValidHttpUrl,
  tryFetchRichContent,
} from "./rich-content-service.ts";
import {
  broadcastDumpDeleted,
  broadcastDumpUpdated,
  broadcastNewDump,
} from "./ws-service.ts";
import {
  notifyMentions,
  notifyUserFollowersNewDump,
} from "./notification-service.ts";
import { makeSlug, UUID_RE } from "../lib/slugify.ts";
import { canonicalizeUrl } from "../lib/canonical-url.ts";
import {
  DUMP_ALLOWED_MIME_PREFIXES,
  DUMP_ALLOWED_MIME_TYPES,
  DUMP_MAX_FILE_SIZE_BYTES,
  DUMPS_DIR,
  THUMBNAILS_DIR,
  VALIDATION,
} from "../config.ts";
import { linkAttachments } from "./attachment-service.ts";
import { relinkBacklinks } from "./backlink-service.ts";
import { attachCategoryIds, setDumpCategories } from "./category-service.ts";

function isAllowedMime(mime: string): boolean {
  return DUMP_ALLOWED_MIME_PREFIXES.some((p) => mime.startsWith(p)) ||
    DUMP_ALLOWED_MIME_TYPES.has(mime);
}

// The JSON routes validate these in isCreateUrlDumpRequest/isUpdateDumpRequest;
// the multipart ones (file create and replace) arrive here unchecked.
function assertFileDumpText(title?: string, comment?: string): void {
  if (title && title.trim().length > VALIDATION.DUMP_TITLE_MAX) {
    throw new APIException(
      APIErrorCode.VALIDATION_ERROR,
      400,
      `Title must be at most ${VALIDATION.DUMP_TITLE_MAX} characters`,
    );
  }
  if (comment && comment.length > VALIDATION.DUMP_COMMENT_MAX) {
    throw new APIException(
      APIErrorCode.VALIDATION_ERROR,
      400,
      `Comment must be at most ${VALIDATION.DUMP_COMMENT_MAX} characters`,
    );
  }
}

function titleFromUrl(url: string): string {
  try {
    return new URL(url).hostname.replace(/^www\./, "");
  } catch {
    return url;
  }
}

export async function createUrlDump(
  request: CreateUrlDumpRequest,
  userId: string,
): Promise<Dump> {
  if (!isValidHttpUrl(request.url)) {
    throw new APIException(APIErrorCode.BAD_REQUEST, 400, "Invalid URL");
  }

  const dumpId = crypto.randomUUID();
  const createdAt = new Date();
  const richContent = await fetchRichContent(request.url);
  // A title typed on the create form wins over the one scraped from the page:
  // the poster has seen the preview and is correcting it.
  const title = request.title?.trim() || richContent?.title ||
    titleFromUrl(request.url);
  const isPrivate = request.isPrivate ?? false;
  const slug = makeSlug(title, dumpId);

  db.prepare(
    `INSERT INTO dumps (id, kind, title, slug, comment, user_id, created_at, url, url_canonical, rich_content, is_private)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);`,
  ).run(
    dumpId,
    "url",
    title,
    slug,
    request.comment ?? null,
    userId,
    createdAt.toISOString(),
    request.url,
    canonicalizeUrl(request.url),
    richContent ? JSON.stringify(richContent) : null,
    isPrivate ? 1 : 0,
  );

  const categoryIds = [...new Set(request.categoryIds ?? [])];
  setDumpCategories(dumpId, categoryIds);

  const dump: Dump = {
    id: dumpId,
    kind: "url",
    title,
    slug,
    comment: request.comment,
    userId,
    createdAt,
    url: request.url,
    richContent,
    voteCount: 0,
    commentCount: 0,
    isPrivate,
    categoryIds,
  };
  if (!isPrivate) {
    broadcastNewDump(dump);
    notifyUserFollowersNewDump(userId, dumpId, title);
  }
  if (request.comment) {
    notifyMentions(userId, request.comment, "dump", dumpId, title);
    linkAttachments(request.comment, dumpId);
  }
  relinkBacklinks("dump_comment", dumpId, dumpId, request.comment ?? "");
  return dump;
}

export async function createFileDump(
  file: File,
  comment: string | undefined,
  userId: string,
  isPrivate = false,
  title?: string,
  categoryIds: string[] = [],
): Promise<Dump> {
  assertFileDumpText(title, comment);
  if (!isAllowedMime(file.type)) {
    throw new APIException(
      APIErrorCode.BAD_REQUEST,
      400,
      `File type '${file.type}' is not allowed`,
    );
  }
  if (file.size > DUMP_MAX_FILE_SIZE_BYTES) {
    throw new APIException(
      APIErrorCode.BAD_REQUEST,
      400,
      "File too large (max 50 MB)",
    );
  }

  const dumpId = crypto.randomUUID();
  const createdAt = new Date();
  const finalTitle = title?.trim() || file.name;
  const slug = makeSlug(finalTitle, dumpId);
  const dedupedCategoryIds = [...new Set(categoryIds)];

  await Deno.mkdir(DUMPS_DIR, { recursive: true });
  const data = new Uint8Array(await file.arrayBuffer());

  try {
    await Deno.writeFile(`${DUMPS_DIR}/${dumpId}`, data);

    db.prepare(
      `INSERT INTO dumps (id, kind, title, slug, comment, user_id, created_at, file_name, file_mime, file_size, is_private)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);`,
    ).run(
      dumpId,
      "file",
      finalTitle,
      slug,
      comment ?? null,
      userId,
      createdAt.toISOString(),
      file.name,
      file.type,
      file.size,
      isPrivate ? 1 : 0,
    );
    setDumpCategories(dumpId, dedupedCategoryIds);
  } catch (err) {
    // Roll back the file if DB insert fails
    await Deno.remove(`${DUMPS_DIR}/${dumpId}`).catch(() => {});
    throw err;
  }

  const dump: Dump = {
    id: dumpId,
    kind: "file",
    title: finalTitle,
    slug,
    comment,
    userId,
    createdAt,
    fileName: file.name,
    fileMime: file.type,
    fileSize: file.size,
    voteCount: 0,
    commentCount: 0,
    isPrivate,
    categoryIds: dedupedCategoryIds,
  };
  if (!isPrivate) {
    broadcastNewDump(dump);
    notifyUserFollowersNewDump(userId, dumpId, finalTitle);
  }
  if (comment) {
    notifyMentions(userId, comment, "dump", dumpId, finalTitle);
    linkAttachments(comment, dumpId);
  }
  relinkBacklinks("dump_comment", dumpId, dumpId, comment ?? "");
  return dump;
}

// Internal fetch — no privacy check. Use only when ownership is already enforced.
function fetchDump(idOrSlug: string): Dump {
  const row = UUID_RE.test(idOrSlug)
    ? db.prepare(`SELECT ${SELECT_COLS} FROM dumps WHERE id = ?;`).get(idOrSlug)
    : db.prepare(`SELECT ${SELECT_COLS} FROM dumps WHERE slug = ?;`).get(
      idOrSlug,
    );
  if (!row || !isDumpRow(row)) {
    throw new APIException(APIErrorCode.NOT_FOUND, 404, "Dump not found");
  }
  return dumpRowToApi(row);
}

// Public fetch — enforces visibility. Returns 404 for private dumps the requester doesn't own.
export function getDump(dumpId: string, requestingUserId?: string): Dump {
  const dump = fetchDump(dumpId);
  if (dump.isPrivate && dump.userId !== requestingUserId) {
    throw new APIException(APIErrorCode.NOT_FOUND, 404, "Dump not found");
  }
  attachCategoryIds([dump]);
  return dump;
}

export function searchDumps(
  query: string,
  page: number,
  limit: number,
  requestingUserId?: string,
): { items: Dump[]; total: number } {
  if (!query.trim()) return { items: [], total: 0 };
  const pattern = `%${query}%`;
  const offset = (page - 1) * limit;

  const searchClause =
    `(title LIKE ? OR comment LIKE ? OR json_extract(rich_content,'$.title') LIKE ? OR json_extract(rich_content,'$.description') LIKE ?)`;
  const searchParams = [pattern, pattern, pattern, pattern] as const;

  if (requestingUserId) {
    const rows = db.prepare(
      `SELECT ${SELECT_COLS} FROM dumps WHERE (is_private = 0 OR user_id = ?) AND ${searchClause} ORDER BY created_at DESC LIMIT ? OFFSET ?;`,
    ).all(requestingUserId, ...searchParams, limit, offset);
    const totalRow = db.prepare(
      `SELECT COUNT(*) as count FROM dumps WHERE (is_private = 0 OR user_id = ?) AND ${searchClause};`,
    ).get(requestingUserId, ...searchParams) as { count: number } | undefined;
    const items = rows.filter(isDumpRow).map(dumpRowToApi);
    attachCategoryIds(items);
    return { items, total: totalRow?.count ?? 0 };
  } else {
    const rows = db.prepare(
      `SELECT ${SELECT_COLS} FROM dumps WHERE is_private = 0 AND ${searchClause} ORDER BY created_at DESC LIMIT ? OFFSET ?;`,
    ).all(...searchParams, limit, offset);
    const totalRow = db.prepare(
      `SELECT COUNT(*) as count FROM dumps WHERE is_private = 0 AND ${searchClause};`,
    ).get(...searchParams) as { count: number } | undefined;
    const items = rows.filter(isDumpRow).map(dumpRowToApi);
    attachCategoryIds(items);
    return { items, total: totalRow?.count ?? 0 };
  }
}

export function listDumps(
  page: number,
  limit: number,
  requestingUserId?: string,
): { items: Dump[]; total: number } {
  const offset = (page - 1) * limit;
  // Show public dumps + the requesting user's own private dumps
  const rows = requestingUserId
    ? db.prepare(
      `SELECT ${SELECT_COLS} FROM dumps WHERE (is_private = 0 OR user_id = ?) ORDER BY created_at DESC LIMIT ? OFFSET ?;`,
    ).all(requestingUserId, limit, offset)
    : db.prepare(
      `SELECT ${SELECT_COLS} FROM dumps WHERE is_private = 0 ORDER BY created_at DESC LIMIT ? OFFSET ?;`,
    ).all(limit, offset);
  const totalRow = requestingUserId
    ? db.prepare(
      `SELECT COUNT(*) as count FROM dumps WHERE (is_private = 0 OR user_id = ?);`,
    ).get(requestingUserId) as { count: number } | undefined
    : db.prepare(
      `SELECT COUNT(*) as count FROM dumps WHERE is_private = 0;`,
    ).get() as { count: number } | undefined;

  if (!rows || !rows.every(isDumpRow)) {
    throw new APIException(
      APIErrorCode.SERVER_ERROR,
      500,
      "Malformed dump data",
    );
  }

  const items = rows.map(dumpRowToApi);
  attachCategoryIds(items);
  return { items, total: totalRow?.count ?? 0 };
}

/**
 * Dumps that already point at the same thing as `url`, newest first.
 *
 * Matched on the canonical key rather than the raw URL, so a link reposted with
 * different tracking parameters, scheme, `www.`, or (for YouTube) in a
 * different share shape still counts as the same dump. Private dumps are
 * visible only to their owner, exactly as everywhere else.
 *
 * Returns a small display-only projection: this feeds a hint on the create
 * form, not a feed.
 */
export function findDumpsByUrl(
  url: string,
  requestingUserId?: string,
  limit = 3,
): DumpUrlMatch[] {
  const canonical = canonicalizeUrl(url);
  if (!canonical) return [];

  const rows = db.prepare(
    `SELECT d.id, d.slug, d.title, d.created_at, d.vote_count, u.username,
       (SELECT COUNT(*) FROM comments WHERE dump_id = d.id AND deleted = 0) as comment_count
     FROM dumps d
     JOIN users u ON u.id = d.user_id
     WHERE d.url_canonical = ? AND (d.is_private = 0 OR d.user_id = ?)
     ORDER BY d.created_at DESC
     LIMIT ?;`,
  ).all(canonical, requestingUserId ?? null, limit) as {
    id: string;
    slug: string | null;
    title: string;
    created_at: string;
    vote_count: number;
    username: string;
    comment_count: number;
  }[];

  return rows.map((row) => ({
    id: row.id,
    slug: row.slug ?? undefined,
    title: row.title,
    username: row.username,
    createdAt: new Date(row.created_at),
    voteCount: row.vote_count,
    commentCount: row.comment_count,
  }));
}

export async function updateDump(
  dumpId: string,
  request: UpdateDumpRequest,
): Promise<Dump> {
  const dump = fetchDump(dumpId);

  const now = new Date();

  // File dumps: title, comment and isPrivate are editable
  if (dump.kind === "file") {
    const title = request.title?.trim() || dump.title;
    const slug = title !== dump.title ? makeSlug(title, dumpId) : dump.slug;
    const updatedDump: Dump = {
      ...dump,
      title,
      slug,
      comment: "comment" in request
        ? (request.comment ?? undefined)
        : dump.comment,
      isPrivate: "isPrivate" in request
        ? (request.isPrivate ?? false)
        : dump.isPrivate,
      updatedAt: now,
    };
    db.prepare(
      `UPDATE dumps SET title = ?, slug = ?, comment = ?, is_private = ?, updated_at = ? WHERE id = ?;`,
    ).run(
      updatedDump.title,
      updatedDump.slug ?? null,
      updatedDump.comment ?? null,
      updatedDump.isPrivate ? 1 : 0,
      now.toISOString(),
      dumpId,
    );
    if (request.categoryIds !== undefined) {
      const ids = [...new Set(request.categoryIds)];
      setDumpCategories(dumpId, ids);
      updatedDump.categoryIds = ids;
    } else {
      attachCategoryIds([updatedDump]);
    }
    if (updatedDump.isPrivate && !dump.isPrivate) broadcastDumpDeleted(dumpId);
    else if (!updatedDump.isPrivate) broadcastDumpUpdated(updatedDump);
    // Going public is an arrival for everyone who couldn't see it before.
    if (dump.isPrivate && !updatedDump.isPrivate) broadcastNewDump(updatedDump);
    if (updatedDump.comment) {
      notifyMentions(
        dump.userId,
        updatedDump.comment,
        "dump",
        dumpId,
        updatedDump.title,
      );
      linkAttachments(updatedDump.comment, dumpId);
    }
    relinkBacklinks("dump_comment", dumpId, dumpId, updatedDump.comment ?? "");
    return updatedDump;
  }

  // URL dumps
  const newUrl = request.url ?? dump.url!;

  if (!isValidHttpUrl(newUrl)) {
    throw new APIException(APIErrorCode.BAD_REQUEST, 400, "Invalid URL");
  }

  let { richContent, title } = dump;

  if (newUrl !== dump.url) {
    richContent = await fetchRichContent(newUrl);
    title = richContent?.title ?? titleFromUrl(newUrl);
  }

  if (request.title?.trim()) {
    title = request.title.trim();
  }

  const newSlug = title !== dump.title ? makeSlug(title, dumpId) : dump.slug;
  const updatedDump: Dump = {
    ...dump,
    title,
    slug: newSlug,
    comment: "comment" in request
      ? (request.comment ?? undefined)
      : dump.comment,
    url: newUrl,
    richContent,
    isPrivate: "isPrivate" in request
      ? (request.isPrivate ?? false)
      : dump.isPrivate,
    updatedAt: now,
  };

  const row = dumpApiToRow(updatedDump);
  const result = db.prepare(
    `UPDATE dumps SET title = ?, slug = ?, comment = ?, url = ?, url_canonical = ?, rich_content = ?, is_private = ?, updated_at = ? WHERE id = ?;`,
  ).run(
    row.title,
    row.slug,
    row.comment,
    row.url,
    row.url ? canonicalizeUrl(row.url) : null,
    row.rich_content,
    row.is_private,
    now.toISOString(),
    row.id,
  );

  if (result.changes === 0) {
    throw new APIException(APIErrorCode.NOT_FOUND, 404, "Dump not found");
  }

  if (request.categoryIds !== undefined) {
    const ids = [...new Set(request.categoryIds)];
    setDumpCategories(dumpId, ids);
    updatedDump.categoryIds = ids;
  } else {
    attachCategoryIds([updatedDump]);
  }

  if (updatedDump.isPrivate && !dump.isPrivate) broadcastDumpDeleted(dumpId);
  else if (!updatedDump.isPrivate) broadcastDumpUpdated(updatedDump);
  // Going public is an arrival for everyone who couldn't see it before.
  if (dump.isPrivate && !updatedDump.isPrivate) broadcastNewDump(updatedDump);
  if (updatedDump.comment) {
    notifyMentions(
      dump.userId,
      updatedDump.comment,
      "dump",
      dumpId,
      updatedDump.title,
    );
    linkAttachments(updatedDump.comment, dumpId);
  }
  relinkBacklinks("dump_comment", dumpId, dumpId, updatedDump.comment ?? "");
  return updatedDump;
}

export async function replaceFileDump(
  dumpId: string,
  file: File,
  comment: string | undefined,
  title?: string,
  categoryIds?: string[],
): Promise<Dump> {
  assertFileDumpText(title, comment);
  if (!isAllowedMime(file.type)) {
    throw new APIException(
      APIErrorCode.BAD_REQUEST,
      400,
      `File type '${file.type}' is not allowed`,
    );
  }
  if (file.size > DUMP_MAX_FILE_SIZE_BYTES) {
    throw new APIException(
      APIErrorCode.BAD_REQUEST,
      400,
      "File too large (max 50 MB)",
    );
  }

  const dump = fetchDump(dumpId);
  if (dump.kind !== "file") {
    throw new APIException(APIErrorCode.BAD_REQUEST, 400, "Not a file dump");
  }

  const data = new Uint8Array(await file.arrayBuffer());
  const filePath = `${DUMPS_DIR}/${dumpId}`;
  // Read old file contents so we can restore on DB failure
  const oldData = await Deno.readFile(filePath).catch(() => null);
  await Deno.writeFile(filePath, data);

  const now = new Date();
  const finalTitle = title?.trim() || dump.title;
  const newSlug = finalTitle !== dump.title
    ? makeSlug(finalTitle, dumpId)
    : dump.slug;
  try {
    db.prepare(
      `UPDATE dumps SET title = ?, slug = ?, file_name = ?, file_mime = ?, file_size = ?, comment = ?, updated_at = ? WHERE id = ?;`,
    ).run(
      finalTitle,
      newSlug ?? null,
      file.name,
      file.type,
      file.size,
      comment ?? null,
      now.toISOString(),
      dumpId,
    );
  } catch (err) {
    // Roll back the file to its previous contents on DB failure
    if (oldData) await Deno.writeFile(filePath, oldData).catch(() => {});
    else await Deno.remove(filePath).catch(() => {});
    throw err;
  }

  if (categoryIds !== undefined) {
    const ids = [...new Set(categoryIds)];
    setDumpCategories(dumpId, ids);
    dump.categoryIds = ids;
  } else {
    attachCategoryIds([dump]);
  }

  if (comment) {
    notifyMentions(dump.userId, comment, "dump", dumpId, finalTitle);
    linkAttachments(comment, dumpId);
  }
  relinkBacklinks("dump_comment", dumpId, dumpId, comment ?? "");
  return {
    ...dump,
    title: finalTitle,
    slug: newSlug,
    fileName: file.name,
    fileMime: file.type,
    fileSize: file.size,
    comment,
    updatedAt: now,
  };
}

export function getDumpsByUser(
  userId: string,
  page: number,
  limit: number,
  includePrivate: boolean,
): { items: Dump[]; total: number } {
  const offset = (page - 1) * limit;
  const privacyFilter = includePrivate ? "" : " AND is_private = 0";
  const rows = db.prepare(
    `SELECT ${SELECT_COLS} FROM dumps WHERE user_id = ?${privacyFilter} ORDER BY created_at DESC LIMIT ? OFFSET ?;`,
  ).all(userId, limit, offset);
  const totalRow = db.prepare(
    `SELECT COUNT(*) as count FROM dumps WHERE user_id = ?${privacyFilter};`,
  ).get(userId) as { count: number } | undefined;
  if (!rows.every(isDumpRow)) {
    throw new APIException(
      APIErrorCode.SERVER_ERROR,
      500,
      "Malformed dump data",
    );
  }
  const items = rows.map(dumpRowToApi);
  attachCategoryIds(items);
  return { items, total: totalRow?.count ?? 0 };
}

export function getVotedDumpsByUser(
  userId: string,
  page: number,
  limit: number,
  requestingUserId: string | null,
): { items: Dump[]; total: number } {
  const offset = (page - 1) * limit;
  const dumpCols = SELECT_COLS_ALIASED;

  let totalRow: { count: number } | undefined;
  let rows: unknown[];

  if (requestingUserId === userId) {
    // Own profile: include private dumps the user themselves voted on and owns.
    rows = db.prepare(
      `SELECT ${dumpCols}
       FROM dumps d
       INNER JOIN votes v ON d.id = v.dump_id
       WHERE v.user_id = ? AND (d.is_private = 0 OR d.user_id = ?)
       ORDER BY v.created_at DESC LIMIT ? OFFSET ?;`,
    ).all(userId, userId, limit, offset);
    totalRow = db.prepare(
      `SELECT COUNT(*) as count FROM dumps d
       INNER JOIN votes v ON d.id = v.dump_id
       WHERE v.user_id = ? AND (d.is_private = 0 OR d.user_id = ?);`,
    ).get(userId, userId) as { count: number } | undefined;
  } else {
    rows = db.prepare(
      `SELECT ${dumpCols}
       FROM dumps d
       INNER JOIN votes v ON d.id = v.dump_id
       WHERE v.user_id = ? AND d.is_private = 0
       ORDER BY v.created_at DESC LIMIT ? OFFSET ?;`,
    ).all(userId, limit, offset);
    totalRow = db.prepare(
      `SELECT COUNT(*) as count FROM dumps d
       INNER JOIN votes v ON d.id = v.dump_id
       WHERE v.user_id = ? AND d.is_private = 0;`,
    ).get(userId) as { count: number } | undefined;
  }

  if (!rows.every(isDumpRow)) {
    throw new APIException(
      APIErrorCode.SERVER_ERROR,
      500,
      "Malformed dump data",
    );
  }
  const items = rows.map(dumpRowToApi);
  attachCategoryIds(items);
  return { items, total: totalRow?.count ?? 0 };
}

export async function refreshDumpMetadata(dumpId: string): Promise<Dump> {
  const dump = fetchDump(dumpId);

  if (dump.kind !== "url" || !dump.url) {
    throw new APIException(
      APIErrorCode.BAD_REQUEST,
      400,
      "Only URL dumps support metadata refresh",
    );
  }

  // A failed fetch yields a stub with no title and no thumbnail. Writing that
  // over a dump that already has good metadata would silently destroy it and
  // rename the dump to its bare hostname, so bail out instead — the caller
  // surfaces the error and nothing is lost.
  const { ok, content: richContent } = await tryFetchRichContent(dump.url);
  if (!ok) {
    throw new APIException(
      APIErrorCode.SERVER_ERROR,
      502,
      "Could not reach the page to refresh its metadata",
    );
  }

  const title = richContent?.title ?? titleFromUrl(dump.url);

  const updatedDump: Dump = { ...dump, title, richContent };
  const row = dumpApiToRow(updatedDump);
  db.prepare(
    `UPDATE dumps SET title = ?, rich_content = ? WHERE id = ?;`,
  ).run(row.title, row.rich_content, row.id);

  if (!updatedDump.isPrivate) broadcastDumpUpdated(updatedDump);

  return updatedDump;
}

export function getDumpThumbnailInfo(
  idOrSlug: string,
): { id: string; mime: string } | undefined {
  const dump = fetchDump(idOrSlug);
  return dump.thumbnailMime
    ? { id: dump.id, mime: dump.thumbnailMime }
    : undefined;
}

export function setDumpThumbnail(dumpId: string, mime: string): Dump {
  const dump = fetchDump(dumpId);
  db.prepare(`UPDATE dumps SET custom_thumbnail_mime = ? WHERE id = ?;`).run(
    mime,
    dump.id,
  );
  const updatedDump: Dump = { ...dump, thumbnailMime: mime };
  if (!updatedDump.isPrivate) broadcastDumpUpdated(updatedDump);
  return updatedDump;
}

export async function removeDumpThumbnail(dumpId: string): Promise<Dump> {
  const dump = fetchDump(dumpId);
  db.prepare(`UPDATE dumps SET custom_thumbnail_mime = NULL WHERE id = ?;`)
    .run(dump.id);
  await Deno.remove(`${THUMBNAILS_DIR}/${dump.id}-custom`).catch(() => {});
  const updatedDump: Dump = { ...dump, thumbnailMime: undefined };
  if (!updatedDump.isPrivate) broadcastDumpUpdated(updatedDump);
  return updatedDump;
}

export async function deleteDump(dumpId: string): Promise<void> {
  const dump = fetchDump(dumpId);

  const result = db.prepare(`DELETE FROM dumps WHERE id = ?;`).run(dumpId);

  if (result.changes === 0) {
    throw new APIException(APIErrorCode.NOT_FOUND, 404, "Dump not found");
  }

  if (dump.kind === "file") {
    await Deno.remove(`${DUMPS_DIR}/${dumpId}`).catch(() => {});
  }

  broadcastDumpDeleted(dumpId);
}