Cookie’ler

use std::sync::Arc;
use lilyrs::http_api::{
    controller, Controller, ControllerInitError, ControllerTrait, CookieSameSite,
    Extensions, HttpApiError, PassthroughResponseContext, PassthroughResponseError,
    RequestCookies, ResponseCookie,
};
use serde::Serialize;

#[derive(Serialize)]
struct Preference { theme: String }

#[derive(Controller)]
#[base_path("/preferences")]
struct PreferenceController;

#[lilyrs::http_api::async_trait::async_trait]
impl ControllerTrait for PreferenceController {
    async fn new(_: Arc<Extensions>) -> Result<Self, ControllerInitError> { Ok(Self) }
}

#[controller]
impl PreferenceController {
    #[get("/theme")]
    async fn read(&self, cookies: RequestCookies) -> Result<Preference, HttpApiError> {
        let theme = cookies.get("theme")
            .map_err(|_| HttpApiError::BadRequest("cookie is invalid".into()))?
            .map(str::to_owned).unwrap_or_else(|| "light".into());
        Ok(Preference { theme })
    }

    #[put("/theme")]
    async fn set(&self, mut response: PassthroughResponseContext<'_>)
        -> Result<Preference, HttpApiError>
    {
        let cookie = ResponseCookie::new("theme", "dark")
            .map_err(PassthroughResponseError::from)?
            .http_only(true).secure(true).same_site(CookieSameSite::Lax)
            .path("/").map_err(PassthroughResponseError::from)?;
        response.set_cookie(&cookie)?;
        Ok(Preference { theme: "dark".into() })
    }
}

let key_ring = CookieKeyRing::new(primary_secret)?
    .with_previous(previous_secret)?;
let verified = cookies.private(&key_ring).get("session")?;
response.set_private_cookie(&cookie, &key_ring)?;