@karibsen/eponyme 0.1.0

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

@@ -0,0 +1,227 @@
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { isEponymeRole } from "../../types/index.js";
+import { generateTemporaryPassword, hashPassword, validatePassword, verifyPassword } from "../utils/password.js";
+const OWNER_USERNAME = "EponymeOwner";
+const MAX_LOGIN_ATTEMPTS = 5;
+const LOGIN_LOCK_MS = 15 * 60 * 1e3;
+const USERNAME_PATTERN = /^[\w.-]{3,50}$/;
+const dummyPasswordHash = hashPassword("Eponyme timing-safe dummy password");
+export class EponymeAuthService {
+  constructor(client, sessionDurationDays = 7) {
+    this.client = client;
+    this.sessionDurationDays = sessionDurationDays;
+  }
+  async bootstrapOwner(log = console.log) {
+    if (await this.client.eponymeUser.count() > 0) return false;
+    const temporaryPassword = generateTemporaryPassword();
+    try {
+      await this.client.eponymeUser.create({
+        data: {
+          id: randomUUID(),
+          username: OWNER_USERNAME,
+          usernameNormalized: normalizeUsername(OWNER_USERNAME),
+          passwordHash: await hashPassword(temporaryPassword),
+          role: "owner",
+          active: true,
+          mustChangePassword: true,
+          failedLoginAttempts: 0
+        }
+      });
+    } catch (error) {
+      if (await this.client.eponymeUser.count() > 0) return false;
+      throw error;
+    }
+    log("[Eponyme] Initial owner account created. These credentials are shown only once.");
+    log(`[Eponyme] Username: ${OWNER_USERNAME}`);
+    log(`[Eponyme] Temporary password: ${temporaryPassword}`);
+    log("[Eponyme] Sign in and change this password before using the dashboard.");
+    return true;
+  }
+  async login(username, password) {
+    const normalized = typeof username === "string" ? normalizeUsername(username) : "";
+    const submittedPassword = typeof password === "string" ? password : "";
+    const user = normalized ? await this.client.eponymeUser.findUnique({ where: { usernameNormalized: normalized } }) : null;
+    const validPassword = await verifyPassword(submittedPassword, user?.passwordHash ?? await dummyPasswordHash);
+    if (!user || !user.active || !validPassword) {
+      if (user?.active) await this.recordFailedLogin(user);
+      return { ok: false, reason: "invalid" };
+    }
+    if (user.lockedUntil && new Date(user.lockedUntil).getTime() > Date.now())
+      return { ok: false, reason: "locked" };
+    if (user.failedLoginAttempts || user.lockedUntil) {
+      await this.client.eponymeUser.update({
+        where: { id: user.id },
+        data: { failedLoginAttempts: 0, lockedUntil: null }
+      });
+    }
+    return { ok: true, session: await this.createSession({ ...user, failedLoginAttempts: 0, lockedUntil: null }) };
+  }
+  async getSession(token) {
+    if (!token) return void 0;
+    const tokenHash = hashToken(token);
+    const session = await this.client.eponymeUserSession.findUnique({
+      where: { tokenHash },
+      include: { user: true }
+    });
+    if (!session?.user) return void 0;
+    if (new Date(session.expiresAt).getTime() <= Date.now() || !session.user.active) {
+      await this.client.eponymeUserSession.deleteMany({ where: { tokenHash } });
+      return void 0;
+    }
+    return {
+      token,
+      expiresAt: new Date(session.expiresAt),
+      user: toAuthUser(session.user)
+    };
+  }
+  async logout(token) {
+    if (!token) return;
+    await this.client.eponymeUserSession.deleteMany({ where: { tokenHash: hashToken(token) } });
+  }
+  async changePassword(userId, currentPassword, newPassword) {
+    const user = await this.client.eponymeUser.findUnique({ where: { id: userId } });
+    if (!user || !user.active) return { error: "User account is unavailable." };
+    if (typeof currentPassword !== "string" || !await verifyPassword(currentPassword, user.passwordHash))
+      return { error: "Current password is incorrect." };
+    const passwordError = validatePassword(newPassword);
+    if (passwordError) return { error: passwordError };
+    if (normalizeUsername(String(newPassword)).includes(user.usernameNormalized))
+      return { error: "Password must not contain the username." };
+    if (await verifyPassword(String(newPassword), user.passwordHash))
+      return { error: "New password must be different from the current password." };
+    const updated = await this.client.eponymeUser.update({
+      where: { id: userId },
+      data: {
+        passwordHash: await hashPassword(String(newPassword)),
+        mustChangePassword: false,
+        failedLoginAttempts: 0,
+        lockedUntil: null
+      }
+    });
+    await this.client.eponymeUserSession.deleteMany({ where: { userId } });
+    return { session: await this.createSession(updated) };
+  }
+  async listUsers() {
+    const users = await this.client.eponymeUser.findMany({ orderBy: { createdAt: "asc" } });
+    return users.map(toAuthUser);
+  }
+  async createUser(username, role) {
+    const usernameError = validateUsername(username);
+    if (usernameError) return { error: usernameError };
+    if (!isEponymeRole(role)) return { error: "A valid role is required." };
+    const cleanUsername = String(username).trim();
+    const temporaryPassword = generateTemporaryPassword();
+    try {
+      const user = await this.client.eponymeUser.create({
+        data: {
+          id: randomUUID(),
+          username: cleanUsername,
+          usernameNormalized: normalizeUsername(cleanUsername),
+          passwordHash: await hashPassword(temporaryPassword),
+          role,
+          active: true,
+          mustChangePassword: true,
+          failedLoginAttempts: 0
+        }
+      });
+      return { result: { user: toAuthUser(user), temporaryPassword } };
+    } catch (error) {
+      if (isUniqueConstraintViolation(error)) return { error: "This username is already in use." };
+      throw error;
+    }
+  }
+  async updateUser(id, changes) {
+    const user = await this.client.eponymeUser.findUnique({ where: { id } });
+    if (!user) return { error: "User not found.", notFound: true };
+    if (changes.role !== void 0 && !isEponymeRole(changes.role))
+      return { error: "A valid role is required." };
+    if (changes.active !== void 0 && typeof changes.active !== "boolean")
+      return { error: "Active must be a boolean." };
+    const nextRole = changes.role ?? user.role;
+    const nextActive = changes.active ?? user.active;
+    const removesActiveOwner = user.role === "owner" && user.active && (nextRole !== "owner" || !nextActive);
+    const apply = async (tx) => {
+      if (removesActiveOwner) {
+        const activeOwnerCount = await tx.eponymeUser.count({ where: { role: "owner", active: true } });
+        if (activeOwnerCount <= 1) return { error: "The last active owner cannot be disabled or demoted." };
+      }
+      const updated = await tx.eponymeUser.update({
+        where: { id },
+        data: { role: nextRole, active: nextActive }
+      });
+      return { user: toAuthUser(updated) };
+    };
+    const result = removesActiveOwner && this.client.$transaction ? await this.client.$transaction(apply, { isolationLevel: "Serializable" }).catch((error) => isSerializationFailure(error) ? { error: "Another change was applied at the same time. Please try again." } : Promise.reject(error)) : await apply(this.client);
+    if (result.error) return result;
+    if (!nextActive) await this.client.eponymeUserSession.deleteMany({ where: { userId: id } });
+    return result;
+  }
+  async resetPassword(id) {
+    const user = await this.client.eponymeUser.findUnique({ where: { id } });
+    if (!user) return { error: "User not found." };
+    const temporaryPassword = generateTemporaryPassword();
+    const updated = await this.client.eponymeUser.update({
+      where: { id },
+      data: {
+        passwordHash: await hashPassword(temporaryPassword),
+        mustChangePassword: true,
+        failedLoginAttempts: 0,
+        lockedUntil: null
+      }
+    });
+    await this.client.eponymeUserSession.deleteMany({ where: { userId: id } });
+    return { result: { user: toAuthUser(updated), temporaryPassword } };
+  }
+  async createSession(user) {
+    const token = randomBytes(32).toString("base64url");
+    const expiresAt = new Date(Date.now() + this.sessionDurationDays * 24 * 60 * 60 * 1e3);
+    await this.client.eponymeUserSession.create({
+      data: {
+        id: randomUUID(),
+        tokenHash: hashToken(token),
+        userId: user.id,
+        expiresAt
+      }
+    });
+    return { token, expiresAt, user: toAuthUser(user) };
+  }
+  async recordFailedLogin(user) {
+    if (user.lockedUntil && new Date(user.lockedUntil).getTime() > Date.now()) return;
+    const attempts = user.failedLoginAttempts + 1;
+    await this.client.eponymeUser.update({
+      where: { id: user.id },
+      data: {
+        failedLoginAttempts: attempts >= MAX_LOGIN_ATTEMPTS ? 0 : attempts,
+        lockedUntil: attempts >= MAX_LOGIN_ATTEMPTS ? new Date(Date.now() + LOGIN_LOCK_MS) : null
+      }
+    });
+  }
+}
+export function normalizeUsername(username) {
+  return username.trim().toLocaleLowerCase("en-US");
+}
+export function validateUsername(username) {
+  if (typeof username !== "string" || !username.trim()) return "Username is required.";
+  if (!USERNAME_PATTERN.test(username.trim()))
+    return "Username must contain 3 to 50 letters, numbers, dots, underscores or hyphens.";
+}
+function hashToken(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
+function isUniqueConstraintViolation(error) {
+  return Boolean(error && typeof error === "object" && error.code === "P2002");
+}
+function isSerializationFailure(error) {
+  return Boolean(error && typeof error === "object" && error.code === "P2034");
+}
+function toAuthUser(user) {
+  return {
+    id: user.id,
+    username: user.username,
+    role: isEponymeRole(user.role) ? user.role : "viewer",
+    active: user.active,
+    mustChangePassword: user.mustChangePassword,
+    createdAt: new Date(user.createdAt).toISOString(),
+    updatedAt: new Date(user.updatedAt).toISOString()
+  };
+}

package/dist/runtime/server/services/eponyme-form-service.d.ts

@@ -0,0 +1,3 @@
+import { EponymeFormService } from './eponyme-form-store.js';
+export { EponymeFormService } from './eponyme-form-store.js';
+export declare function useEponymeFormService(): EponymeFormService;

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

@@ -0,0 +1,8 @@
+import eponymeConfig from "#eponyme/config";
+import prisma from "#eponyme/prisma";
+import { EponymeFormService } from "./eponyme-form-store.js";
+export { EponymeFormService } from "./eponyme-form-store.js";
+const eponymeFormService = new EponymeFormService(eponymeConfig, prisma);
+export function useEponymeFormService() {
+  return eponymeFormService;
+}

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

@@ -0,0 +1,100 @@
+import type { EponymeConfig, EponymeFormDefinitionBase } from '../../types/index.js';
+import { type ValidationErrors } from '../../utils/validate-eponyme-data.js';
+type DateValue = Date | string;
+export interface EponymeFormSubmission {
+    id: string;
+    formName: string;
+    data: Record<string, unknown>;
+    createdAt: string;
+}
+export interface EponymeFormSubmissionPage {
+    submissions: EponymeFormSubmission[];
+    total: number;
+    page: number;
+    perPage: number;
+}
+export interface PrismaEponymeFormSubmissionRow {
+    id: string;
+    formName: string;
+    data: unknown;
+    createdAt: DateValue;
+}
+export type PrismaEponymeFormClient = {
+    eponymeFormSubmission: {
+        create(args: {
+            data: {
+                id: string;
+                formName: string;
+                data: Record<string, unknown>;
+            };
+        }): Promise<PrismaEponymeFormSubmissionRow>;
+        findMany(args: {
+            where: {
+                formName: string;
+            };
+            orderBy: {
+                createdAt: 'desc';
+            };
+            skip: number;
+            take: number;
+        }): Promise<PrismaEponymeFormSubmissionRow[]>;
+        count(args: {
+            where: {
+                formName: string;
+            };
+        }): Promise<number>;
+        findUnique(args: {
+            where: {
+                id: string;
+            };
+        }): Promise<PrismaEponymeFormSubmissionRow | null>;
+        delete(args: {
+            where: {
+                id: string;
+            };
+        }): Promise<PrismaEponymeFormSubmissionRow>;
+        deleteMany(args: {
+            where: {
+                formName: string;
+            };
+        }): Promise<{
+            count: number;
+        }>;
+    };
+};
+export declare class EponymeFormService {
+    private readonly client;
+    private readonly forms;
+    constructor(config: EponymeConfig, client: PrismaEponymeFormClient);
+    getForm(name: string): EponymeFormDefinitionBase | undefined;
+    /**
+     * Without this, a missing model surfaces as "Cannot read properties of
+     * undefined (reading 'create')", which tells the developer nothing about the
+     * two steps they actually skipped.
+     */
+    private submissions;
+    names(): string[];
+    /**
+     * Runs the same rules as the dashboard, in `publish` mode: a public form has no
+     * draft state, so `required` and the minimum bounds always apply.
+     */
+    validate(name: string, payload: unknown): {
+        data: Record<string, unknown>;
+    } | {
+        errors: ValidationErrors;
+    } | undefined;
+    isHoneypotTriggered(name: string, payload: unknown): boolean;
+    submit(name: string, payload: unknown): Promise<{
+        submission: EponymeFormSubmission;
+    } | {
+        errors: ValidationErrors;
+    } | undefined>;
+    listSubmissions(name: string, options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<EponymeFormSubmissionPage | undefined>;
+    getSubmission(name: string, id: string): Promise<EponymeFormSubmission | undefined>;
+    deleteSubmission(name: string, id: string): Promise<boolean>;
+    deleteAllSubmissions(name: string): Promise<number | undefined>;
+}
+export {};

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

@@ -0,0 +1,109 @@
+import { randomUUID } from "node:crypto";
+import { getEponymeForms } from "../../utils/get-eponyme-schemas.js";
+import { validateEponymeData } from "../../utils/validate-eponyme-data.js";
+const DEFAULT_PER_PAGE = 25;
+const MAX_PER_PAGE = 100;
+export class EponymeFormService {
+  constructor(config, client) {
+    this.client = client;
+    this.forms = getEponymeForms(config);
+  }
+  forms;
+  getForm(name) {
+    return this.forms[name];
+  }
+  /**
+   * Without this, a missing model surfaces as "Cannot read properties of
+   * undefined (reading 'create')", which tells the developer nothing about the
+   * two steps they actually skipped.
+   */
+  submissions() {
+    const delegate = this.client?.eponymeFormSubmission;
+    if (!delegate)
+      throw new Error("[Eponyme] The EponymeFormSubmission model is missing from your Prisma client. Add it to your schema, run a migration, then run `prisma generate`.");
+    return delegate;
+  }
+  names() {
+    return Object.keys(this.forms);
+  }
+  /**
+   * Runs the same rules as the dashboard, in `publish` mode: a public form has no
+   * draft state, so `required` and the minimum bounds always apply.
+   */
+  validate(name, payload) {
+    const definition = this.forms[name];
+    if (!definition) return void 0;
+    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 unknownKeys = Object.keys(rest).filter((key) => !(key in definition.fields));
+    if (unknownKeys.length)
+      return { errors: Object.fromEntries(unknownKeys.map((key) => [key, ["Unknown field."]])) };
+    const errors = validateEponymeData(definition.fields, rest, "publish");
+    if (Object.keys(errors).length) return { errors };
+    return { data: rest };
+  }
+  isHoneypotTriggered(name, payload) {
+    const definition = this.forms[name];
+    if (!definition || !definition.honeypot) return false;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
+    const value = payload[definition.honeypot];
+    return typeof value === "string" ? value.trim().length > 0 : value != null && value !== false;
+  }
+  async submit(name, payload) {
+    const definition = this.forms[name];
+    if (!definition || definition.submission.mode !== "managed") return void 0;
+    const validated = this.validate(name, payload);
+    if (!validated || "errors" in validated) return validated;
+    const row = await this.submissions().create({
+      data: { id: randomUUID(), formName: name, data: validated.data }
+    });
+    return { submission: toSubmission(row) };
+  }
+  async listSubmissions(name, options = {}) {
+    const definition = this.forms[name];
+    if (!definition || definition.submission.mode !== "managed") return void 0;
+    const perPage = clamp(options.perPage ?? DEFAULT_PER_PAGE, 1, MAX_PER_PAGE);
+    const page = Math.max(1, Math.trunc(options.page ?? 1) || 1);
+    const [rows, total] = await Promise.all([
+      this.submissions().findMany({
+        where: { formName: name },
+        orderBy: { createdAt: "desc" },
+        skip: (page - 1) * perPage,
+        take: perPage
+      }),
+      this.submissions().count({ where: { formName: name } })
+    ]);
+    return { submissions: rows.map(toSubmission), total, page, perPage };
+  }
+  async getSubmission(name, id) {
+    if (!this.forms[name]) return void 0;
+    const row = await this.submissions().findUnique({ where: { id } });
+    if (!row || row.formName !== name) return void 0;
+    return toSubmission(row);
+  }
+  async deleteSubmission(name, id) {
+    if (!await this.getSubmission(name, id)) return false;
+    await this.submissions().delete({ where: { id } });
+    return true;
+  }
+  async deleteAllSubmissions(name) {
+    const definition = this.forms[name];
+    if (!definition || definition.submission.mode !== "managed") return void 0;
+    const { count } = await this.submissions().deleteMany({ where: { formName: name } });
+    return count;
+  }
+}
+function clamp(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+function toSubmission(row) {
+  return {
+    id: row.id,
+    formName: row.formName,
+    data: row.data && typeof row.data === "object" && !Array.isArray(row.data) ? row.data : {},
+    createdAt: new Date(row.createdAt).toISOString()
+  };
+}

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

@@ -0,0 +1,3 @@
+import { EponymeService } from './eponyme-store.js';
+export { EponymeService } from './eponyme-store.js';
+export declare function useEponymeService(): EponymeService;

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

@@ -0,0 +1,8 @@
+import eponymeConfig from "#eponyme/config";
+import prisma from "#eponyme/prisma";
+import { EponymeService } from "./eponyme-store.js";
+export { EponymeService } from "./eponyme-store.js";
+const eponymeService = new EponymeService(eponymeConfig, prisma);
+export function useEponymeService() {
+  return eponymeService;
+}

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

@@ -0,0 +1,202 @@
+import type { EponymeCollectionDefinitionBase, EponymeConfig, EponymeSchema } from '../../types/index.js';
+import { type ValidationErrors } from '../../utils/validate-eponyme-data.js';
+export type EponymeAction = 'draft' | 'publish';
+export type EponymeVersion = 'draft' | 'published';
+/** Either the live draft/published content, or a numeric id from the version history. */
+export type EponymeVersionSelector = EponymeVersion | number;
+export type EponymeStatus = 'draft' | 'published';
+export interface EponymeResult {
+    data: Record<string, unknown>;
+    status: EponymeStatus;
+    publishedAt: string | null;
+}
+export interface EponymeVersionAuthor {
+    id: string;
+    username: string;
+}
+export interface EponymeHistoryEntry {
+    id: number;
+    action: EponymeAction | 'restore';
+    status: EponymeStatus;
+    createdAt: string;
+    user: EponymeVersionAuthor | null;
+}
+/** Raised when a concurrent write changed the entry between our read and our write. */
+export interface EponymeConflict {
+    conflict: true;
+    errors?: never;
+}
+export interface EponymeCollectionEntry<Data extends Record<string, unknown> = Record<string, unknown>> {
+    slug: string;
+    title: string;
+    data: Data;
+    status: EponymeStatus;
+    publishedAt: string | null;
+    updatedAt: string | null;
+}
+export interface EponymeSitemapEntry {
+    loc: string;
+    lastmod?: string;
+}
+export type PrismaEponymeRow = {
+    name: string;
+    data: unknown;
+    updatedAt?: Date | string;
+};
+export type PrismaEponymeVersionRow = {
+    id: number;
+    entryName: string;
+    data: unknown;
+    action: string;
+    status: string;
+    createdAt: Date | string;
+    userId?: string | null;
+    user?: {
+        id: string;
+        username: string;
+    } | null;
+};
+export type PrismaEponymeClient = {
+    eponyme: {
+        upsert(args: {
+            where: {
+                name: string;
+            };
+            create: {
+                name: string;
+                data: Record<string, unknown>;
+            };
+            update: {
+                data?: Record<string, unknown>;
+            };
+        }): Promise<PrismaEponymeRow>;
+        update(args: {
+            where: {
+                name: string;
+            };
+            data: {
+                data: Record<string, unknown>;
+            };
+        }): Promise<PrismaEponymeRow>;
+        /** Used as a compare-and-swap: the `updatedAt` guard makes concurrent writes fail instead of overwriting. */
+        updateMany(args: {
+            where: {
+                name: string;
+                updatedAt?: Date | string;
+            };
+            data: {
+                data: Record<string, unknown>;
+            };
+        }): Promise<{
+            count: number;
+        }>;
+        create(args: {
+            data: {
+                name: string;
+                data: Record<string, unknown>;
+            };
+        }): Promise<PrismaEponymeRow>;
+        findUnique(args: {
+            where: {
+                name: string;
+            };
+        }): Promise<PrismaEponymeRow | null>;
+        findMany(args: {
+            where: {
+                name: {
+                    startsWith: string;
+                };
+            };
+            orderBy: Array<{
+                updatedAt: 'desc';
+            } | {
+                name: 'asc';
+            }>;
+        }): Promise<PrismaEponymeRow[]>;
+        delete(args: {
+            where: {
+                name: string;
+            };
+        }): Promise<PrismaEponymeRow>;
+    };
+    eponymeVersion: {
+        create(args: {
+            data: {
+                entryName: string;
+                data: Record<string, unknown>;
+                action: string;
+                status: EponymeStatus;
+                userId?: string | null;
+            };
+        }): Promise<PrismaEponymeVersionRow>;
+        findMany(args: {
+            where: {
+                entryName: string;
+            };
+            orderBy: {
+                createdAt: 'desc';
+            };
+            take: number;
+            include?: {
+                user: true;
+            };
+        }): Promise<PrismaEponymeVersionRow[]>;
+        findUnique(args: {
+            where: {
+                id: number;
+            };
+        }): Promise<PrismaEponymeVersionRow | null>;
+    };
+};
+export declare class EponymeService {
+    private readonly client;
+    private readonly schemas;
+    private readonly collections;
+    constructor(config: EponymeConfig, client: PrismaEponymeClient);
+    getSchema(name: string): EponymeSchema | undefined;
+    getCollection(name: string): EponymeCollectionDefinitionBase | undefined;
+    private getCollectionEntry;
+    /** Reconcile every configured eponyme at application startup. */
+    syncAll(): Promise<void>;
+    private reconcile;
+    private createState;
+    private normalizeState;
+    /** Reads the stored state along with the `updatedAt` it was read at, used as the optimistic lock token. */
+    private loadRow;
+    private loadState;
+    /**
+     * Writes a new state only if the row still carries the `updatedAt` we read.
+     * Returns false when a concurrent editor won the race, so the caller can report a conflict
+     * instead of silently discarding their changes.
+     */
+    private writeState;
+    get(name: string, version?: EponymeVersionSelector): Promise<Record<string, unknown> | undefined>;
+    getResult(name: string, version?: EponymeVersionSelector): Promise<EponymeResult | undefined>;
+    /** 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>;
+    /**
+     * 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[]>;
+    createCollectionEntry(name: string, payload: unknown, actorId?: string): Promise<(EponymeResult & {
+        slug: string;
+        errors?: never;
+    }) | {
+        errors: ValidationErrors;
+    } | undefined>;
+    deleteCollectionEntry(name: string): Promise<boolean>;
+    patch(name: string, payload: unknown, action?: EponymeAction, actorId?: string): Promise<(EponymeResult & {
+        errors?: never;
+        conflict?: never;
+    }) | {
+        errors: ValidationErrors;
+        conflict?: never;
+    } | EponymeConflict | undefined>;
+    history(name: string, limit?: number): Promise<EponymeHistoryEntry[] | undefined>;
+    restore(name: string, versionId: number, actorId?: string): Promise<EponymeResult | EponymeConflict | undefined>;
+}
+export declare function isPrismaError(error: unknown, code: string): boolean;