@karibsen/eponyme 0.1.0

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: import("../../../types/index.js").EponymeAuthUser | null;
+}>>;
+export default _default;

package/dist/runtime/server/api/eponyme-auth/session.get.js

@@ -0,0 +1,5 @@
+import { defineEventHandler } from "h3";
+import { getEponymeEventUser } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => ({
+  user: await getEponymeEventUser(event) ?? null
+}));

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

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

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

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

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    entries: import("../../services/eponyme-store.js").EponymeCollectionEntry<Record<string, unknown>>[];
+}>>;
+export default _default;

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

@@ -0,0 +1,11 @@
+import { createError, defineEventHandler, getQuery, getRequestURL } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { requireEponymeUser } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-collections\//, ""));
+  const version = getQuery(event).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 };
+});

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

@@ -0,0 +1,7 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<(import("../../services/eponyme-store.js").EponymeResult & {
+    slug: string;
+    errors?: never;
+}) | {
+    errors: import("../../../utils/validate-eponyme-data.js").ValidationErrors;
+}>>;
+export default _default;

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

@@ -0,0 +1,16 @@
+import { createError, defineEventHandler, getRequestURL, readBody, setResponseStatus } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.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-collections\//, ""));
+  const result = name ? await useEponymeService().createCollectionEntry(name, await readBody(event), user.id) : void 0;
+  if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme collection not found." });
+  if (result.errors) {
+    setResponseStatus(event, 422);
+    return { errors: result.errors };
+  }
+  setResponseStatus(event, 201);
+  return result;
+});

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

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

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

@@ -0,0 +1,19 @@
+import { createError, defineEventHandler } from "h3";
+import { useEponymeFormService } from "../../services/eponyme-form-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+import { readEponymeFormRoute } from "../../utils/form-route.js";
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  const route = readEponymeFormRoute(event);
+  if (!route?.submissions) throw createError({ statusCode: 404, statusMessage: "Eponyme submission not found." });
+  const service = useEponymeFormService();
+  if (!route.submissionId) {
+    const deleted = await service.deleteAllSubmissions(route.name);
+    if (deleted === void 0) throw createError({ statusCode: 404, statusMessage: "Eponyme form not found." });
+    return { deleted };
+  }
+  if (!await service.deleteSubmission(route.name, route.submissionId))
+    throw createError({ statusCode: 404, statusMessage: "Eponyme submission not found." });
+  return { deleted: true };
+});

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../services/eponyme-form-store.js").EponymeFormSubmissionPage | {
+    submission: import("../../services/eponyme-form-store.js").EponymeFormSubmission;
+}>>;
+export default _default;

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

@@ -0,0 +1,22 @@
+import { createError, defineEventHandler, getQuery } from "h3";
+import { useEponymeFormService } from "../../services/eponyme-form-service.js";
+import { requireEponymeUser } from "../../utils/auth.js";
+import { readEponymeFormRoute } from "../../utils/form-route.js";
+export default defineEventHandler(async (event) => {
+  await requireEponymeUser(event);
+  const route = readEponymeFormRoute(event);
+  if (!route?.submissions) throw createError({ statusCode: 404, statusMessage: "Eponyme form not found." });
+  const service = useEponymeFormService();
+  if (route.submissionId) {
+    const submission = await service.getSubmission(route.name, route.submissionId);
+    if (!submission) throw createError({ statusCode: 404, statusMessage: "Eponyme submission not found." });
+    return { submission };
+  }
+  const query = getQuery(event);
+  const page = await service.listSubmissions(route.name, {
+    page: Number(query.page ?? 1),
+    perPage: query.perPage === void 0 ? void 0 : Number(query.perPage)
+  });
+  if (!page) throw createError({ statusCode: 404, statusMessage: "Eponyme form not found." });
+  return page;
+});

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

@@ -0,0 +1,19 @@
+/**
+ * The only unauthenticated write route in the module. Order matters: reject an
+ * oversized body before parsing it, and answer a normal success to a triggered
+ * honeypot so a bot learns nothing from the response.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    submitted: boolean;
+    errors?: undefined;
+    id?: undefined;
+} | {
+    errors: import("../../../utils/validate-eponyme-data.js").ValidationErrors;
+    submitted?: undefined;
+    id?: undefined;
+} | {
+    submitted: boolean;
+    id: string;
+    errors?: undefined;
+}>>;
+export default _default;

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

@@ -0,0 +1,36 @@
+import { createError, defineEventHandler, getRequestHeader, readRawBody, setResponseHeader, setResponseStatus } from "h3";
+import { useEponymeFormService } from "../../services/eponyme-form-service.js";
+import { readEponymeFormRoute } from "../../utils/form-route.js";
+export default defineEventHandler(async (event) => {
+  const route = readEponymeFormRoute(event);
+  const service = useEponymeFormService();
+  const definition = route && !route.submissions ? service.getForm(route.name) : void 0;
+  if (!route || !definition || definition.submission.mode !== "managed")
+    throw createError({ statusCode: 404, statusMessage: "Eponyme form not found." });
+  setResponseHeader(event, "Cache-Control", "no-store");
+  const declaredLength = Number(getRequestHeader(event, "content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > definition.maxBodyBytes)
+    throw createError({ statusCode: 413, statusMessage: "Submission is too large." });
+  const raw = await readRawBody(event, "utf8");
+  if (raw && Buffer.byteLength(raw, "utf8") > definition.maxBodyBytes)
+    throw createError({ statusCode: 413, statusMessage: "Submission is too large." });
+  let payload;
+  try {
+    payload = raw ? JSON.parse(raw) : void 0;
+  } catch {
+    setResponseStatus(event, 422);
+    return { errors: { _form: ["Body must be valid JSON."] } };
+  }
+  if (service.isHoneypotTriggered(route.name, payload)) {
+    setResponseStatus(event, 201);
+    return { submitted: true };
+  }
+  const result = await service.submit(route.name, payload);
+  if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme form not found." });
+  if ("errors" in result) {
+    setResponseStatus(event, 422);
+    return { errors: result.errors };
+  }
+  setResponseStatus(event, 201);
+  return { submitted: true, id: result.submission.id };
+});

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    history: import("../../services/eponyme-store.js").EponymeHistoryEntry[];
+}>>;
+export default _default;

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

@@ -0,0 +1,11 @@
+import { createError, defineEventHandler, getQuery, getRequestURL } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { requireEponymeUser } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  await requireEponymeUser(event);
+  const name = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-history\//, ""));
+  const requestedLimit = Number(getQuery(event).limit ?? 50);
+  const history = name ? await useEponymeService().history(name, Number.isFinite(requestedLimit) ? requestedLimit : 50) : void 0;
+  if (!history) throw createError({ statusCode: 404, statusMessage: "Eponyme entry not found." });
+  return { history };
+});

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

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

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

@@ -0,0 +1,18 @@
+import { createError, defineEventHandler, getRequestURL } from "h3";
+import { useEponymeService } from "../../services/eponyme-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  const user = await requireEponymeUser(event, { roles: ["editor", "owner"] });
+  const path = decodeURIComponent(getRequestURL(event).pathname.replace(/^\/api\/eponyme-history\//, ""));
+  const match = path.match(/^(.+)\/(\d+)$/);
+  if (!match) throw createError({ statusCode: 400, statusMessage: "A valid version id is required." });
+  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);
+  if (!result) throw createError({ statusCode: 404, statusMessage: "Eponyme version 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." });
+  return result;
+});

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    entries: import("../services/eponyme-store.js").EponymeSitemapEntry[];
+}>>;
+export default _default;

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

@@ -0,0 +1,5 @@
+import { defineEventHandler } from "h3";
+import { getEponymeSitemapEntries } from "../utils/eponyme-sitemap.js";
+export default defineEventHandler(async () => {
+  return { entries: await getEponymeSitemapEntries() };
+});

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    statuses: Record<string, import("../services/eponyme-store.js").EponymeStatus>;
+}>>;
+export default _default;

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

@@ -0,0 +1,7 @@
+import { defineEventHandler } from "h3";
+import { useEponymeService } from "../services/eponyme-service.js";
+import { requireEponymeUser } from "../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  await requireEponymeUser(event);
+  return { statuses: await useEponymeService().statuses() };
+});

package/dist/runtime/server/api/eponyme-users/[id]/reset-password.post.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: import("../../../../types/index.js").EponymeAuthUser;
+    temporaryPassword: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/eponyme-users/[id]/reset-password.post.js

@@ -0,0 +1,12 @@
+import { createError, defineEventHandler, getRouterParam } from "h3";
+import { useEponymeAuthService } from "../../../services/eponyme-auth-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  await requireEponymeUser(event, { roles: ["owner"] });
+  const id = getRouterParam(event, "id", { decode: true });
+  const result = id ? await useEponymeAuthService().resetPassword(id) : void 0;
+  if (!result?.result)
+    throw createError({ statusCode: 404, message: result?.error ?? "User not found." });
+  return result.result;
+});

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: import("../../../types/index.js").EponymeAuthUser;
+}>>;
+export default _default;

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

@@ -0,0 +1,14 @@
+import { createError, defineEventHandler, getRouterParam, readBody } from "h3";
+import { useEponymeAuthService } from "../../services/eponyme-auth-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  await requireEponymeUser(event, { roles: ["owner"] });
+  const id = getRouterParam(event, "id", { decode: true });
+  if (!id) throw createError({ statusCode: 404, message: "User not found." });
+  const body = await readBody(event);
+  const result = await useEponymeAuthService().updateUser(id, body ?? {});
+  if (!result.user)
+    throw createError({ statusCode: result.notFound ? 404 : 422, message: result.error });
+  return { user: result.user };
+});

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    users: import("../../../types/index.js").EponymeAuthUser[];
+}>>;
+export default _default;

package/dist/runtime/server/api/eponyme-users/index.get.js

@@ -0,0 +1,7 @@
+import { defineEventHandler } from "h3";
+import { useEponymeAuthService } from "../../services/eponyme-auth-service.js";
+import { requireEponymeUser } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  await requireEponymeUser(event, { roles: ["owner"] });
+  return { users: await useEponymeAuthService().listUsers() };
+});

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

@@ -0,0 +1,5 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    user: import("../../../types/index.js").EponymeAuthUser;
+    temporaryPassword: string;
+}>>;
+export default _default;

package/dist/runtime/server/api/eponyme-users/index.post.js

@@ -0,0 +1,13 @@
+import { createError, defineEventHandler, readBody, setResponseStatus } from "h3";
+import { useEponymeAuthService } from "../../services/eponyme-auth-service.js";
+import { assertEponymeMutationOrigin, requireEponymeUser } from "../../utils/auth.js";
+export default defineEventHandler(async (event) => {
+  assertEponymeMutationOrigin(event);
+  await requireEponymeUser(event, { roles: ["owner"] });
+  const body = await readBody(event);
+  const created = await useEponymeAuthService().createUser(body?.username, body?.role);
+  if (!created.result)
+    throw createError({ statusCode: 422, statusMessage: created.error ?? "Unable to create user." });
+  setResponseStatus(event, 201);
+  return created.result;
+});

package/dist/runtime/server/plugins/eponyme-sync.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/server/plugins/eponyme-sync.js

@@ -0,0 +1,14 @@
+import { defineNitroPlugin } from "nitropack/runtime";
+import { useEponymeAuthService } from "../services/eponyme-auth-service.js";
+import { useEponymeService } from "../services/eponyme-service.js";
+export default defineNitroPlugin(async () => {
+  try {
+    await useEponymeAuthService().bootstrapOwner();
+  } catch (error) {
+    throw new Error(
+      "[Eponyme] Authentication bootstrap failed. Apply the EponymeUser and EponymeUserSession Prisma migration before starting the application.",
+      { cause: error }
+    );
+  }
+  await useEponymeService().syncAll();
+});

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

@@ -0,0 +1,2 @@
+import { EponymeAuthService } from './eponyme-auth-store.js';
+export declare function useEponymeAuthService(): EponymeAuthService;

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

@@ -0,0 +1,15 @@
+import prisma from "#eponyme/prisma";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { EponymeAuthService } from "./eponyme-auth-store.js";
+let authService;
+export function useEponymeAuthService() {
+  if (!authService) {
+    const config = useRuntimeConfig();
+    const authConfig = config.eponymeAuth;
+    authService = new EponymeAuthService(
+      prisma,
+      authConfig?.sessionDurationDays ?? 7
+    );
+  }
+  return authService;
+}

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

@@ -0,0 +1,119 @@
+import type { EponymeAuthUser } from '../../types/index.js';
+type DateValue = Date | string;
+export interface PrismaEponymeUserRow {
+    id: string;
+    username: string;
+    usernameNormalized: string;
+    passwordHash: string;
+    role: string;
+    active: boolean;
+    mustChangePassword: boolean;
+    failedLoginAttempts: number;
+    lockedUntil: DateValue | null;
+    createdAt: DateValue;
+    updatedAt: DateValue;
+}
+export interface PrismaEponymeSessionRow {
+    id: string;
+    tokenHash: string;
+    userId: string;
+    expiresAt: DateValue;
+    createdAt: DateValue;
+    user?: PrismaEponymeUserRow;
+}
+export interface PrismaEponymeAuthClient {
+    eponymeUser: {
+        count(args?: {
+            where?: Record<string, unknown>;
+        }): Promise<number>;
+        create(args: {
+            data: Record<string, unknown>;
+        }): Promise<PrismaEponymeUserRow>;
+        findUnique(args: {
+            where: Record<string, unknown>;
+        }): Promise<PrismaEponymeUserRow | null>;
+        findMany(args: {
+            orderBy: Record<string, 'asc' | 'desc'>;
+        }): Promise<PrismaEponymeUserRow[]>;
+        update(args: {
+            where: Record<string, unknown>;
+            data: Record<string, unknown>;
+        }): Promise<PrismaEponymeUserRow>;
+    };
+    eponymeUserSession: {
+        create(args: {
+            data: Record<string, unknown>;
+        }): Promise<PrismaEponymeSessionRow>;
+        findUnique(args: {
+            where: Record<string, unknown>;
+            include: {
+                user: true;
+            };
+        }): Promise<PrismaEponymeSessionRow | null>;
+        delete(args: {
+            where: Record<string, unknown>;
+        }): Promise<PrismaEponymeSessionRow>;
+        deleteMany(args: {
+            where: Record<string, unknown>;
+        }): Promise<{
+            count: number;
+        }>;
+    };
+    /** Optional so tests can pass a plain fake client; real Prisma clients always provide it. */
+    $transaction?: <T>(fn: (tx: PrismaEponymeAuthClient) => Promise<T>, options?: {
+        isolationLevel?: 'Serializable';
+    }) => Promise<T>;
+}
+export interface CreatedSession {
+    token: string;
+    expiresAt: Date;
+    user: EponymeAuthUser;
+}
+export type LoginResult = {
+    ok: true;
+    session: CreatedSession;
+} | {
+    ok: false;
+    reason: 'invalid' | 'locked';
+};
+export declare class EponymeAuthService {
+    private readonly client;
+    private readonly sessionDurationDays;
+    constructor(client: PrismaEponymeAuthClient, sessionDurationDays?: number);
+    bootstrapOwner(log?: (message: string) => void): Promise<boolean>;
+    login(username: unknown, password: unknown): Promise<LoginResult>;
+    getSession(token: string | undefined): Promise<CreatedSession | undefined>;
+    logout(token: string | undefined): Promise<void>;
+    changePassword(userId: string, currentPassword: unknown, newPassword: unknown): Promise<{
+        session?: CreatedSession;
+        error?: string;
+    }>;
+    listUsers(): Promise<EponymeAuthUser[]>;
+    createUser(username: unknown, role: unknown): Promise<{
+        result?: {
+            user: EponymeAuthUser;
+            temporaryPassword: string;
+        };
+        error?: string;
+    }>;
+    updateUser(id: string, changes: {
+        role?: unknown;
+        active?: unknown;
+    }): Promise<{
+        user?: EponymeAuthUser;
+        error?: string;
+        notFound?: boolean;
+    }>;
+    resetPassword(id: string): Promise<{
+        result?: {
+            user: EponymeAuthUser;
+            temporaryPassword: string;
+        };
+        error?: string;
+    }>;
+    private createSession;
+    private recordFailedLogin;
+}
+export declare function normalizeUsername(username: string): string;
+export declare function validateUsername(username: unknown): string | undefined;
+export {};