@karibsen/eponyme 0.1.0 → 0.2.0

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

@@ -1,4 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    entries: import("../../services/eponyme-store.js").EponymeCollectionEntry<Record<string, unknown>>[];
-}>>;
+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-collections/[path].get.js

@@ -1,11 +1,38 @@
 import { createError, defineEventHandler, getQuery, getRequestURL } from "h3";
 import { useEponymeService } from "../../services/eponyme-service.js";
 import { requireEponymeUser } from "../../utils/auth.js";
+import { interpolateEponymeContent } from "../../utils/eponyme-variables.js";
+const MAX_TAKE = 200;
+function readCount(raw, min, max) {
+  if (raw === void 0 || raw === "") return void 0;
+  const value = Number(raw);
+  if (!Number.isFinite(value)) return void 0;
+  return Math.min(max, Math.max(min, Math.trunc(value)));
+}
 export default defineEventHandler(async (event) => {
   const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-collections\//, ""));
-  const version = getQuery(event).version === "draft" ? "draft" : "published";
+  const query = getQuery(event);
+  const version = query.version === "draft" ? "draft" : "published";
   if (version === "draft") await requireEponymeUser(event);
-  const entries = name ? await useEponymeService().listCollection(name, version) : void 0;
-  if (!entries) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
-  return { entries };
+  if (!name) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
+  const service = useEponymeService();
+  const orderBy = query.orderBy === void 0 || query.orderBy === "" ? void 0 : String(query.orderBy);
+  if (orderBy) {
+    const allowed = service.collectionSortKeys(name);
+    if (!allowed) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
+    if (!allowed.includes(orderBy)) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: `Unknown sort key "${orderBy}". Available keys: ${allowed.join(", ")}.`
+      });
+    }
+  }
+  const page = await service.listCollection(name, version, {
+    take: readCount(query.take, 1, MAX_TAKE),
+    skip: readCount(query.skip, 0, Number.MAX_SAFE_INTEGER),
+    orderBy,
+    order: query.order === "asc" ? "asc" : query.order === "desc" ? "desc" : void 0
+  });
+  if (!page) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
+  return query.raw ? page : interpolateEponymeContent(page);
 });

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,7 @@
 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 { callEponymeBlockingHook, callEponymeHook } from "../../utils/eponyme-hooks.js";
 export default defineEventHandler(async (event) => {
   const route = readEponymeFormRoute(event);
   const service = useEponymeFormService();
@@ -25,12 +26,24 @@ export default defineEventHandler(async (event) => {
     setResponseStatus(event, 201);
     return { submitted: true };
   }
-  const result = await service.submit(route.name, payload);
+  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.d.ts

@@ -1,5 +1,6 @@
 import type { EponymeConfig, EponymeFormDefinitionBase } from '../../types/index.js';
 import { type ValidationErrors } from '../../utils/validate-eponyme-data.js';
+/** Kept here rather than imported, so the store stays free of H3 imports. */
 type DateValue = Date | string;
 export interface EponymeFormSubmission {
     id: string;

package/dist/runtime/server/services/eponyme-store.d.ts

@@ -16,7 +16,7 @@ export interface EponymeVersionAuthor {
 }
 export interface EponymeHistoryEntry {
     id: number;
-    action: EponymeAction | 'restore';
+    action: EponymeAction | 'restore' | 'import';
     status: EponymeStatus;
     createdAt: string;
     user: EponymeVersionAuthor | null;
@@ -33,15 +33,69 @@ export interface EponymeCollectionEntry<Data extends Record<string, unknown> = R
     status: EponymeStatus;
     publishedAt: string | null;
     updatedAt: string | null;
+    /** Only set for entries read from the trash. */
+    deletedAt?: string | null;
 }
 export interface EponymeSitemapEntry {
     loc: string;
     lastmod?: string;
 }
+/** One entry of an export file: the complete stored state, without the envelope. */
+export interface EponymeExportEntry {
+    name: string;
+    /** Set for collection entries, so a reader can group them without re-parsing the name. */
+    collection?: string;
+    draft: Record<string, unknown>;
+    published: Record<string, unknown>;
+    status: EponymeStatus;
+    publishedAt: string | null;
+}
+export interface EponymeExportFile {
+    eponyme: {
+        format: 1;
+        exportedAt: string;
+        /** Schema fingerprint per singleton and per collection, checked before an import writes anything. */
+        schemas: Record<string, string>;
+    };
+    entries: EponymeExportEntry[];
+}
+export interface EponymeImportResult {
+    dryRun: boolean;
+    created: number;
+    updated: number;
+    skipped: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
+/** The import was refused as a whole, before any write. */
+export interface EponymeImportRejection {
+    errors: string[];
+    /** Names whose configured schema differs from the one the file was exported with. */
+    schemaMismatch?: string[];
+}
+export type EponymeSortDirection = 'asc' | 'desc';
+export interface EponymeCollectionQuery {
+    take?: number;
+    skip?: number;
+    orderBy?: string;
+    order?: EponymeSortDirection;
+}
+export interface EponymeCollectionPage<Data extends Record<string, unknown> = Record<string, unknown>> {
+    entries: EponymeCollectionEntry<Data>[];
+    /** Matching entries before `take` and `skip`, so it can drive a pager. */
+    total: number;
+}
+export declare const COLLECTION_METADATA_KEYS: readonly ["updatedAt", "publishedAt", "title", "slug"];
 export type PrismaEponymeRow = {
     name: string;
     data: unknown;
     updatedAt?: Date | string;
+    deletedAt?: Date | string | null;
+};
+/** `null` keeps the live rows, `{ not: null }` the trashed ones. */
+export type PrismaDeletedAtFilter = null | {
+    not: null;
 };
 export type PrismaEponymeVersionRow = {
     id: number;
@@ -83,9 +137,11 @@ export type PrismaEponymeClient = {
             where: {
                 name: string;
                 updatedAt?: Date | string;
+                deletedAt?: PrismaDeletedAtFilter;
             };
             data: {
-                data: Record<string, unknown>;
+                data?: Record<string, unknown>;
+                deletedAt?: Date | null;
             };
         }): Promise<{
             count: number;
@@ -106,6 +162,7 @@ export type PrismaEponymeClient = {
                 name: {
                     startsWith: string;
                 };
+                deletedAt?: PrismaDeletedAtFilter;
             };
             orderBy: Array<{
                 updatedAt: 'desc';
@@ -175,20 +232,49 @@ export declare class EponymeService {
     /** Content as it was in a given version, for previewing without restoring it. */
     private getVersionResult;
     statuses(): Promise<Record<string, EponymeStatus>>;
-    listCollection(name: string, version?: EponymeVersion): Promise<EponymeCollectionEntry[] | undefined>;
+    /** Metadata keys that can be sorted on, alongside every field of the collection. */
+    collectionSortKeys(name: string): string[] | undefined;
+    listCollection(name: string, version?: EponymeVersion, query?: EponymeCollectionQuery): Promise<EponymeCollectionPage | undefined>;
     /**
      * Builds the public URL list configured by `previewPaths`.
      * Collections are resolved directly from their stored rows so this performs
      * one query per collection rather than one query per entry.
      */
     getSitemapEntries(previewPaths: Record<string, string>): Promise<EponymeSitemapEntry[]>;
+    /**
+     * Every singleton and every live collection entry, as a portable file.
+     * Collections are read with one query each rather than one per entry.
+     */
+    exportContent(): Promise<EponymeExportFile>;
+    /**
+     * Applies an export file on top of the current content: every entry it carries is
+     * upserted, everything else is left alone. Nothing is ever deleted.
+     *
+     * The schema check runs first and refuses the whole file, so an import can never
+     * land half of its entries into a configuration that no longer matches.
+     */
+    importContent(file: unknown, options?: {
+        dryRun?: boolean;
+        actorId?: string;
+    }): Promise<EponymeImportResult | EponymeImportRejection>;
     createCollectionEntry(name: string, payload: unknown, actorId?: string): Promise<(EponymeResult & {
         slug: string;
         errors?: never;
     }) | {
         errors: ValidationErrors;
     } | undefined>;
+    /**
+     * A trashed entry keeps its row, so it keeps its slug: reusing one has to be
+     * refused with an error the editor can act on rather than the generic message.
+     */
+    private slugTakenError;
+    /** Moves an entry to the trash. Its history is kept, so it stays restorable. */
     deleteCollectionEntry(name: string): Promise<boolean>;
+    restoreCollectionEntry(name: string): Promise<boolean>;
+    /** Definitive: `onDelete: Cascade` takes the entry's whole history with it. */
+    purgeCollectionEntry(name: string): Promise<boolean>;
+    /** Trashed entries of a collection, most recently updated first. */
+    listCollectionTrash(name: string): Promise<EponymeCollectionPage | undefined>;
     patch(name: string, payload: unknown, action?: EponymeAction, actorId?: string): Promise<(EponymeResult & {
         errors?: never;
         conflict?: never;
@@ -199,4 +285,6 @@ export declare class EponymeService {
     history(name: string, limit?: number): Promise<EponymeHistoryEntry[] | undefined>;
     restore(name: string, versionId: number, actorId?: string): Promise<EponymeResult | EponymeConflict | undefined>;
 }
+/** Stable hash of a schema's shape, embedded in an export and checked on import. */
+export declare function schemaFingerprint(schema: EponymeSchema): string;
 export declare function isPrismaError(error: unknown, code: string): boolean;