katecms 0.0.0-stage → 1.0.0-beta.1

package/dist/runtime/server/api/_katecms/resolve.get.js

@@ -0,0 +1,116 @@
+import { defineEventHandler, getQuery } from "h3";
+import { useRuntimeConfig } from "#imports";
+import {
+  buildSlugPathMap,
+  can,
+  collectionListPaging,
+  collectionPerPage,
+  countCollections,
+  findCollectionBySlugPath,
+  listCollections,
+  matchPublicCollectionRoute
+} from "@katecms/core";
+import { getDb } from "../../utils/db.js";
+import { getCurrentUser } from "../../utils/session.js";
+import {
+  fail,
+  getCollectionDefinition,
+  getCollections,
+  readPage,
+  readPerPage,
+  toAdminEntry,
+  toCollectionMeta
+} from "../../utils/collections.js";
+import { loadAssignedEntryDictionaries } from "../../utils/dictionaries.js";
+import { resolvePublicDictionaryTerm } from "../../utils/public-term.js";
+import {
+  isTruthyQueryParam,
+  parsePublicStatusParam,
+  resolvePublicStatuses
+} from "../../../utils/preview.js";
+function listStatusFromPublic(statuses) {
+  const published = statuses.includes("published");
+  const draft = statuses.includes("draft");
+  if (published && draft) {
+    return "active";
+  }
+  if (draft) {
+    return "draft";
+  }
+  return "published";
+}
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const path = typeof query.path === "string" ? query.path : "";
+  if (!path.trim()) {
+    fail(400, "Missing path.");
+  }
+  const collections = getCollections();
+  const matched = matchPublicCollectionRoute(collections, path);
+  if (!matched) {
+    const db2 = getDb();
+    const termPage = await resolvePublicDictionaryTerm(db2, path);
+    if (termPage) {
+      return termPage;
+    }
+    fail(404, "Page not found.");
+  }
+  const def = getCollectionDefinition(matched.collectionSlug);
+  if (!def || def.public === false) {
+    fail(404, "Page not found.");
+  }
+  const previewRequested = isTruthyQueryParam(query.preview);
+  const actor = previewRequested ? await getCurrentUser(event) : null;
+  const roles = useRuntimeConfig().katecms?.roles ?? {};
+  const previewAllowed = actor != null && can(actor, "collections", "read", { roles, scope: matched.collectionSlug });
+  const { statuses, preview } = resolvePublicStatuses({
+    previewRequested,
+    previewAllowed,
+    requested: parsePublicStatusParam(query.status)
+  });
+  const db = getDb();
+  const meta = toCollectionMeta(matched.collectionSlug, def);
+  if (matched.kind === "archive") {
+    const page = readPage(query.page);
+    const perPage = readPerPage(query.perPage, collectionPerPage(def));
+    const listStatus = listStatusFromPublic(statuses);
+    const [rows, total, pathRows] = await Promise.all([
+      listCollections(db, matched.collectionSlug, {
+        status: listStatus,
+        ...collectionListPaging(page, perPage)
+      }),
+      countCollections(db, matched.collectionSlug, { status: listStatus }),
+      db.selectFrom("collections").select(["id", "slug", "parent_id"]).where("type", "=", matched.collectionSlug).execute()
+    ]);
+    const paths = buildSlugPathMap(pathRows);
+    const entries = await Promise.all(rows.map(async (row2) => {
+      const dictionaries2 = await loadAssignedEntryDictionaries(db, row2.id, matched.collectionSlug);
+      return toAdminEntry(row2, paths.get(row2.id) ?? row2.slug, { dictionaries: dictionaries2 });
+    }));
+    return {
+      kind: "archive",
+      collection: meta,
+      entries,
+      preview,
+      page,
+      perPage,
+      total
+    };
+  }
+  const row = await findCollectionBySlugPath(
+    db,
+    matched.collectionSlug,
+    matched.segments,
+    statuses
+  );
+  if (!row) {
+    fail(404, "Page not found.");
+  }
+  const dictionaries = await loadAssignedEntryDictionaries(db, row.id, matched.collectionSlug);
+  return {
+    kind: "entry",
+    collection: meta,
+    entry: toAdminEntry(row, matched.slugPath, { dictionaries }),
+    preview
+  };
+});

package/dist/runtime/server/api/_katecms/terms.get.d.ts

@@ -0,0 +1,20 @@
+import type { QueryTermsResult } from '@katecms/core';
+/**
+ * Public dictionary-term query.
+ *
+ * Query:
+ * - `dictionary` (required) — comma-separated dictionary slugs
+ * - `perPage` (`-1` or omitted — all), `offset`
+ * - `includeIds`, `excludeIds`, `excludeTreeIds`
+ * - `parentId` (`0` = top-level), `childOf`, `childless`
+ * - `slug`, `title`, `search`
+ * - `hideEmpty` (default true), `hierarchical` (default true), `padCounts`
+ * - `fieldsQuery` — JSON object (`relation` + `queries`) against term `fields`.
+ *   `REGEXP` and `NOT REGEXP` are rejected.
+ * - `orderBy`, `order`, `orderByField` — JSON `{ key, type? }` when `orderBy=field`
+ * - `return` — `all`, `ids`, `titles`, `count`, `idParent`, `idSlug`, `idTitle`
+ *
+ * `count` is the number of published entries in public collections.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<QueryTermsResult>>;
+export default _default;

package/dist/runtime/server/api/_katecms/terms.get.js

@@ -0,0 +1,201 @@
+import { defineEventHandler, getQuery } from "h3";
+import {
+  isTermOrderBy,
+  isTermsReturn,
+  parseFieldsQuery,
+  queryTerms,
+  UNLIMITED_COLLECTION_PER_PAGE
+} from "@katecms/core";
+import { getDb } from "../../utils/db.js";
+import { rejectPublicRegexp } from "../../utils/public-fields-query.js";
+import { fail, getCollections, readPerPage } from "../../utils/collections.js";
+import { getDictionaries } from "../../utils/dictionaries.js";
+const CASTS = /* @__PURE__ */ new Set(["TEXT", "INTEGER", "NUMERIC", "DATETIME", "DATE", "TIME"]);
+function firstQueryValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+function readStringList(value) {
+  const parts = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+  return [...new Set(parts.map((item) => String(item).trim()).filter(Boolean))];
+}
+function readIdList(value) {
+  const parts = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : value == null ? [] : [value];
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const part of parts) {
+    const n = Number(part);
+    if (!Number.isInteger(n) || n < 1 || seen.has(n)) {
+      continue;
+    }
+    seen.add(n);
+    ids.push(n);
+  }
+  return ids;
+}
+function hasQueryParam(query, key) {
+  return query[key] !== void 0;
+}
+function readBool(value, fallback) {
+  const raw = firstQueryValue(value);
+  if (raw == null || raw === "") {
+    return fallback;
+  }
+  if (typeof raw === "boolean") {
+    return raw;
+  }
+  const token = String(raw).trim().toLowerCase();
+  if (token === "1" || token === "true" || token === "yes") {
+    return true;
+  }
+  if (token === "0" || token === "false" || token === "no") {
+    return false;
+  }
+  return fallback;
+}
+function readOffset(value) {
+  const raw = firstQueryValue(value);
+  if (raw == null || raw === "") {
+    return 0;
+  }
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0) {
+    fail(400, "Invalid offset.");
+  }
+  return n;
+}
+function readParentId(value) {
+  const raw = firstQueryValue(value);
+  if (raw == null || raw === "" || raw === "null" || raw === 0 || raw === "0") {
+    return null;
+  }
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1) {
+    fail(400, "Invalid parentId.");
+  }
+  return n;
+}
+function readChildOf(value) {
+  const raw = firstQueryValue(value);
+  if (raw == null || raw === "" || raw === 0 || raw === "0") {
+    return void 0;
+  }
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1) {
+    fail(400, "Invalid childOf.");
+  }
+  return n;
+}
+function readFieldsQuery(value) {
+  const raw = firstQueryValue(value);
+  if (raw == null || raw === "") {
+    return void 0;
+  }
+  let parsed = raw;
+  if (typeof raw === "string") {
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      fail(400, "Invalid fieldsQuery.");
+    }
+  }
+  if (typeof parsed !== "object" || parsed == null || Array.isArray(parsed)) {
+    fail(400, "Invalid fieldsQuery.");
+  }
+  return rejectPublicRegexp(parseFieldsQuery(parsed));
+}
+function readOrderByField(value) {
+  const raw = firstQueryValue(value);
+  if (raw == null || raw === "") {
+    return void 0;
+  }
+  let parsed = raw;
+  if (typeof raw === "string") {
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      fail(400, "Invalid orderByField.");
+    }
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    fail(400, "Invalid orderByField.");
+  }
+  const key = typeof parsed.key === "string" ? parsed.key.trim() : "";
+  if (!key) {
+    fail(400, "Invalid orderByField.");
+  }
+  const typeRaw = parsed.type;
+  const type = typeof typeRaw === "string" && CASTS.has(typeRaw.trim().toUpperCase()) ? typeRaw.trim().toUpperCase() : void 0;
+  return type ? { key, type } : { key };
+}
+function publicCollectionSlugs(all) {
+  return Object.keys(all).filter((slug) => all[slug]?.public !== false);
+}
+function resolveDictionaries(requested, all) {
+  const known = new Set(Object.keys(all));
+  return requested.filter((slug) => known.has(slug));
+}
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const requested = readStringList(query.dictionary);
+  if (requested.length === 0) {
+    fail(400, "Missing dictionary.");
+  }
+  const dictionaries = resolveDictionaries(requested, getDictionaries());
+  const orderByRaw = firstQueryValue(query.orderBy);
+  const orderByToken = typeof orderByRaw === "string" ? orderByRaw.trim() : "";
+  const orderBy = isTermOrderBy(orderByToken) ? orderByToken : void 0;
+  const orderRaw = firstQueryValue(query.order);
+  const orderToken = typeof orderRaw === "string" ? orderRaw.trim().toLowerCase() : "";
+  const order = orderToken === "asc" || orderToken === "desc" ? orderToken : void 0;
+  const returnRaw = firstQueryValue(query.return);
+  const returnToken = typeof returnRaw === "string" ? returnRaw.trim() : "";
+  const returnMode = isTermsReturn(returnToken) ? returnToken : void 0;
+  const filters = {
+    dictionaries,
+    perPage: readPerPage(query.perPage, UNLIMITED_COLLECTION_PER_PAGE),
+    offset: readOffset(query.offset),
+    hideEmpty: readBool(query.hideEmpty, true),
+    hierarchical: readBool(query.hierarchical, true),
+    padCounts: readBool(query.padCounts, false),
+    childless: readBool(query.childless, false),
+    countTypes: publicCollectionSlugs(getCollections()),
+    search: typeof firstQueryValue(query.search) === "string" ? String(firstQueryValue(query.search)) : void 0
+  };
+  if (orderBy) {
+    filters.orderBy = orderBy;
+  }
+  if (order) {
+    filters.order = order;
+  }
+  if (returnMode) {
+    filters.return = returnMode;
+  }
+  if (hasQueryParam(query, "includeIds")) {
+    filters.includeIds = readIdList(query.includeIds);
+  }
+  if (hasQueryParam(query, "excludeIds")) {
+    filters.excludeIds = readIdList(query.excludeIds);
+  }
+  if (hasQueryParam(query, "excludeTreeIds")) {
+    filters.excludeTreeIds = readIdList(query.excludeTreeIds);
+  }
+  if (hasQueryParam(query, "slug")) {
+    filters.slug = readStringList(query.slug);
+  }
+  if (hasQueryParam(query, "title")) {
+    filters.title = readStringList(query.title);
+  }
+  if (hasQueryParam(query, "parentId")) {
+    filters.parentId = readParentId(query.parentId);
+  }
+  if (hasQueryParam(query, "childOf")) {
+    filters.childOf = readChildOf(query.childOf);
+  }
+  if (hasQueryParam(query, "fieldsQuery")) {
+    filters.fieldsQuery = readFieldsQuery(query.fieldsQuery);
+  }
+  if (orderBy === "field") {
+    filters.orderByField = readOrderByField(query.orderByField);
+  }
+  return queryTerms(getDb(), filters);
+});

package/dist/runtime/server/api/_katecms/users/[id].delete.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Delete another user.
+ *
+ * Requires `users` delete. You cannot delete yourself. A site owner can be
+ * deleted only by an owner, and never when they are the last owner.
+ * Entries and uploads they authored stay; the author link is cleared.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    ok: true;
+}>>;
+export default _default;

package/dist/runtime/server/api/_katecms/users/[id].delete.js

@@ -0,0 +1,45 @@
+import { defineEventHandler, getRouterParam } from "h3";
+import { useRuntimeConfig } from "#imports";
+import {
+  can,
+  deleteUser,
+  findUserById,
+  isOwner
+} from "@katecms/core";
+import { getDb } from "../../../utils/db.js";
+import { requireUser } from "../../../utils/session.js";
+import { fail } from "../../../utils/users.js";
+export default defineEventHandler(async (event) => {
+  const actor = await requireUser(event);
+  const roles = useRuntimeConfig().katecms?.roles ?? {};
+  if (!can(actor, "users", "delete", { roles })) {
+    fail(403, "Insufficient permissions.");
+  }
+  const id = Number(getRouterParam(event, "id"));
+  if (!Number.isInteger(id) || id <= 0) {
+    fail(400, "Invalid user id.");
+  }
+  if (id === actor.id) {
+    fail(403, "You cannot delete your own account.");
+  }
+  const db = getDb();
+  const target = await findUserById(db, id);
+  if (!target) {
+    fail(404, "User not found.");
+  }
+  if (isOwner(target, roles) && !isOwner(actor, roles)) {
+    fail(403, "The site owner cannot be deleted.");
+  }
+  try {
+    const row = await deleteUser(db, id);
+    if (!row) {
+      fail(404, "User not found.");
+    }
+    return { ok: true };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("last owner")) {
+      fail(422, "Cannot remove the last owner.");
+    }
+    throw error;
+  }
+});

package/dist/runtime/server/api/_katecms/users/[id].patch.d.ts

@@ -0,0 +1,19 @@
+import type { AdminUser } from '../../../../utils/admin-users.js';
+/**
+ * Update a user.
+ *
+ * Access rules:
+ * - editing your own account is always allowed (name / email / avatar);
+ * - changing your own password also requires `currentPassword`;
+ * - a manager may set another account's password without the old one;
+ * - editing someone else requires the `users` update permission;
+ * - `role` and `status` can only be changed by a manager editing *another*
+ *   account (you can't change your own role/status, which prevents both
+ *   self-lockout and privilege escalation);
+ * - the `owner` account can only be edited by the owner themselves, and the
+ *   reserved `owner` role can never be assigned.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: AdminUser;
+}>>;
+export default _default;

package/dist/runtime/server/api/_katecms/users/[id].patch.js

@@ -0,0 +1,129 @@
+import { defineEventHandler, getRouterParam, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import {
+  can,
+  findUserById,
+  hashPassword,
+  isOwner,
+  isUniqueConstraintError,
+  isValidRole,
+  OWNER_ROLE,
+  updateUser,
+  validateEmail,
+  validatePassword,
+  verifyPassword
+} from "@katecms/core";
+import { getDb } from "../../../utils/db.js";
+import {
+  assertAuthAttemptAllowed,
+  recordAuthAttemptFailure,
+  recordAuthAttemptSuccess,
+  throwTooManyAttempts
+} from "../../../utils/auth-rate-limit.js";
+import { requireUser, setUserSession } from "../../../utils/session.js";
+import {
+  fail,
+  readAvatar,
+  readName,
+  toAdminUser
+} from "../../../utils/users.js";
+const STATUSES = ["active", "banned"];
+export default defineEventHandler(async (event) => {
+  const actor = await requireUser(event);
+  const roles = useRuntimeConfig().katecms?.roles ?? {};
+  const id = Number(getRouterParam(event, "id"));
+  if (!Number.isInteger(id) || id <= 0) {
+    fail(400, "Invalid user id.");
+  }
+  const isSelf = actor.id === id;
+  const canManage = can(actor, "users", "update", { roles });
+  if (!canManage && !isSelf) {
+    fail(403, "Insufficient permissions.");
+  }
+  const db = getDb();
+  const target = await findUserById(db, id);
+  if (!target) {
+    fail(404, "User not found.");
+  }
+  if (isOwner(target, roles) && !isSelf) {
+    fail(403, "The site owner cannot be changed.");
+  }
+  const body = await readBody(event);
+  const patch = {};
+  if (body?.email !== void 0) {
+    const email = typeof body.email === "string" ? body.email.trim() : "";
+    const emailCheck = validateEmail(email);
+    if (!emailCheck.ok) {
+      fail(422, emailCheck.error);
+    }
+    patch.email = email;
+  }
+  if (typeof body?.password === "string" && body.password.length > 0) {
+    const passwordCheck = validatePassword(body.password);
+    if (!passwordCheck.ok) {
+      fail(422, passwordCheck.error);
+    }
+    if (isSelf) {
+      const attemptKey = `password:${actor.id}`;
+      assertAuthAttemptAllowed(event, attemptKey);
+      const currentPassword = typeof body.currentPassword === "string" ? body.currentPassword : "";
+      const matches = currentPassword.length > 0 && await verifyPassword(currentPassword, target.password_hash);
+      if (!matches) {
+        const { retryAfterMs } = recordAuthAttemptFailure(attemptKey);
+        if (retryAfterMs > 0) {
+          throwTooManyAttempts(event, retryAfterMs);
+        }
+        fail(422, "Current password is incorrect.");
+      }
+      recordAuthAttemptSuccess(attemptKey);
+    }
+    patch.password_hash = await hashPassword(body.password);
+  }
+  if (body?.name !== void 0) {
+    patch.name = readName(body.name);
+  }
+  if (body?.avatar !== void 0) {
+    patch.avatar = readAvatar(body.avatar);
+  }
+  if (body?.role !== void 0) {
+    if (!canManage || isSelf) {
+      fail(403, "Cannot change this account role.");
+    }
+    const role = typeof body.role === "string" ? body.role : "";
+    if (role === OWNER_ROLE) {
+      fail(422, "The owner role cannot be assigned.");
+    }
+    if (!isValidRole(roles, role)) {
+      fail(422, "Unknown role.");
+    }
+    patch.role = role;
+  }
+  if (body?.status !== void 0) {
+    if (!canManage || isSelf) {
+      fail(403, "Cannot change this account status.");
+    }
+    const status = body.status;
+    if (!STATUSES.includes(status)) {
+      fail(422, "Invalid status.");
+    }
+    patch.status = status;
+  }
+  try {
+    const row = await updateUser(db, id, patch);
+    if (!row) {
+      fail(404, "User not found.");
+    }
+    if (isSelf && patch.password_hash) {
+      await setUserSession(event, row.id, row.session_version);
+    }
+    return { user: toAdminUser(row) };
+  } catch (error) {
+    if (isUniqueConstraintError(error)) {
+      fail(409, "A user with this email already exists.");
+    }
+    if (error instanceof Error && error.message.includes("last owner")) {
+      fail(422, "Cannot remove the last owner.");
+    }
+    throw error;
+  }
+});

package/dist/runtime/server/api/_katecms/users.get.d.ts

@@ -0,0 +1,10 @@
+import type { UsersResponse } from '../../../utils/admin-users.js';
+/**
+ * Accounts for the admin users UI and the `user` field picker.
+ *
+ * Password hashes are never returned. Managers (read/create/update on `users`)
+ * see every account; others see only themselves. Extra capability flags power
+ * the admin list; the picker only reads `users`.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<UsersResponse>>;
+export default _default;

package/dist/runtime/server/api/_katecms/users.get.js

@@ -0,0 +1,34 @@
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
+import {
+  can,
+  findUserById,
+  listUsers
+} from "@katecms/core";
+import { getDb } from "../../utils/db.js";
+import { requireUser } from "../../utils/session.js";
+import { roleOptions, toAdminUser } from "../../utils/users.js";
+export default defineEventHandler(async (event) => {
+  const actor = await requireUser(event);
+  const roles = useRuntimeConfig().katecms?.roles ?? {};
+  const db = getDb();
+  const canCreate = can(actor, "users", "create", { roles });
+  const canUpdate = can(actor, "users", "update", { roles });
+  const canDelete = can(actor, "users", "delete", { roles });
+  const isManager = can(actor, "users", "read", { roles }) || canCreate || canUpdate || canDelete;
+  let rows;
+  if (isManager) {
+    rows = await listUsers(db);
+  } else {
+    const row = await findUserById(db, actor.id);
+    rows = row ? [row] : [];
+  }
+  return {
+    users: rows.map(toAdminUser),
+    roles: roleOptions(roles),
+    currentUserId: actor.id,
+    canCreate,
+    canUpdate,
+    canDelete
+  };
+});

package/dist/runtime/server/api/_katecms/users.post.d.ts

@@ -0,0 +1,10 @@
+import type { AdminUser } from '../../../utils/admin-users.js';
+/**
+ * Create a user. Requires the `users` create permission (the `owner` superuser
+ * always passes). The reserved `owner` role can't be assigned — ownership is
+ * only ever granted to the first registered account.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: AdminUser;
+}>>;
+export default _default;

package/dist/runtime/server/api/_katecms/users.post.js

@@ -0,0 +1,62 @@
+import { defineEventHandler, readBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+import {
+  createUser,
+  hashPassword,
+  isUniqueConstraintError,
+  isValidRole,
+  OWNER_ROLE,
+  validateEmail,
+  validatePassword
+} from "@katecms/core";
+import { getDb } from "../../utils/db.js";
+import { requirePermission } from "../../utils/permissions.js";
+import { requireUser } from "../../utils/session.js";
+import {
+  defaultAssignableRole,
+  fail,
+  readAvatar,
+  readName,
+  toAdminUser
+} from "../../utils/users.js";
+export default defineEventHandler(async (event) => {
+  const actor = await requireUser(event);
+  const roles = useRuntimeConfig().katecms?.roles ?? {};
+  requirePermission(actor, "users", "create", roles);
+  const body = await readBody(event);
+  const email = typeof body?.email === "string" ? body.email.trim() : "";
+  const password = typeof body?.password === "string" ? body.password : "";
+  const name = readName(body?.name);
+  const avatar = readAvatar(body?.avatar);
+  const role = typeof body?.role === "string" && body.role.trim() ? body.role.trim() : defaultAssignableRole(roles);
+  const emailCheck = validateEmail(email);
+  if (!emailCheck.ok) {
+    fail(422, emailCheck.error);
+  }
+  const passwordCheck = validatePassword(password);
+  if (!passwordCheck.ok) {
+    fail(422, passwordCheck.error);
+  }
+  if (role === OWNER_ROLE) {
+    fail(422, "The owner role cannot be assigned.");
+  }
+  if (!isValidRole(roles, role)) {
+    fail(422, "Unknown role.");
+  }
+  const passwordHash = await hashPassword(password);
+  try {
+    const row = await createUser(getDb(), {
+      email,
+      password_hash: passwordHash,
+      name,
+      avatar,
+      role
+    });
+    return { user: toAdminUser(row) };
+  } catch (error) {
+    if (isUniqueConstraintError(error)) {
+      fail(409, "A user with this email already exists.");
+    }
+    throw error;
+  }
+});

package/dist/runtime/server/api/uploads/[...key].get.d.ts

@@ -0,0 +1,3 @@
+/** Serve uploaded files from the media storage directory. */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBufferLike>>>;
+export default _default;