8f870d9793
Unter aktivem Invite-Gating lieferte mana-auth diese Codes, AuthError.classify hatte aber keine Cases → native Sign-ups zeigten „Server-Fehler (403) — INVITE_REQUIRED: …" statt der sauberen deutschen Meldung. Jetzt eigene Cases (Server-Message durchgereicht), invalidatesSession=false. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
269 lines
11 KiB
Swift
269 lines
11 KiB
Swift
import Foundation
|
|
|
|
/// Fehler-Typen des Auth- und Transport-Layers.
|
|
///
|
|
/// Server-Fehler-Codes folgen `AuthErrorCode` aus
|
|
/// `mana/services/mana-auth/src/lib/auth-errors.ts`. Jeder dort
|
|
/// definierte Code hat hier einen passenden Case — neue Codes
|
|
/// auf Server-Seite brauchen einen Minor-Bump dieses Pakets.
|
|
public enum AuthError: Error, LocalizedError, Sendable, Equatable {
|
|
// MARK: - Client-Side
|
|
|
|
/// Kein Token im Keychain — User muss sich einloggen.
|
|
case notSignedIn
|
|
/// Lokales Encoding (z.B. UTF-8-Konvertierung) gescheitert.
|
|
case encoding
|
|
/// Keychain-Operation gescheitert mit OSStatus.
|
|
case keychain(OSStatus)
|
|
/// Antwort konnte nicht dekodiert werden.
|
|
case decoding(String)
|
|
/// Netzwerk-Schicht hat geworfen.
|
|
case networkFailure(String)
|
|
|
|
// MARK: - Server-Side (Mapping zu AuthErrorCode in mana-auth)
|
|
|
|
/// `INVALID_CREDENTIALS` — Email oder Passwort falsch.
|
|
case invalidCredentials
|
|
/// `EMAIL_NOT_VERIFIED` — Account existiert, Email muss bestätigt
|
|
/// werden. UI bietet "Bestätigungs-Mail erneut senden" an.
|
|
case emailNotVerified
|
|
/// `EMAIL_ALREADY_REGISTERED` — Sign-Up mit existierender Email.
|
|
case emailAlreadyRegistered
|
|
/// `WEAK_PASSWORD` — Passwort erfüllt Mindest-Policy nicht.
|
|
case weakPassword(message: String?)
|
|
/// `ACCOUNT_LOCKED` — zu viele Fehlversuche. `retryAfter` in Sekunden.
|
|
case accountLocked(retryAfter: TimeInterval?)
|
|
/// `SIGNUP_LIMIT_REACHED` — tägliches Registrierungs-Limit aus.
|
|
case signupLimitReached
|
|
/// `RATE_LIMITED` — generelles Rate-Limit. `retryAfter` in Sekunden.
|
|
case rateLimited(retryAfter: TimeInterval?)
|
|
/// `TOKEN_EXPIRED` — z.B. Reset-Token, Verify-Token.
|
|
case tokenExpired
|
|
/// `TOKEN_INVALID` — Token nicht parsebar / nicht gefunden.
|
|
case tokenInvalid
|
|
/// `TWO_FACTOR_REQUIRED` — Login erfolgreich, aber 2FA-Challenge offen.
|
|
case twoFactorRequired
|
|
/// `TWO_FACTOR_FAILED` — TOTP- oder Backup-Code falsch.
|
|
case twoFactorFailed
|
|
/// `PASSKEY_NOT_ENABLED` — User hat keinen Passkey registriert.
|
|
case passkeyNotEnabled
|
|
/// `PASSKEY_CANCELLED` — User hat den Plattform-Dialog abgebrochen.
|
|
case passkeyCancelled
|
|
/// `PASSKEY_VERIFICATION_FAILED` — WebAuthn-Verifikation gescheitert.
|
|
case passkeyVerificationFailed
|
|
/// `VALIDATION` — Request-Body ungültig (z.B. fehlendes Feld).
|
|
case validation(message: String?)
|
|
/// `INVITE_REQUIRED` — Konto-Anlage braucht eine Einladung (Gating aktiv).
|
|
case inviteRequired(message: String?)
|
|
/// `INVITE_INVALID` — Einladungs-Code ungültig/abgelaufen/verbraucht.
|
|
case inviteInvalid(message: String?)
|
|
/// `INVITE_CHECK_UNAVAILABLE` — Einladungs-Prüfung temporär nicht möglich.
|
|
case inviteCheckUnavailable
|
|
/// `UNAUTHORIZED` — fehlender oder ungültiger Authorization-Header.
|
|
case unauthorized
|
|
/// `NOT_FOUND` — referenzierte Ressource existiert nicht.
|
|
case notFound
|
|
/// `SERVICE_UNAVAILABLE` — Server temporär nicht erreichbar.
|
|
case serviceUnavailable
|
|
/// `INTERNAL` — Server-interner Fehler ohne weitere Klassifikation.
|
|
case serverInternal
|
|
|
|
/// Fallback für Server-Fehler ohne bekannten `AuthErrorCode`.
|
|
case serverError(status: Int, code: String?, message: String?)
|
|
|
|
public var errorDescription: String? {
|
|
switch self {
|
|
case .notSignedIn:
|
|
"Nicht angemeldet"
|
|
case .encoding:
|
|
"Datenkodierung fehlgeschlagen"
|
|
case let .keychain(status):
|
|
"Keychain-Fehler (OSStatus \(status))"
|
|
case let .decoding(detail):
|
|
"Antwort konnte nicht gelesen werden: \(detail)"
|
|
case let .networkFailure(message):
|
|
"Netzwerkfehler: \(message)"
|
|
case .invalidCredentials:
|
|
"Email oder Passwort falsch"
|
|
case .emailNotVerified:
|
|
"Bitte bestätige deine Email-Adresse, bevor du dich anmeldest."
|
|
case .emailAlreadyRegistered:
|
|
"Diese Email ist bereits registriert."
|
|
case let .weakPassword(message):
|
|
message ?? "Passwort erfüllt die Mindest-Anforderungen nicht."
|
|
case let .accountLocked(retryAfter):
|
|
retryAfter
|
|
.map { "Account temporär gesperrt. Erneut versuchen in \(Int($0))s." }
|
|
?? "Account temporär gesperrt."
|
|
case .signupLimitReached:
|
|
"Das tägliche Registrierungslimit ist erreicht. Versuche es morgen wieder."
|
|
case let .rateLimited(retryAfter):
|
|
retryAfter
|
|
.map { "Zu viele Versuche. Bitte warte \(Int($0))s." }
|
|
?? "Zu viele Versuche. Bitte warte einen Moment."
|
|
case .tokenExpired:
|
|
"Der Link ist abgelaufen. Bitte fordere einen neuen an."
|
|
case .tokenInvalid:
|
|
"Der Link ist ungültig."
|
|
case .twoFactorRequired:
|
|
"Zwei-Faktor-Code erforderlich."
|
|
case .twoFactorFailed:
|
|
"Zwei-Faktor-Code falsch."
|
|
case .passkeyNotEnabled:
|
|
"Für diesen Account ist kein Passkey eingerichtet."
|
|
case .passkeyCancelled:
|
|
"Passkey-Eingabe abgebrochen."
|
|
case .passkeyVerificationFailed:
|
|
"Passkey konnte nicht verifiziert werden."
|
|
case let .validation(message):
|
|
message ?? "Eingabe ungültig."
|
|
case let .inviteRequired(message):
|
|
message ?? "Für die Konto-Anlage brauchst du eine Einladung."
|
|
case let .inviteInvalid(message):
|
|
message ?? "Diese Einladung ist ungültig."
|
|
case .inviteCheckUnavailable:
|
|
"Einladungen können gerade nicht geprüft werden. Bitte später erneut."
|
|
case .unauthorized:
|
|
"Nicht autorisiert."
|
|
case .notFound:
|
|
"Nicht gefunden."
|
|
case .serviceUnavailable:
|
|
"Server temporär nicht erreichbar. Bitte später erneut versuchen."
|
|
case .serverInternal:
|
|
"Server-Fehler. Bitte später erneut versuchen."
|
|
case let .serverError(status, code, message):
|
|
"Server-Fehler (\(status))"
|
|
+ (code.map { " — \($0)" } ?? "")
|
|
+ (message.map { ": \($0)" } ?? "")
|
|
}
|
|
}
|
|
|
|
/// `true` wenn dieser Fehler bedeutet, dass die gespeicherten
|
|
/// Tokens nicht mehr gültig sind und die App den Nutzer ausloggen
|
|
/// muss. `false` für *transiente* Fehler (Server-Downtime, Netzwerk-
|
|
/// Fehler, Rate-Limiting), bei denen die Session erhalten bleiben
|
|
/// soll — die App sollte den Versuch nur wiederholen.
|
|
///
|
|
/// Genutzt von ``AuthClient/refreshAccessToken()`` um zu entscheiden,
|
|
/// ob der Keychain gewiped werden muss. Apps können denselben
|
|
/// Test auf Fehler aus ``AuthenticatedTransport`` anwenden, um
|
|
/// zwischen "neuer Login nötig" und "später nochmal probieren" zu
|
|
/// unterscheiden.
|
|
public var invalidatesSession: Bool {
|
|
switch self {
|
|
case .invalidCredentials,
|
|
.unauthorized,
|
|
.tokenExpired,
|
|
.tokenInvalid,
|
|
.emailNotVerified:
|
|
true
|
|
case .notSignedIn,
|
|
.encoding,
|
|
.keychain,
|
|
.decoding,
|
|
.networkFailure,
|
|
.emailAlreadyRegistered,
|
|
.weakPassword,
|
|
.accountLocked,
|
|
.signupLimitReached,
|
|
.rateLimited,
|
|
.twoFactorRequired,
|
|
.twoFactorFailed,
|
|
.passkeyNotEnabled,
|
|
.passkeyCancelled,
|
|
.passkeyVerificationFailed,
|
|
.validation,
|
|
.inviteRequired,
|
|
.inviteInvalid,
|
|
.inviteCheckUnavailable,
|
|
.notFound,
|
|
.serviceUnavailable,
|
|
.serverInternal,
|
|
.serverError:
|
|
false
|
|
}
|
|
}
|
|
|
|
/// Klassifiziert eine `mana-auth`-Fehler-Antwort. `data` ist der
|
|
/// Response-Body, `status` der HTTP-Status, `retryAfterHeader` der
|
|
/// `Retry-After`-Header-Wert in Sekunden (falls vorhanden).
|
|
///
|
|
/// Mapping zu `AuthErrorCode` in
|
|
/// `mana/services/mana-auth/src/lib/auth-errors.ts`. Unbekannte Codes
|
|
/// fallen auf ``serverError(status:code:message:)`` zurück.
|
|
public static func classify(
|
|
status: Int,
|
|
data: Data,
|
|
retryAfterHeader: TimeInterval? = nil
|
|
) -> AuthError {
|
|
let body = try? JSONDecoder().decode(ServerErrorBody.self, from: data)
|
|
let message = body?.message
|
|
let retryAfter = body?.retryAfterSec ?? retryAfterHeader
|
|
|
|
switch body?.error {
|
|
case "INVALID_CREDENTIALS":
|
|
return .invalidCredentials
|
|
case "EMAIL_NOT_VERIFIED":
|
|
return .emailNotVerified
|
|
case "EMAIL_ALREADY_REGISTERED":
|
|
return .emailAlreadyRegistered
|
|
case "WEAK_PASSWORD":
|
|
return .weakPassword(message: message)
|
|
case "ACCOUNT_LOCKED":
|
|
return .accountLocked(retryAfter: retryAfter)
|
|
case "SIGNUP_LIMIT_REACHED":
|
|
return .signupLimitReached
|
|
case "RATE_LIMITED":
|
|
return .rateLimited(retryAfter: retryAfter)
|
|
case "TOKEN_EXPIRED":
|
|
return .tokenExpired
|
|
case "TOKEN_INVALID":
|
|
return .tokenInvalid
|
|
case "TWO_FACTOR_REQUIRED":
|
|
return .twoFactorRequired
|
|
case "TWO_FACTOR_FAILED":
|
|
return .twoFactorFailed
|
|
case "PASSKEY_NOT_ENABLED":
|
|
return .passkeyNotEnabled
|
|
case "PASSKEY_CANCELLED":
|
|
return .passkeyCancelled
|
|
case "PASSKEY_VERIFICATION_FAILED":
|
|
return .passkeyVerificationFailed
|
|
case "VALIDATION":
|
|
return .validation(message: message)
|
|
case "INVITE_REQUIRED":
|
|
return .inviteRequired(message: message)
|
|
case "INVITE_INVALID":
|
|
return .inviteInvalid(message: message)
|
|
case "INVITE_CHECK_UNAVAILABLE":
|
|
return .inviteCheckUnavailable
|
|
case "UNAUTHORIZED":
|
|
return .unauthorized
|
|
case "NOT_FOUND":
|
|
return .notFound
|
|
case "SERVICE_UNAVAILABLE":
|
|
return .serviceUnavailable
|
|
case "INTERNAL":
|
|
return .serverInternal
|
|
default:
|
|
// Status-Heuristik wenn kein Code geliefert wurde.
|
|
switch status {
|
|
case 401: return .invalidCredentials
|
|
case 403: return .emailNotVerified
|
|
case 404: return .notFound
|
|
case 429: return .rateLimited(retryAfter: retryAfter)
|
|
case 503: return .serviceUnavailable
|
|
default: return .serverError(status: status, code: body?.error, message: message)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Wire-Format der `mana-auth`-Fehler-Antwort. Spiegelt
|
|
/// `AuthErrorResponseBody` aus `lib/auth-errors.ts`.
|
|
struct ServerErrorBody: Decodable, Sendable {
|
|
let error: String?
|
|
let message: String?
|
|
let status: Int?
|
|
let retryAfterSec: TimeInterval?
|
|
}
|