kita-planer/src/auth.ts

import NextAuth from "next-auth";
import Credentials from "next-auth/providers/credentials";
import { compare } from "bcryptjs";
import { limitPublicAction } from "@/lib/rate-limit";
import { z } from "zod";

import { prisma } from "@/lib/prisma";

// =====================================================================
// NextAuth.js (Auth.js v5) · Credentials-Provider mit JWT-Strategie
// ---------------------------------------------------------------------
// Mandantenfähigkeit: `id`, `role`, `kitaId`, `familyId` werden über die JWT-/Session-
// Callbacks aus der DB in jede Session durchgeschleift, damit jede
// Server Action / API-Route den Tenant-Filter setzen kann.
// =====================================================================

const credentialsSchema = z.object({
  email: z.string().trim().max(254).email().toLowerCase(),
  password: z.string().min(1).refine(value => Buffer.byteLength(value, "utf8") <= 72),
});

// Brute-Force-Schutz auf Account-Ebene (planung.md §5.5).
// Zusätzlich greifen atomare, instanzübergreifende DB-Limits vor bcrypt.
const MAX_FAILED_ATTEMPTS = 10;
const LOCKOUT_MINUTES = 15;

export const { handlers, auth, signIn, signOut } = NextAuth({
  session: { strategy: "jwt" },
  pages: {
    signIn: "/login",
  },
  providers: [
    Credentials({
      name: "Credentials",
      credentials: {
        email: { label: "E-Mail", type: "email" },
        password: { label: "Passwort", type: "password" },
      },
      async authorize(rawCredentials) {
        const parsed = credentialsSchema.safeParse(rawCredentials);
        if (!parsed.success) return null;
        const { email, password } = parsed.data;

        if (!(await limitPublicAction("login", email, 20, 900))) return null;
        const user = await prisma.user.findUnique({ where: { email } });
        if (!user) {
          // Match the cost for nonexistent accounts without exposing account existence.
          await compare(password, "$2b$12$KbQiLuL6QbybTw/WNx4Ige2yCZcjVccoruuDx3vmkJt8YYUpphdIu");
          return null;
        }
        if (user.disabledAt || !user.emailVerifiedAt) return null;

        // Account temporär gesperrt → Login pauschal ablehnen.
        if (user.lockedUntil && user.lockedUntil > new Date()) {
          return null;
        }

        const passwordOk = await compare(password, user.passwordHash);
        if (!passwordOk) {
          await prisma.$executeRaw`
            UPDATE users SET "failedLoginAttempts" = "failedLoginAttempts" + 1,
              "lockedUntil" = CASE WHEN "failedLoginAttempts" + 1 >= ${MAX_FAILED_ATTEMPTS}
                THEN NOW() + make_interval(mins => ${LOCKOUT_MINUTES}::int) ELSE "lockedUntil" END
            WHERE id = ${user.id}`;
          return null;
        }

        // Erfolgreicher Login → Counter zurücksetzen, lastLogin aktualisieren.
        const admitted = await prisma.user.updateMany({
          where: { id: user.id, disabledAt: null, sessionVersion: user.sessionVersion, passwordHash: user.passwordHash, emailVerifiedAt: { not: null },
            OR: [{ lockedUntil: null }, { lockedUntil: { lte: new Date() } }] },
          data: {
            failedLoginAttempts: 0,
            lockedUntil: null,
            lastLoginAt: new Date(),
          },
        });

        if (admitted.count !== 1) return null;
        return {
          sessionVersion: user.sessionVersion,
          authenticatedAt: Date.now(),
          id: user.id,
          email: user.email,
          name: `${user.firstName} ${user.lastName}`.trim(),
          role: user.role,
          kitaId: user.kitaId,
          familyId: user.familyId,
        };
      },
    }),
  ],
  callbacks: {
    async redirect({ url, baseUrl }) {
      if (/[\\\x00-\x20]/.test(url)) return baseUrl;
      try {
        const destination = new URL(url, baseUrl);
        return destination.origin === new URL(baseUrl).origin ? destination.href : baseUrl;
      } catch { return baseUrl; }
    },
    /**
     * Wird beim Login (mit `user`) und bei jedem Token-Refresh (ohne `user`)
     * aufgerufen. Beim Login schreiben wir die mandantenrelevanten Felder
     * einmalig in den Token; bei jedem weiteren Aufruf re-validieren wir
     * `role` und `kitaId` gegen die DB, damit z.B. ein gerade entzogener
     * Admin-Rang sofort greift (kein 30-Tage-Token mit veralteter Rolle).
     */
    async jwt({ token, user }) {
      if (user) {
        token.id = user.id;
        token.sessionVersion = user.sessionVersion;
        token.authenticatedAt = user.authenticatedAt;
      }
      const id = token.id ?? token.sub;
      if (typeof id !== "string" || !id || id.length > 64 || !Number.isSafeInteger(token.sessionVersion) || !Number.isFinite(token.authenticatedAt) || token.authenticatedAt > Date.now() + 60_000) return null;
      const fresh = await prisma.user.findUnique({
        where: { id },
        select: { role: true, kitaId: true, familyId: true, disabledAt: true, sessionVersion: true, emailVerifiedAt: true },
      });
      if (!fresh || fresh.disabledAt || !fresh.emailVerifiedAt || fresh.sessionVersion !== token.sessionVersion) return null;
      token.id = id;
      token.role = fresh.role;
      token.kitaId = fresh.kitaId;
      token.familyId = fresh.familyId;
      return token;
    },

    /**
     * Wird bei jedem `auth()` /  `useSession()`-Aufruf ausgeführt.
     * Hier projizieren wir die JWT-Felder in das Session-Objekt,
     * damit Server Components / Client Components sie typsicher lesen können.
     */
    async session({ session, token }) {
      if (token && session.user) {
        session.user.id = token.id;
        session.user.sessionVersion = token.sessionVersion;
        session.user.authenticatedAt = token.authenticatedAt;
        session.user.role = token.role;
        session.user.kitaId = token.kitaId;
        session.user.familyId = token.familyId;
      }
      return session;
    },
  },
});