Struct axum_extra::extract::PrivateCookieJar

pub struct PrivateCookieJar<K = Key> { /* private fields */ }

Extractor that grabs private cookies from the request and manages the jar.

All cookies will be private and encrypted with a Key. This makes it suitable for storing private data.

Note that methods like PrivateCookieJar::add, PrivateCookieJar::remove, etc updates the PrivateCookieJar and returns it. This value must be returned from the handler as part of the response for the changes to be propagated.

Example

use axum::{
    Router,
    Extension,
    routing::{post, get},
    extract::TypedHeader,
    response::{IntoResponse, Redirect},
    headers::authorization::{Authorization, Bearer},
    http::StatusCode,
};
use axum_extra::extract::cookie::{PrivateCookieJar, Cookie, Key};

async fn set_secret(
    jar: PrivateCookieJar,
) -> (PrivateCookieJar, Redirect) {
    let updated_jar = jar.add(Cookie::new("secret", "secret-data"));
    (updated_jar, Redirect::to("/get"))
}

async fn get_secret(jar: PrivateCookieJar) {
    if let Some(data) = jar.get("secret") {
        // ...
    }
}

// Generate a secure key
//
// You probably don't wanna generate a new one each time the app starts though
let key = Key::generate();

let app = Router::new()
    .route("/set", post(set_secret))
    .route("/get", get(get_secret))
    // add extension with the key so `PrivateCookieJar` can access it
    .layer(Extension(key));

Implementations

impl<K> PrivateCookieJar<K>

pub fn get(&self, name: &str) -> Option<Cookie<'static>>

Available on crate features cookie and cookie-private only.

Get a cookie from the jar.

If the cookie exists and can be decrypted then it is returned in plaintext.

Example

use axum_extra::extract::cookie::PrivateCookieJar;
use axum::response::IntoResponse;

async fn handle(jar: PrivateCookieJar) {
    let value: Option<String> = jar
        .get("foo")
        .map(|cookie| cookie.value().to_owned());
}

pub fn remove(self, cookie: Cookie<'static>) -> Self

Available on crate features cookie and cookie-private only.

Remove a cookie from the jar.

Example

use axum_extra::extract::cookie::{PrivateCookieJar, Cookie};
use axum::response::IntoResponse;

async fn handle(jar: PrivateCookieJar) -> PrivateCookieJar {
    jar.remove(Cookie::named("foo"))
}

pub fn add(self, cookie: Cookie<'static>) -> Self

Available on crate features cookie and cookie-private only.

Add a cookie to the jar.

The value will automatically be percent-encoded.

Example

use axum_extra::extract::cookie::{PrivateCookieJar, Cookie};
use axum::response::IntoResponse;

async fn handle(jar: PrivateCookieJar) -> PrivateCookieJar {
    jar.add(Cookie::new("foo", "bar"))
}

pub fn decrypt(&self, cookie: Cookie<'static>) -> Option<Cookie<'static>>

Available on crate features cookie and cookie-private only.

Authenticates and decrypts cookie, returning the plaintext version if decryption succeeds or None otherwise.

pub fn iter(&self) -> impl Iterator<Item = Cookie<'static>> + '_

Available on crate features cookie and cookie-private only.

Get an iterator over all cookies in the jar.

Only cookies with valid authenticity and integrity are yielded by the iterator.

Trait Implementations

impl<K> Debug for PrivateCookieJar<K>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B, K> FromRequest<B> for PrivateCookieJar<K> where
    B: Send,
    K: Into<Key> + Clone + Send + Sync + 'static, 

type Rejection = <Extension<K> as FromRequest<B>>::Rejection

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request<'life0, 'async_trait>(
    req: &'life0 mut RequestParts<B>
) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Perform the extraction.

impl<K> IntoResponse for PrivateCookieJar<K>

fn into_response(self) -> Response

Create a response.

impl<K> IntoResponseParts for PrivateCookieJar<K>

type Error = Infallible

The type returned in the event of an error.

fn into_response_parts(
    self,
    res: ResponseParts
) -> Result<ResponseParts, Self::Error>

Set parts of the response