Florian Wilde
f1cdb3da13
Umschaltbar ueber AUTH_ENABLED in der .env. Steht sie auf false, verhaelt
sich alles wie bisher - geprueft mit den 200 bestehenden Pruefungen.
Kern ist eine Actor- und Policy-Schicht: getActor() liefert bei
ausgeschalteter Anmeldung einen system-Actor mit Vollzugriff, sonst den
angemeldeten Benutzer. Dadurch braucht keine einzige Route ein
'if (anmeldungAktiv)' - sie fragen alle nur can() bzw. requirePermission().
- Datenmodell: User, Session, Group, Membership; Codes bekommen Gruppe und
Ersteller. Die Migration legt eine Standardgruppe an und ordnet ihr
bestehende Codes zu, bevor die Spalte verpflichtend wird - sonst
scheiterte sie auf jeder bereits benutzten Installation.
- Passwoerter mit scrypt aus der Node-Standardbibliothek. Bewusst kein
Argon2: das braeuchte ein natives Modul passend zur Container-Plattform.
- Sitzungen in der Datenbank, im Cookie nur ein Zufallstoken; gespeichert
wird dessen SHA-256. Deaktivieren oder ein neues Passwort beendet alle
offenen Sitzungen sofort.
- Aussperrschutz: der letzte aktive Administrator kann sich nicht selbst
entmachten, deaktivieren oder loeschen. Der Schalter liegt in der .env,
nicht in der Oberflaeche - so bleibt der Weg zurueck immer offen.
- Ersteinrichtung legt den ersten Administrator an und schliesst sich danach.
- Die Weiterleitung /r/{slug} bleibt oeffentlich, sonst liesse sich kein
gedruckter Code mehr scannen.
Zwei Fehler dabei gefunden und behoben:
- 'return handleLogin(...)' innerhalb eines try-Blocks gibt das Promise
zurueck, bevor es sich aufloest. Die Ablehnung kam nie im catch an und
wurde zu einem nackten 500er statt einer 401. Jetzt mit await.
- Die Fehlerklassen wurden ueber instanceof erkannt. type-module.ts landet
aber sowohl im Server- als auch im Client-Buendel, es gibt also zwei
Klassenidentitaeten - saubere 400er wurden dadurch still zu 500ern. Die
Erkennung laeuft jetzt ueber eine Eigenschaft.
Geprueft: 51 neue Pruefungen fuer Anmeldung und die vollstaendige
Rollenmatrix, dazu die 200 bestehenden bei ausgeschalteter Anmeldung.
91 lines
2.7 KiB
TypeScript
91 lines
2.7 KiB
TypeScript
import type { NextRequest } from "next/server";
|
|
import { z } from "zod";
|
|
|
|
import { getActor } from "@/lib/auth/actor";
|
|
import { can, requirePermission, visibleGroupIds } from "@/lib/auth/policy";
|
|
import { prisma } from "@/lib/db";
|
|
import { errorResponse, firstZodMessage, jsonError } from "@/lib/http";
|
|
import { QrRequestError } from "@/lib/qr/type-module";
|
|
|
|
export const dynamic = "force-dynamic";
|
|
|
|
const createSchema = z.object({
|
|
name: z
|
|
.string()
|
|
.trim()
|
|
.min(1, { error: "Bitte gib einen Namen für die Gruppe ein." })
|
|
.max(80, { error: "Der Name darf höchstens 80 Zeichen lang sein." }),
|
|
description: z.string().trim().max(300).optional(),
|
|
});
|
|
|
|
/** Gruppen samt Mitgliedern — gefiltert nach dem, was der Actor sehen darf. */
|
|
export async function GET(): Promise<Response> {
|
|
try {
|
|
const actor = await getActor();
|
|
if (actor.kind === "anonymous") {
|
|
throw new QrRequestError("Bitte melde dich an.", 401);
|
|
}
|
|
|
|
const visible = visibleGroupIds(actor);
|
|
const groups = await prisma.group.findMany({
|
|
where: visible === null ? undefined : { id: { in: visible } },
|
|
orderBy: { name: "asc" },
|
|
include: {
|
|
memberships: {
|
|
include: { user: { select: { id: true, email: true, name: true } } },
|
|
orderBy: { createdAt: "asc" },
|
|
},
|
|
_count: { select: { codes: true } },
|
|
},
|
|
});
|
|
|
|
return Response.json({
|
|
groups: groups.map((group) => ({
|
|
id: group.id,
|
|
name: group.name,
|
|
description: group.description,
|
|
codeCount: group._count.codes,
|
|
canManage: can(actor, "group:manage", { groupId: group.id }),
|
|
members: group.memberships.map((m) => ({
|
|
userId: m.user.id,
|
|
email: m.user.email,
|
|
name: m.user.name,
|
|
role: m.role,
|
|
})),
|
|
})),
|
|
});
|
|
} catch (error) {
|
|
return errorResponse(error);
|
|
}
|
|
}
|
|
|
|
export async function POST(request: NextRequest): Promise<Response> {
|
|
try {
|
|
requirePermission(await getActor(), "instance:manage");
|
|
|
|
const parsed = createSchema.safeParse(await request.json());
|
|
if (!parsed.success) {
|
|
return jsonError(firstZodMessage(parsed.error));
|
|
}
|
|
|
|
const existing = await prisma.group.findUnique({
|
|
where: { name: parsed.data.name },
|
|
select: { id: true },
|
|
});
|
|
if (existing) {
|
|
throw new QrRequestError("Eine Gruppe mit diesem Namen gibt es schon.", 409);
|
|
}
|
|
|
|
const group = await prisma.group.create({
|
|
data: {
|
|
name: parsed.data.name,
|
|
description: parsed.data.description || null,
|
|
},
|
|
});
|
|
|
|
return Response.json({ group: { id: group.id, name: group.name } }, { status: 201 });
|
|
} catch (error) {
|
|
return errorResponse(error);
|
|
}
|
|
}
|