@karibsen/eponyme 0.1.1 → 0.3.0

package/dist/runtime/composables/useEponymeForm.js

@@ -10,12 +10,14 @@ function resolveForm(name) {
   if (!definition) throw new Error(`[Eponyme] Unknown form "${name}". Declare it with form() in eponyme.config.ts.`);
   return definition;
 }
+const CAPTCHA_TOKEN_KEY = "_eponyme_captcha";
 export function useEponymeForm(name, options = {}) {
   const definition = resolveForm(name);
   const requestFetch = useRequestFetch();
   const serverErrors = ref({});
   const pending = ref(false);
   const submitted = ref(false);
+  const captchaToken = ref("");
   const values = ref(createDefaultEponymeData(definition.fields));
   const validation = useEponymeValidation(definition.fields, values, ref({}), { serverErrors });
   const fields = computed(() => Object.entries(definition.fields).map(([fieldName, fieldDefinition]) => ({
@@ -33,6 +35,7 @@ export function useEponymeForm(name, options = {}) {
     values.value = createDefaultEponymeData(definition.fields);
     serverErrors.value = {};
     submitted.value = false;
+    captchaToken.value = "";
     validation.reset();
   }
   async function submit() {
@@ -47,7 +50,12 @@ export function useEponymeForm(name, options = {}) {
       } else {
         if (options.onSubmit && import.meta.dev)
           console.warn(`[Eponyme] Form "${name}" is managed, so its onSubmit handler is ignored.`);
-        await requestFetch(`/api/eponyme-forms/${name}`, { method: "POST", body: values.value });
+        await requestFetch(`/api/eponyme-forms/${name}`, {
+          method: "POST",
+          // The token travels beside the fields, never as one of them: it is
+          // transport, and the schema only knows about declared fields.
+          body: definition.captcha ? { ...values.value, [CAPTCHA_TOKEN_KEY]: captchaToken.value } : values.value
+        });
       }
       submitted.value = true;
       return true;
@@ -69,6 +77,8 @@ export function useEponymeForm(name, options = {}) {
     pending,
     submitted,
     honeypot: definition.honeypot,
+    requiresCaptcha: definition.captcha,
+    captchaToken,
     submit,
     reset
   };

package/dist/runtime/composables/useEponymeHistory.d.ts

@@ -2,7 +2,7 @@ import type { EponymeHistoryEntry } from '../server/services/eponyme-store.js';
 export declare function useEponymeHistory(name: () => string): {
     history: import("vue").Ref<{
         id: number;
-        action: import("../server/services/eponyme-store.js").EponymeAction | "restore";
+        action: import("../server/services/eponyme-store.js").EponymeAction | "restore" | "import";
         status: import("../server/services/eponyme-store.js").EponymeStatus;
         createdAt: string;
         user: {
@@ -11,7 +11,7 @@ export declare function useEponymeHistory(name: () => string): {
         } | null;
     }[], EponymeHistoryEntry[] | {
         id: number;
-        action: import("../server/services/eponyme-store.js").EponymeAction | "restore";
+        action: import("../server/services/eponyme-store.js").EponymeAction | "restore" | "import";
         status: import("../server/services/eponyme-store.js").EponymeStatus;
         createdAt: string;
         user: {

package/dist/runtime/composables/useEponymeHistory.js

@@ -1,5 +1,6 @@
 import { useRequestFetch } from "#app";
 import { ref } from "vue";
+import { EPONYME_DATE_LOCALE } from "../utils/date-locale.js";
 export function useEponymeHistory(name) {
   const requestFetch = useRequestFetch();
   const history = ref([]);
@@ -20,5 +21,5 @@ export function useEponymeHistory(name) {
   return { history, pending, error, load };
 }
 export function formatVersionDate(value) {
-  return new Intl.DateTimeFormat(void 0, { dateStyle: "medium", timeStyle: "short" }).format(new Date(value));
+  return new Intl.DateTimeFormat(EPONYME_DATE_LOCALE, { dateStyle: "medium", timeStyle: "short" }).format(new Date(value));
 }

package/dist/runtime/pages/EponymeDetailPage.vue

@@ -38,7 +38,7 @@ if (!schemas[eponymeName.value] && !collection.value && !form.value && !collecti
 <template>
   <main class="eponyme-root ep:flex ep:min-h-screen ep:flex-col ep:bg-theme-ep ep:font-sans ep:text-text-ep ep:md:flex-row">
     <EponymeSidebar :base-path="indexPath" />
-    <div class="ep:w-full">
+    <div class="ep:w-full ep:min-w-0 ep:md:flex-1">
       <EponymeFolderPage
         v-if="isFolder"
         :base-path="indexPath"

package/dist/runtime/pages/EponymeIndexPage.vue

@@ -1,34 +1,149 @@
 <script setup>
-import { useRoute, useSeoMeta } from "#app";
+import { nextTick, ref } from "vue";
+import { refreshNuxtData, useRequestFetch, useRoute, useSeoMeta } from "#app";
 import EponymeNavigationLink from "../components/editor/EponymeNavigationLink.vue";
 import EponymeSidebar from "../components/editor/EponymeSidebar.vue";
+import EPButton from "../components/ui/EPButton.vue";
+import EPDialog from "../components/ui/EPDialog.vue";
+import EPToast from "../components/ui/EPToast.vue";
+import { useEponymeAuth } from "../composables/useEponymeAuth";
 import { useEponymeConfig } from "../composables/useEponymeConfig";
 import { getEponymeCollections, getEponymeForms, getEponymeSchemas } from "../utils/get-eponyme-schemas";
 const config = useEponymeConfig();
 const route = useRoute();
+const auth = useEponymeAuth();
+const request = useRequestFetch();
 const eponymes = getEponymeSchemas(config);
 const collections = getEponymeCollections(config);
 const forms = getEponymeForms(config);
 const entries = { ...eponymes, ...collections, ...forms };
 useSeoMeta({ title: "Eponyme" });
+const fileInput = ref();
+const exporting = ref(false);
+const importing = ref(false);
+const preview = ref();
+const pendingFile = ref();
+const toast = ref({ open: false, title: "", description: "", variant: "success" });
 function label(name) {
   return name.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
 }
+async function showToast(variant, title, description) {
+  toast.value.open = false;
+  await nextTick();
+  toast.value = { open: true, variant, title, description };
+}
+function describeError(caught, fallback) {
+  const error = caught;
+  const mismatch = error?.data?.data?.schemaMismatch;
+  const message = error?.statusMessage || error?.data?.statusMessage || fallback;
+  return mismatch?.length ? `${message} (${mismatch.join(", ")})` : message;
+}
+async function exportContent() {
+  exporting.value = true;
+  try {
+    const file = await request("/api/eponyme-export", { cache: "no-store" });
+    const url = URL.createObjectURL(new Blob([JSON.stringify(file, null, 2)], { type: "application/json" }));
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = `eponyme-export-${file.eponyme.exportedAt.slice(0, 10)}.json`;
+    link.click();
+    URL.revokeObjectURL(url);
+  } catch (caught) {
+    await showToast("error", "Export failed", describeError(caught, "Unable to export the content."));
+  } finally {
+    exporting.value = false;
+  }
+}
+async function reviewFile(event) {
+  const input = event.target;
+  const file = input.files?.[0];
+  input.value = "";
+  if (!file) return;
+  importing.value = true;
+  try {
+    const parsed = JSON.parse(await file.text());
+    preview.value = await request("/api/eponyme-import?dryRun=1", { method: "POST", body: parsed });
+    pendingFile.value = parsed;
+  } catch (caught) {
+    pendingFile.value = void 0;
+    preview.value = void 0;
+    await showToast("error", "Import refused", caught instanceof SyntaxError ? "This file is not valid JSON." : describeError(caught, "Unable to read this export file."));
+  } finally {
+    importing.value = false;
+  }
+}
+async function confirmImport() {
+  if (!pendingFile.value) return;
+  importing.value = true;
+  try {
+    const result = await request("/api/eponyme-import", { method: "POST", body: pendingFile.value });
+    closePreview();
+    await refreshNuxtData();
+    await showToast(
+      "success",
+      "Content imported",
+      `${result.created} created, ${result.updated} updated${result.skipped.length ? `, ${result.skipped.length} skipped` : ""}.`
+    );
+  } catch (caught) {
+    await showToast("error", "Import failed", describeError(caught, "Unable to import this file."));
+  } finally {
+    importing.value = false;
+  }
+}
+function closePreview() {
+  preview.value = void 0;
+  pendingFile.value = void 0;
+}
 </script>
 
 <template>
   <main class="eponyme-root ep:flex ep:min-h-screen ep:flex-col ep:bg-theme-ep ep:font-sans ep:text-text-ep ep:md:flex-row">
     <EponymeSidebar :base-path="route.path" />
     <section class="ep:mx-auto ep:w-full ep:max-w-3xl ep:px-6 ep:py-8 ep:md:px-10 ep:md:py-12">
-      <p class="ep:m-0 ep:text-[11px] ep:font-semibold ep:tracking-widest ep:text-muted-ep ep:uppercase">
-        Eponyme
-      </p>
-      <h1 class="ep:mt-2 ep:text-3xl ep:font-semibold ep:tracking-tight ep:text-white">
-        Content entries
-      </h1>
-      <p class="ep:mt-2 ep:text-sm ep:text-muted-ep">
-        Choose the content area you want to update.
-      </p>
+      <div class="ep:flex ep:flex-wrap ep:items-start ep:justify-between ep:gap-4">
+        <div>
+          <p class="ep:m-0 ep:text-[11px] ep:font-semibold ep:tracking-widest ep:text-muted-ep ep:uppercase">
+            Eponyme
+          </p>
+          <h1 class="ep:mt-2 ep:text-3xl ep:font-semibold ep:tracking-tight ep:text-white">
+            Content entries
+          </h1>
+          <p class="ep:mt-2 ep:text-sm ep:text-muted-ep">
+            Choose the content area you want to update.
+          </p>
+        </div>
+        <div
+          v-if="auth.canEdit.value"
+          class="ep:flex ep:shrink-0 ep:items-center ep:gap-2"
+        >
+          <EPButton
+            label="Export"
+            icon="mingcute:download-2-line"
+            size="sm"
+            :loading="exporting"
+            :disabled="exporting"
+            title="Download every entry as a JSON file"
+            @click="exportContent"
+          />
+          <EPButton
+            v-if="auth.isOwner.value"
+            label="Import"
+            icon="mingcute:upload-2-line"
+            size="sm"
+            :loading="importing"
+            :disabled="importing"
+            title="Apply an export file from another environment"
+            @click="fileInput?.click()"
+          />
+          <input
+            ref="fileInput"
+            type="file"
+            accept="application/json,.json"
+            class="ep:hidden"
+            @change="reviewFile"
+          >
+        </div>
+      </div>
       <nav
         class="ep:mt-8 ep:grid ep:gap-3 ep:sm:grid-cols-2"
         aria-label="Content entries"
@@ -43,6 +158,54 @@ function label(name) {
         />
       </nav>
     </section>
+    <ClientOnly>
+      <EPDialog
+        :open="Boolean(preview)"
+        title="Import content"
+        description="Entries in the file overwrite their counterpart. Nothing is ever deleted."
+        @update:open="!$event && closePreview()"
+      >
+        <div v-if="preview">
+          <ul class="ep:m-0 ep:list-none ep:space-y-1 ep:p-0 ep:text-sm ep:text-muted-ep">
+            <li><span class="ep:font-semibold ep:text-white">{{ preview.created }}</span> to create</li>
+            <li><span class="ep:font-semibold ep:text-white">{{ preview.updated }}</span> to overwrite</li>
+            <li><span class="ep:font-semibold ep:text-white">{{ preview.skipped.length }}</span> skipped</li>
+          </ul>
+          <ul
+            v-if="preview.skipped.length"
+            class="ep:mt-4 ep:max-h-40 ep:list-none ep:space-y-2 ep:overflow-y-auto ep:p-0 ep:text-xs ep:text-muted-ep"
+          >
+            <li
+              v-for="skipped in preview.skipped"
+              :key="skipped.name"
+            >
+              <span class="ep:font-medium ep:text-white">{{ skipped.name }}</span> — {{ skipped.reason }}
+            </li>
+          </ul>
+          <div class="ep:mt-6 ep:flex ep:justify-end ep:gap-2">
+            <EPButton
+              label="Cancel"
+              variant="ghost"
+              @click="closePreview"
+            />
+            <EPButton
+              label="Import"
+              variant="primary"
+              :loading="importing"
+              :disabled="importing || !preview.created && !preview.updated"
+              @click="confirmImport"
+            />
+          </div>
+        </div>
+      </EPDialog>
+      <EPToast
+        :open="toast.open"
+        :title="toast.title"
+        :description="toast.description"
+        :variant="toast.variant"
+        @update:open="toast.open = $event"
+      />
+    </ClientOnly>
   </main>
 </template>
 

package/dist/runtime/server/api/eponyme/[name].patch.js

@@ -1,6 +1,8 @@
 import { createError, defineEventHandler, getQuery, getRequestURL, readBody, setResponseStatus } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeBlockingHook, callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
 export default defineEventHandler(async (event) => {
   assertEponymeMutationOrigin(event);
   const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
@@ -8,7 +10,12 @@ export default defineEventHandler(async (event) => {
   if (!name) throw createError({ statusCode: 404, statusMessage: "Eponyme entry not found." });
   const requestedAction = getQuery(event).action;
   const action = requestedAction === "draft" ? "draft" : "publish";
-  const result = await useEponymeService().patch(name, await readBody(event), action, user.id);
+  const service = useEponymeService();
+  const collection = splitEponymeCollectionEntry(service, name);
+  const body = await readBody(event);
+  const beforeSave = { name, collection, action, data: body, userId: user.id };
+  await callEponymeBlockingHook("eponyme:entry:beforeSave", beforeSave);
+  const result = await service.patch(name, beforeSave.data, action, user.id);
   if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme entry not found." });
   if ("conflict" in result && result.conflict)
     throw createError({ statusCode: 409, message: "This entry was changed by someone else. Reload the page to get the latest version." });
@@ -16,5 +23,14 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 422);
     return { errors: result.errors };
   }
+  await callEponymeHook(action === "publish" ? "eponyme:entry:published" : "eponyme:entry:saved", {
+    name,
+    collection,
+    action,
+    status: result.status,
+    publishedAt: result.publishedAt,
+    data: result.data,
+    userId: user.id
+  });
   return requestedAction ? result : { data: result.data };
 });

package/dist/runtime/server/api/eponyme-collections/[path].delete.js

@@ -1,11 +1,16 @@
 import { createError, defineEventHandler, getRequestURL } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
 export default defineEventHandler(async (event) => {
   assertEponymeMutationOrigin(event);
-  await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
   const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-collections\//, ""));
-  if (!name || !await useEponymeService().deleteCollectionEntry(name))
+  const service = useEponymeService();
+  const collection = name ? splitEponymeCollectionEntry(service, name) : void 0;
+  if (!collection || !await service.deleteCollectionEntry(name))
     throw createError({ statusCode: 404, statusMessage: "Eponyme collection entry not found." });
+  await callEponymeHook("eponyme:entry:trashed", { name, collection, userId: user.id });
   return { deleted: true };
 });

package/dist/runtime/server/api/eponyme-export.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../services/eponyme-store.js").EponymeExportFile>>;
+export default _default;

package/dist/runtime/server/api/eponyme-export.get.js

@@ -0,0 +1,11 @@
+import { defineEventHandler, setResponseHeader } from "h3";
+import { useEponymeService } from "../services/eponyme-service.js";
+import { requireEponymeUser } from "../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  setResponseHeader(event, "Cache-Control", "no-store");
+  const file = await useEponymeService().exportContent();
+  const day = file.eponyme.exportedAt.slice(0, 10);
+  setResponseHeader(event, "Content-Disposition", `attachment; filename="eponyme-export-${day}.json"`);
+  return file;
+});

package/dist/runtime/server/api/eponyme-forms/[path].post.js

@@ -1,6 +1,8 @@
 import { createError, defineEventHandler, getRequestHeader, readRawBody, setResponseHeader, setResponseStatus } from "h3";
 import { useEponymeFormService } from "../../services/eponyme-form-service.js";
 import { readEponymeFormRoute } from "../../utils/form-route.js";
+import { CAPTCHA_TOKEN_KEY, isEponymeCaptchaConfigured, verifyEponymeCaptcha } from "../../utils/eponyme-captcha.js";
+import { callEponymeBlockingHook, callEponymeHook } from "../../utils/eponyme-hooks.js";
 export default defineEventHandler(async (event) => {
   const route = readEponymeFormRoute(event);
   const service = useEponymeFormService();
@@ -25,12 +27,38 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 201);
     return { submitted: true };
   }
-  const result = await service.submit(route.name, payload);
+  if (definition.captcha) {
+    if (!isEponymeCaptchaConfigured()) {
+      throw createError({
+        statusCode: 500,
+        statusMessage: `Form "${route.name}" requires a captcha but no adapter is installed. Add one, such as @karibsen/eponyme-captcha.`
+      });
+    }
+    const token = payload && typeof payload === "object" ? payload[CAPTCHA_TOKEN_KEY] : void 0;
+    const result2 = await verifyEponymeCaptcha(event, token);
+    if (!result2.success) {
+      setResponseStatus(event, 422);
+      return { errors: { _form: ["Captcha verification failed. Please try again."] } };
+    }
+  }
+  const validated = service.validate(route.name, payload);
+  if (validated && "errors" in validated) {
+    setResponseStatus(event, 422);
+    return { errors: validated.errors };
+  }
+  const beforeSubmit = { form: route.name, data: validated?.data ?? {} };
+  await callEponymeBlockingHook("eponyme:form:beforeSubmit", beforeSubmit);
+  const result = await service.submit(route.name, beforeSubmit.data);
   if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme form not found." });
   if ("errors" in result) {
     setResponseStatus(event, 422);
     return { errors: result.errors };
   }
+  await callEponymeHook("eponyme:form:submitted", {
+    form: route.name,
+    data: result.submission.data,
+    id: result.submission.id
+  });
   setResponseStatus(event, 201);
   return { submitted: true, id: result.submission.id };
 });

package/dist/runtime/server/api/eponyme-history/[path].patch.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../services/eponyme-store.js").EponymeResult | import("../../services/eponyme-store.js").EponymeConflict>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../services/eponyme-store.js").EponymeResult>>;
 export default _default;

package/dist/runtime/server/api/eponyme-history/[path].patch.js

@@ -1,6 +1,8 @@
 import { createError, defineEventHandler, getRequestURL } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
 export default defineEventHandler(async (event) => {
   assertEponymeMutationOrigin(event);
   const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
@@ -10,9 +12,19 @@ export default defineEventHandler(async (event) => {
   const [, name, rawVersionId] = match;
   const versionId = Number(rawVersionId);
   if (!Number.isSafeInteger(versionId)) throw createError({ statusCode: 404, statusMessage: "Eponyme version not found." });
-  const result = await useEponymeService().restore(name, versionId, user.id);
+  const service = useEponymeService();
+  const result = await service.restore(name, versionId, user.id);
   if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme version not found." });
-  if ("conflict" in result && result.conflict)
+  if ("conflict" in result)
     throw createError({ statusCode: 409, message: "This entry was changed by someone else. Reload the page to get the latest version." });
+  await callEponymeHook("eponyme:entry:restored", {
+    name,
+    collection: splitEponymeCollectionEntry(service, name),
+    action: "restore",
+    status: result.status,
+    publishedAt: result.publishedAt,
+    data: result.data,
+    userId: user.id
+  });
   return result;
 });

package/dist/runtime/server/api/eponyme-import.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../services/eponyme-store.js").EponymeImportResult>>;
+export default _default;

package/dist/runtime/server/api/eponyme-import.post.js

@@ -0,0 +1,31 @@
+import { createError, defineEventHandler, getQuery, getRequestHeader, readRawBody, setResponseHeader } from "h3";
+import { useEponymeService } from "../services/eponyme-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../utils/auth.js";
+const MAX_BODY_BYTES = 5 * 1024 * 1024;
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  const user = await requireEponymeUser(event, { roles: ["owner"] });
+  setResponseHeader(event, "Cache-Control", "no-store");
+  const declaredLength = Number(getRequestHeader(event, "content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_BODY_BYTES)
+    throw createError({ statusCode: 413, statusMessage: "Import file is too large." });
+  const raw = await readRawBody(event, "utf8");
+  if (raw && Buffer.byteLength(raw, "utf8") > MAX_BODY_BYTES)
+    throw createError({ statusCode: 413, statusMessage: "Import file is too large." });
+  let payload;
+  try {
+    payload = raw ? JSON.parse(raw) : void 0;
+  } catch {
+    throw createError({ statusCode: 400, statusMessage: "Import file must be valid JSON." });
+  }
+  const dryRun = Boolean(getQuery(event).dryRun);
+  const result = await useEponymeService().importContent(payload, { dryRun, actorId: user.id });
+  if ("errors" in result) {
+    throw createError({
+      statusCode: result.schemaMismatch?.length ? 409 : 400,
+      statusMessage: result.errors[0] ?? "This import could not be applied.",
+      data: { errors: result.errors, schemaMismatch: result.schemaMismatch ?? [] }
+    });
+  }
+  return result;
+});

package/dist/runtime/server/api/eponyme-trash/[path].delete.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    purged: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/api/eponyme-trash/[path].delete.js

@@ -0,0 +1,16 @@
+import { createError, defineEventHandler, getRequestURL } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  const user = await requireEponymeUser(event, { roles: ["owner"] });
+  const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-trash\//, ""));
+  const service = useEponymeService();
+  const collection = name ? splitEponymeCollectionEntry(service, name) : void 0;
+  if (!collection || !await service.purgeCollectionEntry(name))
+    throw createError({ statusCode: 404, statusMessage: "Eponyme trashed entry not found." });
+  await callEponymeHook("eponyme:entry:purged", { name, collection, userId: user.id });
+  return { purged: true };
+});

package/dist/runtime/server/api/eponyme-trash/[path].get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../services/eponyme-store.js").EponymeCollectionPage<Record<string, unknown>>>>;
+export default _default;

package/dist/runtime/server/api/eponyme-trash/[path].get.js

@@ -0,0 +1,11 @@
+import { createError, defineEventHandler, getRequestURL } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { requireEponymeUser } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-trash\//, ""));
+  if (!name) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
+  const page = await useEponymeService().listCollectionTrash(name);
+  if (!page) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
+  return page;
+});

package/dist/runtime/server/api/eponyme-trash/[path].patch.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    restored: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/api/eponyme-trash/[path].patch.js

@@ -0,0 +1,16 @@
+import { createError, defineEventHandler, getRequestURL } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { callEponymeHook } from "../../utils/eponyme-hooks.js";
+import { splitEponymeCollectionEntry } from "../../utils/eponyme-entry.js";
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-trash\//, ""));
+  const service = useEponymeService();
+  const collection = name ? splitEponymeCollectionEntry(service, name) : void 0;
+  if (!collection || !await service.restoreCollectionEntry(name))
+    throw createError({ statusCode: 404, statusMessage: "Eponyme trashed entry not found." });
+  await callEponymeHook("eponyme:entry:untrashed", { name, collection, userId: user.id });
+  return { restored: true };
+});

package/dist/runtime/server/services/eponyme-form-store.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { getEponymeForms } from "../../utils/get-eponyme-schemas.js";
 import { validateEponymeData } from "../../utils/validate-eponyme-data.js";
+const CAPTCHA_TOKEN_KEY = "_eponyme_captcha";
 const DEFAULT_PER_PAGE = 25;
 const MAX_PER_PAGE = 100;
 export class EponymeFormService {
@@ -36,7 +37,7 @@ export class EponymeFormService {
     if (!payload || typeof payload !== "object" || Array.isArray(payload))
       return { errors: { _form: ["Body must be an object."] } };
     const input = payload;
-    const { [definition.honeypot || ""]: _honeypot, ...rest } = input;
+    const { [definition.honeypot || ""]: _honeypot, [CAPTCHA_TOKEN_KEY]: _captcha, ...rest } = input;
     const unknownKeys = Object.keys(rest).filter((key) => !(key in definition.fields));
     if (unknownKeys.length)
       return { errors: Object.fromEntries(unknownKeys.map((key) => [key, ["Unknown field."]])) };

package/dist/runtime/server/services/eponyme-service.js

@@ -1,8 +1,15 @@
 import eponymeConfig from "#eponyme/config";
 import prisma from "#eponyme/prisma";
+import { useRuntimeConfig } from "nitropack/runtime";
 import { EponymeService } from "./eponyme-store.js";
 export { EponymeService } from "./eponyme-store.js";
-const eponymeService = new EponymeService(eponymeConfig, prisma);
+let eponymeService;
 export function useEponymeService() {
+  if (!eponymeService) {
+    const contentConfig = useRuntimeConfig().eponymeContent;
+    eponymeService = new EponymeService(eponymeConfig, prisma, {
+      cacheSeconds: contentConfig?.cacheSeconds ?? 5
+    });
+  }
   return eponymeService;
 }