Initial commit: Kalendartool (Next.js, Prisma, Docker)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

lib/api/context.ts

@@ -0,0 +1,101 @@
+/**
+ * Hilfsfunktionen fuer API-Routen: laedt den Benutzer samt relevanten
+ * Beziehungen aus der Datenbank und stellt den Kontext fuer die
+ * Berechtigungspruefungen bereit.
+ *
+ * Wichtig (plan.md Abschnitt 2): Berechtigungen werden IMMER
+ * serverseitig geprueft, nie nur im Frontend versteckt.
+ */
+import { prisma } from '@/lib/db/client';
+import { getAuthenticatedUser } from '@/lib/auth/session';
+import { UnauthorizedError } from '@/lib/auth/session';
+import type { AuthenticatedUser } from '@/lib/permissions/permissions';
+
+export interface CalendarContext {
+  user: AuthenticatedUser;
+  calendar: {
+    id: string;
+    ownerId: string;
+    isActive: boolean;
+    title: string;
+    description: string | null;
+    timezone: string;
+    /** Maximale Reservierungsdauer in Minuten; 0 = unbegrenzt. */
+    maxReservationMinutes: number;
+    /** Duerven Nicht-Admins die Titel fremder Reservierungen sehen? */
+    showTitleToMembers: boolean;
+    /** Duerven Nicht-Admins die Notizen fremder Reservierungen sehen? */
+    showNotesToMembers: boolean;
+  };
+  /** Ist der angemeldete User Mitglied dieses Kalenders? */
+  isMember: boolean;
+}
+
+/** Laedt den vollstaendigen DB-Benutzer zur aktuellen Session. */
+export async function requireDbUser() {
+  const authUser = await getAuthenticatedUser();
+  const user = await prisma.user.findUnique({
+    where: { id: authUser.id },
+    select: { id: true, email: true, username: true, role: true },
+  });
+  if (!user) {
+    // Session gueltig, aber Benutzer geloescht -> Session ist ungueltig.
+    throw new UnauthorizedError();
+  }
+  return user;
+}
+
+/**
+ * Laedt einen Kalender samt Mitgliedschaft des Users.
+ * Wirft UnauthorizedError, wenn der User den Kalender ueberhaupt
+ * nicht sehen darf - so werden Daten anderer Kalender niemals ueber
+ * die API preisgegeben.
+ *
+ * Zugriff hat (konsistent mit canViewCalendar in der zentralen
+ * Berechtigungsschicht):
+ *   - ADMIN: alle Kalender (Verwaltungsrolle, auch die anderer User)
+ *   - USER: nur der eine Kalender, in dem er Mitglied ist
+ */
+export async function requireCalendarContext(
+  calendarId: string,
+): Promise<CalendarContext> {
+  const user = await requireDbUser();
+
+  const calendar = await prisma.calendar.findUnique({
+    where: { id: calendarId },
+    select: {
+      id: true,
+      ownerId: true,
+      isActive: true,
+      title: true,
+      description: true,
+      timezone: true,
+      maxReservationMinutes: true,
+      showTitleToMembers: true,
+      showNotesToMembers: true,
+    },
+  });
+  if (!calendar) {
+    throw new UnauthorizedError();
+  }
+
+  const isOwner = calendar.ownerId === user.id;
+  const membership = await prisma.calendarMember.findUnique({
+    where: { userId: user.id },
+    select: { calendarId: true },
+  });
+  const isMember = membership?.calendarId === calendar.id;
+
+  // Admins duerfen alle Kalender sehen und verwalten (canViewCalendar /
+  // canManageCalendar). User nur ihren eigenen (Mitgliedschaft).
+  const canAccess =
+    user.role === 'ADMIN' || isOwner || isMember;
+
+  if (!canAccess) {
+    // Bewusst 401 statt 404: Es wird nicht verraten, dass der
+    // Kalender existiert (plan.md Abschnitt 2).
+    throw new UnauthorizedError();
+  }
+
+  return { user, calendar, isMember };
+}

lib/api/responses.ts

@@ -0,0 +1,86 @@
+/**
+ * Einheitliche API-Antwort-Helfer (plan.md: "HTTP-Statuscodes korrekt
+ * verwenden", "saubere Fehlerbehandlung").
+ */
+import { NextResponse } from 'next/server';
+import { ZodError } from 'zod';
+import { UnauthorizedError } from '@/lib/auth/session';
+import {
+  ReservationConflictError,
+  ReservationValidationError,
+} from '@/lib/reservations/conflicts';
+import {
+  MaxDurationExceededError,
+  CalendarInactiveError,
+  ReservationNotFoundError,
+} from '@/lib/reservations/service';
+
+/** 400: Validierungsfehler mit lesbaren Meldungen. */
+export function validationErrorResponse(error: ZodError): NextResponse {
+  const messages = error.issues.map((issue) => issue.message).join(' ');
+  return NextResponse.json({ error: messages }, { status: 400 });
+}
+
+/** 401: Nicht angemeldet. */
+export function unauthorizedResponse(): NextResponse {
+  return NextResponse.json({ error: 'Nicht angemeldet.' }, { status: 401 });
+}
+
+/** 403: Angemeldet, aber keine Berechtigung. */
+export function forbiddenResponse(): NextResponse {
+  return NextResponse.json(
+    { error: 'Keine Berechtigung fuer diese Aktion.' },
+    { status: 403 },
+  );
+}
+
+/** 404: Ressource nicht gefunden (oder bewusst verschleiert). */
+export function notFoundResponse(message = 'Nicht gefunden.'): NextResponse {
+  return NextResponse.json({ error: message }, { status: 404 });
+}
+
+/** 409: Zeitkollision. */
+export function conflictResponse(): NextResponse {
+  return NextResponse.json(
+    { error: 'Der gewuenschte Zeitraum ist bereits belegt.' },
+    { status: 409 },
+  );
+}
+
+/**
+ * Mappt bekannte Fehler auf korrekte HTTP-Statuscodes.
+ * Unbekannte Fehler werden geloggt und als 500 gemeldet, ohne
+ * interne Details preiszugeben.
+ */
+export function errorResponse(error: unknown): NextResponse {
+  if (error instanceof ZodError) {
+    return validationErrorResponse(error);
+  }
+  if (error instanceof UnauthorizedError) {
+    return unauthorizedResponse();
+  }
+  if (error instanceof ReservationConflictError) {
+    return conflictResponse();
+  }
+  // Validierungsfehler (Vergangenheit, Start>=Ende): 400 mit Meldung.
+  if (error instanceof ReservationValidationError) {
+    return NextResponse.json({ error: error.message }, { status: 400 });
+  }
+  // Dauer ueberschritten: 400 mit lesbare Meldung (nicht 500).
+  if (error instanceof MaxDurationExceededError) {
+    return NextResponse.json({ error: error.message }, { status: 400 });
+  }
+  // Kalender deaktiviert/nicht gefunden: 403 (Berechtigung/Status).
+  if (error instanceof CalendarInactiveError) {
+    return NextResponse.json({ error: error.message }, { status: 403 });
+  }
+  // Reservierung nicht gefunden: 404.
+  if (error instanceof ReservationNotFoundError) {
+    return notFoundResponse(error.message);
+  }
+  console.error('[api] Unerwarteter Fehler:', error);
+  return NextResponse.json(
+    { error: 'Ein interner Fehler ist aufgetreten.' },
+    { status: 500 },
+  );
+}