AfiS-Aktensystem/web/lib/auth/effective.ts

import { db } from '@/lib/db'
import { getEnv } from '@/lib/env'
import { TtlCache } from '@/lib/auth/cache'
import {
  PERMISSIONS,
  isPermission,
  type EffectivePermissions,
  type Permission,
} from '@/lib/auth/permissions'
import { highestRungPerLadder } from '@/lib/auth/ladders'

/** Höchste Freigabestufe. */
const MAX_CLEARANCE = 5

/**
 * 60 Sekunden Verfallszeit als Sicherheitsnetz. Der reguläre Weg ist die
 * sofortige Verwerfung bei `member_changed` oder `role_mapping_changed`.
 */
const cache = new TtlCache<string, EffectivePermissions>(60_000, 200)

/** Wird vom LISTEN-Client aufgerufen, siehe lib/realtime/listener.ts. */
export function invalidateUser(userId: string): void {
  cache.delete(userId)
}

/** Eine Änderung am Rollen-Mapping betrifft potenziell jeden. */
export function invalidateAll(): void {
  cache.clear()
}

function bootstrapAdmin(userId: string): EffectivePermissions {
  return {
    userId,
    clearanceLevel: MAX_CLEARANCE,
    permissions: new Set<Permission>(PERMISSIONS),
    isAdmin: true,
    hasMembership: true,
  }
}

/**
 * Löst die Rechte eines Nutzers aus `UserRole` × `RoleMapping` auf:
 * höchste Stufe aller Rollen, Vereinigung aller Rechte.
 *
 * Steht eine Rolle in einem Ranggefüge, zählt zusätzlich alles, was die
 * Sprossen unter ihr gewähren. Das trägt den Fall, dass beim Befördern in
 * Discord die alte Rangrolle abgenommen wird: die neue allein muss dann schon
 * genügen. Siehe lib/auth/ladders.ts.
 *
 * `hasMembership` ist eine Ergänzung gegenüber docs/03-auth-und-rechte.md und
 * bildet den Türsteher ab: auf dem AfiS-Discord sind auch Gäste, die keine
 * Akte sehen dürfen. Siehe docs/13-entscheidungen.md.
 *
 * Notfall-Admins aus `BOOTSTRAP_ADMIN_IDS` bekommen immer Stufe 5 und alle
 * Rechte, ohne Datenbankabfrage. Ohne das sperrt man sich beim ersten Fehler
 * in der Rollenverwaltung selbst aus.
 */
export async function resolvePermissions(userId: string): Promise<EffectivePermissions> {
  const cached = cache.get(userId)
  if (cached) return cached

  if (getEnv().BOOTSTRAP_ADMIN_IDS.includes(userId)) {
    const resolved = bootstrapAdmin(userId)
    cache.set(userId, resolved)
    return resolved
  }

  // Eine Abfrage, kein Nachfiltern in JavaScript.
  const rows = await db.userRole.findMany({
    where: { userId },
    select: {
      discordRoleId: true,
    },
  })

  const roleIds = rows.map((r) => r.discordRoleId)
  const mappings =
    roleIds.length === 0
      ? []
      : await db.roleMapping.findMany({
          where: { discordRoleId: { in: roleIds } },
          select: {
            clearanceLevel: true,
            permissions: true,
            grantsMembership: true,
            ladderId: true,
            ladderRank: true,
          },
        })

  // Steht eine der Rollen in einem Ranggefüge, gilt auch alles darunter. Das
  // wird **nachgeladen** statt in JavaScript aus der ganzen Tabelle gefiltert:
  // die Bedingung steht in der Abfrage, so wie bei jedem anderen Zugriff auch.
  // Siehe lib/auth/ladders.ts für den Grund der Vererbung.
  const hoechste = highestRungPerLadder(mappings)
  const geerbt =
    hoechste.size === 0
      ? []
      : await db.roleMapping.findMany({
          where: {
            OR: [...hoechste].map(([ladderId, rang]) => ({
              ladderId,
              ladderRank: { lte: rang },
            })),
          },
          select: { clearanceLevel: true, permissions: true, grantsMembership: true },
        })

  let clearanceLevel = 0
  let hasMembership = false
  const permissions = new Set<Permission>()

  for (const mapping of [...mappings, ...geerbt]) {
    if (mapping.clearanceLevel > clearanceLevel) clearanceLevel = mapping.clearanceLevel
    if (mapping.grantsMembership) hasMembership = true
    for (const value of mapping.permissions) {
      if (isPermission(value)) permissions.add(value)
    }
  }

  const resolved: EffectivePermissions = {
    userId,
    clearanceLevel: Math.min(clearanceLevel, MAX_CLEARANCE),
    permissions,
    isAdmin: permissions.has('admin'),
    hasMembership,
  }

  cache.set(userId, resolved)
  return resolved
}