97 lines
2.9 KiB
TypeScript
97 lines
2.9 KiB
TypeScript
import { cookies } from "next/headers";
|
|
import { NextResponse } from "next/server";
|
|
import { UserProfile } from "@/lib/types";
|
|
import { userService } from "@/services/user-service";
|
|
|
|
export const COOKIE_NAME = "session_token" as const;
|
|
|
|
export const COOKIE_CONFIG = {
|
|
httpOnly: true,
|
|
secure: process.env.NODE_ENV === "production",
|
|
sameSite: "lax" as const,
|
|
maxAge: 60 * 60 * 24 * 7, // 7 jours
|
|
path: "/",
|
|
} as const;
|
|
|
|
/**
|
|
* Service d'authentification côté serveur
|
|
* Implémente les méthodes qui nécessitent next/headers
|
|
*/
|
|
export class AuthService {
|
|
/**
|
|
* Récupère l'UUID utilisateur depuis le cookie côté serveur
|
|
*/
|
|
static async getUserUuidFromCookie(): Promise<string | null> {
|
|
const cookieStore = await cookies();
|
|
const userUuidCookie = cookieStore.get(COOKIE_NAME);
|
|
return userUuidCookie?.value || null;
|
|
}
|
|
|
|
/**
|
|
* Vérifie si l'utilisateur est authentifié côté serveur
|
|
*/
|
|
static async isUserAuthenticated(): Promise<boolean> {
|
|
const userUuid = await this.getUserUuidFromCookie();
|
|
return !!userUuid;
|
|
}
|
|
|
|
/**
|
|
* Vérifie l'authentification et retourne le profil utilisateur
|
|
* @throws {Error} avec status 401 si non authentifié ou 404 si utilisateur non trouvé
|
|
*/
|
|
static async requireAuthenticatedUser(): Promise<{
|
|
userUuid: string;
|
|
userProfile: UserProfile;
|
|
}> {
|
|
const userUuid = await this.getUserUuidFromCookie();
|
|
|
|
if (!userUuid) {
|
|
const error = new Error("Utilisateur non authentifié");
|
|
(error as any).status = 401;
|
|
throw error;
|
|
}
|
|
|
|
const userProfile = await userService.getUserByUuid(userUuid);
|
|
if (!userProfile) {
|
|
const error = new Error("Utilisateur introuvable");
|
|
(error as any).status = 404;
|
|
throw error;
|
|
}
|
|
|
|
return { userUuid, userProfile };
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Crée une nouvelle session pour un utilisateur et retourne la réponse avec le cookie
|
|
*/
|
|
static async createSession(userUuid: string, response: NextResponse): Promise<NextResponse> {
|
|
// Pour l'instant, on utilise l'UUID comme token de session
|
|
// Plus tard, on pourra implémenter un système de JWT ou de sessions en base
|
|
const sessionToken = userUuid;
|
|
response.cookies.set(COOKIE_NAME, sessionToken, COOKIE_CONFIG);
|
|
return response;
|
|
}
|
|
|
|
/**
|
|
* Supprime la session et retourne la réponse avec le cookie expiré
|
|
*/
|
|
static removeSession(response: NextResponse): NextResponse {
|
|
response.cookies.set(COOKIE_NAME, "", { ...COOKIE_CONFIG, maxAge: 0 });
|
|
return response;
|
|
}
|
|
|
|
/**
|
|
* Valide un token de session et retourne l'UUID utilisateur
|
|
*/
|
|
static async validateSession(sessionToken: string): Promise<string | null> {
|
|
// Pour l'instant, on considère que le token est valide s'il correspond à un UUID
|
|
// Plus tard, on pourra ajouter une validation plus robuste
|
|
if (sessionToken && sessionToken.length > 0) {
|
|
return sessionToken;
|
|
}
|
|
return null;
|
|
}
|
|
}
|