Axum Extra

https://docs.rs/axum-extra/latest/
Admin
Axum Extra provides additional utilities, extractors, middleware, and response types to extend the...
Tokens:464,849
Snippets:2,383
Trust Score:9.7
Update:1 day ago
Show doc for...
Tokens:
Raw
### Range response example using FileStream::into_range_response

Source: https://docs.rs/axum-extra/latest/axum_extra/response/file_stream/struct.FileStream.html

Shows how to open a file, seek to a start offset, create a ReaderStream, and return a range response with FileStream::into_range_response. The example returns a Result with a tuple error type (StatusCode, String) and uses tokio's async file I/O.

```rust
use axum::{
    http::StatusCode,
    response::IntoResponse,
    routing::get,
    Router,
};
use axum_extra::response::file_stream::FileStream;
use tokio::fs::File;
use tokio::io::AsyncSeekExt;
use tokio_util::io::ReaderStream;

async fn range_response() -> Result<impl IntoResponse, (StatusCode, String)> {
    let mut file = File::open("test.txt")
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))?;
    let mut file_size = file
        .metadata()
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("Get file size: {e}")))?
        .len();

    file.seek(std::io::SeekFrom::Start(10))
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("File seek error: {e}")))?;
    let stream = ReaderStream::new(file);

    Ok(FileStream::new(stream).into_range_response(10, file_size - 1, file_size))
}

let app = Router::new().route("/file-stream", get(range_response));
```

--------------------------------

### MultipartForm::with_parts example

Source: https://docs.rs/axum-extra/latest/axum_extra/response/multiple/struct.MultipartForm.html

Example of initializing a MultipartForm with a vector of parts using the with_parts method. Requires the 'multipart' feature.

```rust
use axum_extra::response::multiple::{MultipartForm, Part};

let parts: Vec<Part> = vec![Part::text("foo".to_string(), "abc"), Part::text("bar".to_string(), "def")];
let form = MultipartForm::with_parts(parts);
```

--------------------------------

### as_ref example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/struct.OptionalQuery.html

Demonstrates using as_ref to convert Option<String> to Option<&String> and then map to get length without moving the String. The original text remains usable after the operation.

```rust
let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {text:?}");
```

--------------------------------

### Range response example: stream a file with a byte range

Source: https://docs.rs/axum-extra/latest/src/axum_extra/response/file_stream.rs.html

Shows how to create a FileStream that returns a partial content response for a byte range. It opens 'test.txt', gets its size, seeks to byte 10, and creates a range response from byte 10 to the end. The example is used in a route handler for '/file-stream'.

```rust
use axum::{
    http::StatusCode,
    response::IntoResponse,
    routing::get,
    Router,
};
use axum_extra::response::file_stream::FileStream;
use tokio::fs::File;
use tokio::io::AsyncSeekExt;
use tokio_util::io::ReaderStream;

async fn range_response() -> Result<impl IntoResponse, (StatusCode, String)> {
    let mut file = File::open("test.txt")
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))?;
    let mut file_size = file
        .metadata()
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("Get file size: {e}")))?
        .len();

    file.seek(std::io::SeekFrom::Start(10))
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("File seek error: {e}")))?;
    let stream = ReaderStream::new(file);

    Ok(FileStream::new(stream).into_range_response(10, file_size - 1, file_size))
}

let app = Router::new().route("/file-stream", get(range_response));
# let _: Router = app;
```

--------------------------------

### set_path example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Sets the path of a cookie. The example creates a cookie, checks path is None, sets it to "/", and verifies it.

```rust
use cookie::Cookie;

let mut c = Cookie::new("name", "value");
assert_eq!(c.path(), None);

c.set_path("/");
assert_eq!(c.path(), Some("/"));
```

--------------------------------

### set_domain example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Sets the domain of a cookie. The example creates a cookie, checks domain is None, sets it to "rust-lang.org", and verifies it.

```rust
use cookie::Cookie;

let mut c = Cookie::new("name", "value");
assert_eq!(c.domain(), None);

c.set_domain("rust-lang.org");
assert_eq!(c.domain(), Some("rust-lang.org"));
```

--------------------------------

### unset_domain example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Unsets the domain of a cookie. The example sets a domain, then unsets it and verifies it returns to None.

```rust
use cookie::Cookie;

let mut c = Cookie::new("name", "value");
assert_eq!(c.domain(), None);

c.set_domain("rust-lang.org");
assert_eq!(c.domain(), Some("rust-lang.org"));

c.unset_domain();
assert_eq!(c.domain(), None);
```

--------------------------------

### unset_path example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Unsets the path of a cookie. The example sets a path, then unsets it and verifies it returns to None.

```rust
use cookie::Cookie;

let mut c = Cookie::new("name", "value");
assert_eq!(c.path(), None);

c.set_path("/");
assert_eq!(c.path(), Some("/"));

c.unset_path();
assert_eq!(c.path(), None);
```

--------------------------------

### try_range_response example

Source: https://docs.rs/axum-extra/latest/axum_extra/response/file_stream/struct.FileStream.html

Streams a file range using FileStream::try_range_response. Takes a file path, start, and end positions. If end is 0, it is treated as file_size - 1. Returns Range Not Satisfiable if start > file_size or start > end. The example maps errors to a 404 status.

```rust
use axum::{
    http::StatusCode,
    response::IntoResponse,
    Router,
    routing::get
};
use std::path::Path;
use axum_extra::response::file_stream::FileStream;
use tokio::fs::File;
use tokio_util::io::ReaderStream;
use tokio::io::AsyncSeekExt;

async fn range_stream() -> impl IntoResponse {
    let range_start = 0;
    let range_end = 1024;

    FileStream::<ReaderStream<File>>::try_range_response("CHANGELOG.md", range_start, range_end).await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))
}

let app = Router::new().route("/file-stream", get(range_stream));
```

--------------------------------

### Example: serving a file stream with FileStream

Source: https://docs.rs/axum-extra/latest/axum_extra/response/file_stream/struct.FileStream.html

Shows how to open a file, create a ReaderStream, wrap it in FileStream with a file name, and return it as a response in an axum handler. Includes error handling for file not found and sets up a route.

```rust
use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    routing::get,
    Router,
};
use axum_extra::response::file_stream::FileStream;
use tokio::fs::File;
use tokio_util::io::ReaderStream;

async fn file_stream() -> Result<Response, (StatusCode, String)> {
    let file = File::open("test.txt")
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))?;

    let stream = ReaderStream::new(file);
    let file_stream_resp = FileStream::new(stream).file_name("test.txt");

    Ok(file_stream_resp.into_response())
}

let app = Router::new().route("/file-stream", get(file_stream));
```

--------------------------------

### Example: Creating a Resource with CRUD routes

Source: https://docs.rs/axum-extra/latest/axum_extra/routing/struct.Resource.html

Shows how to use Resource::named to define conventional CRUD routes for 'users', including index, create, new, show, edit, update, and destroy, then merge into a Router.

```rust
use axum::{Router, routing::get, extract::Path};
use axum_extra::routing::{RouterExt, Resource};

let users = Resource::named("users")
    // Define a route for `GET /users`
    .index(|| async {})
    // `POST /users`
    .create(|| async {})
    // `GET /users/new`
    .new(|| async {})
    // `GET /users/{users_id}`
    .show(|Path(user_id): Path<u64>| async {})
    // `GET /users/{users_id}/edit`
    .edit(|Path(user_id): Path<u64>| async {})
    // `PUT or PATCH /users/{users_id}`
    .update(|Path(user_id): Path<u64>| async {})
    // `DELETE /users/{users_id}`
    .destroy(|Path(user_id): Path<u64>| async {});

let app = Router::new().merge(users);
```

--------------------------------

### set_expires example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Sets the expiration of a cookie. The example sets a future time, checks it is Some, then sets None to get Session expiration.

```rust
use cookie::{Cookie, Expiration};
use cookie::time::{Duration, OffsetDateTime};

let mut c = Cookie::new("name", "value");
assert_eq!(c.expires(), None);

let mut now = OffsetDateTime::now_utc();
now += Duration::weeks(52);

c.set_expires(now);
assert!(c.expires().is_some());

c.set_expires(None);
assert_eq!(c.expires(), Some(Expiration::Session));
```

--------------------------------

### as_mut example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/struct.OptionalQuery.html

Shows using as_mut to get a mutable reference to the inner value and modify it. The example changes Some(2) to Some(42) via the mutable reference.

```rust
let mut x = Some(2);
match x.as_mut() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));
```

--------------------------------

### from_path example

Source: https://docs.rs/axum-extra/latest/axum_extra/response/file_stream/struct.FileStream.html

Creates a FileStream from a file path using FileStream::from_path. The example maps errors to a 404 status and sets up a route for the file stream.

```rust
use axum::{
    http::StatusCode,
    response::IntoResponse,
    Router,
    routing::get
};
use axum_extra::response::file_stream::FileStream;

async fn file_stream() -> impl IntoResponse {
    FileStream::from_path("test.txt")
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))
}

let app = Router::new().route("/file-stream", get(file_stream));
```

--------------------------------

### expires_datetime example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Shows how to use Cookie::expires_datetime() to get the expiration date-time. The example parses a cookie string with an Expires attribute and asserts the year is 2017.

```rust
use cookie::Cookie;

let c = Cookie::parse("name=value").unwrap();
assert_eq!(c.expires_datetime(), None);

// Here, `cookie.expires()` returns `Some`.
let c = Cookie::build(("name", "value")).expires(None).build();
assert_eq!(c.expires_datetime(), None);

let expire_time = "Wed, 21 Oct 2017 07:28:00 GMT";
let cookie_str = format!("name=value; Expires={}", expire_time);
let c = Cookie::parse(cookie_str).unwrap();
assert_eq!(c.expires_datetime().map(|t| t.year()), Some(2017));
```

--------------------------------

### take example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/struct.OptionalQuery.html

Takes the value out of the option, leaving None in its place. Works for both Some and None cases.

```rust
let mut x = Some(2);
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, Some(2));

let mut x: Option<u32> = None;
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, None);
```

--------------------------------

### TypedHeader extractor example: extracting UserAgent header

Source: https://docs.rs/axum-extra/latest/src/axum_extra/typed_header.rs.html

Shows how to use TypedHeader as an extractor to get a typed header value (UserAgent) in a handler. The example is from the 'As extractor' section and is marked as no_run.

```rust
use axum::{
    routing::get,
    Router,
};
use headers::UserAgent;
use axum_extra::TypedHeader;

async fn users_teams_show(
    TypedHeader(user_agent): TypedHeader<UserAgent>,
) {
    // ...
}

let app = Router::new().route("/users/{user_id}/team/{team_id}", get(users_teams_show));
# let _: Router = app;
```

--------------------------------

### path method example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Shows how to use Cookie::path() to get the Path attribute. Returns None when not set, and Some(&str) when set, with case-insensitive parsing.

```rust
use cookie::Cookie;

let c = Cookie::parse("name=value").unwrap();
assert_eq!(c.path(), None);

let c = Cookie::parse("name=value; Path=/").unwrap();
assert_eq!(c.path(), Some("/"));

let c = Cookie::parse("name=value; path=/sub").unwrap();
assert_eq!(c.path(), Some("/sub"));
```

--------------------------------

### Get a cookie from PrivateCookieJar

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.PrivateCookieJar.html

Retrieves a cookie by name from the jar. If the cookie exists and can be decrypted, it is returned in plaintext. The example maps the cookie value to an owned String.

```rust
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());
}
```

--------------------------------

### as_slice inverse example: using first()

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/struct.OptionalQuery.html

Demonstrates the inverse of as_slice using slice::first, showing that i.as_ref() equals i.as_slice().first() for Some and None values.

```rust
for i in [Some(1234_u16), None] {
    assert_eq!(i.as_ref(), i.as_slice().first());
}
```

--------------------------------

### set_secure example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Shows how to use Cookie::set_secure() to set or unset the secure flag. The example demonstrates setting true, false, and None, and asserts the corresponding return values.

```rust
use cookie::Cookie;

let mut c = Cookie::new("name", "value");
assert_eq!(c.secure(), None);

c.set_secure(true);
assert_eq!(c.secure(), Some(true));

c.set_secure(false);
assert_eq!(c.secure(), Some(false));

c.set_secure(None);
assert_eq!(c.secure(), None);
```

--------------------------------

### value_raw example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Shows how to get the raw value of a cookie parsed from a string, with a lifetime that may outlive the cookie. Asserts that the returned value is Some("bar").

```rust
use cookie::Cookie;

let cookie_string = format!("{}={}", "foo", "bar");

// `c` will be dropped at the end of the scope, but `value` will live on
let value = {
    let c = Cookie::parse(cookie_string.as_str()).unwrap();
    c.value_raw()
};

assert_eq!(value, Some("bar"));
```

--------------------------------

### Example: Using OptionalPath to handle routes with and without path parameters

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/struct.OptionalPath.html

Shows how to use OptionalPath to extract an optional path parameter, defaulting to page 1 when absent. The handler is used for both /blog and /blog/{page} routes.

```rust
use std::num::NonZeroU32;
use axum::{
    response::IntoResponse,
    routing::get,
    Router,
};
use axum_extra::extract::OptionalPath;

async fn render_blog(OptionalPath(page): OptionalPath<NonZeroU32>) -> impl IntoResponse {
    // Convert to u32, default to page 1 if not specified
    let page = page.map_or(1, |param| param.get());
    // ...
}

let app = Router::new()
    .route("/blog", get(render_blog))
    .route("/blog/{page}", get(render_blog));
```

--------------------------------

### name_raw example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Shows how to get the raw name of a cookie parsed from a string, with a lifetime that may outlive the cookie. Asserts that the returned name is Some("foo").

```rust
use cookie::Cookie;

let cookie_string = format!("{}={}", "foo", "bar");

// `c` will be dropped at the end of the scope, but `name` will live on
let name = {
    let c = Cookie::parse(cookie_string.as_str()).unwrap();
    c.name_raw()
};

assert_eq!(name, Some("foo"));
```

--------------------------------

### Display implementation example: formatting a cookie as Set-Cookie header

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Shows how to build a cookie with a path and format it as a Set-Cookie header value using the Display trait. The output is 'foo=bar; Path=/'.

```rust
use cookie::Cookie;

let mut cookie = Cookie::build(("foo", "bar")).path("/");
assert_eq!(cookie.to_string(), "foo=bar; Path=/");
```

--------------------------------

### max_age method example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Shows how to use Cookie::max_age() to get the Max-Age attribute. Returns None when not set, and Some(Duration) when set, with whole_hours() used to check the value.

```rust
use cookie::Cookie;

let c = Cookie::parse("name=value").unwrap();
assert_eq!(c.max_age(), None);

let c = Cookie::parse("name=value; Max-Age=3600").unwrap();
assert_eq!(c.max_age().map(|age| age.whole_hours()), Some(1));
```

--------------------------------

### Basic FileStream example: stream a file as a response

Source: https://docs.rs/axum-extra/latest/src/axum_extra/response/file_stream.rs.html

Shows how to create a FileStream from a tokio File and return it as an HTTP response. It opens 'test.txt', maps errors to a 404 status, and sets the file name to 'test.txt'. The example is used in a route handler for '/file-stream'.

```rust
use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    routing::get,
    Router,
};
use axum_extra::response::file_stream::FileStream;
use tokio::fs::File;
use tokio_util::io::ReaderStream;

async fn file_stream() -> Result<Response, (StatusCode, String)> {
    let file = File::open("test.txt")
        .await
        .map_err(|e| (StatusCode::NOT_FOUND, format!("File not found: {e}")))?;

    let stream = ReaderStream::new(file);
    let file_stream_resp = FileStream::new(stream).file_name("test.txt");

    Ok(file_stream_resp.into_response())
}

let app = Router::new().route("/file-stream", get(file_stream));
# let _: Router = app;
```

--------------------------------

### as_slice example: assert_eq with Some and None

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/struct.OptionalQuery.html

Shows how as_slice returns a slice of the contained value or an empty slice for None. Used to get a single type of iterator over an Option or slice.

```rust
assert_eq!(
    [Some(1234).as_slice(), None.as_slice()],
    [&[1234][..], &[][..]],
);
```

--------------------------------

### Get a cookie from SignedCookieJar

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.SignedCookieJar.html

Retrieves a cookie by name from the jar. If the cookie exists and its authenticity and integrity can be verified, it is returned in plaintext. The example maps the cookie to its value as an Option<String>.

```rust
use axum_extra::extract::cookie::SignedCookieJar;
use axum::response::IntoResponse;

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

--------------------------------

### JsonDeserializer usage example

Source: https://docs.rs/axum-extra/latest/src/axum_extra/extract/json_deserializer.rs.html

Shows how to use JsonDeserializer in an axum handler. The handler receives a JsonDeserializer<Data<'_>>, calls deserialize() to parse the body, and returns a Response. The Data struct uses Cow and &str fields with #[serde(borrow)] to allow borrowing from the request body. The example is marked as no_run and includes a Router setup.

```rust
use axum::{
    routing::post,
    Router,
    response::{IntoResponse, Response}
};
use axum_extra::extract::JsonDeserializer;
use serde::Deserialize;
use std::borrow::Cow;
use http::StatusCode;

#[derive(Deserialize)]
struct Data<'a> {
    #[serde(borrow)]
    borrow_text: Cow<'a, str>,
    #[serde(borrow)]
    borrow_bytes: Cow<'a, [u8]>,
    borrow_dangerous: &'a str,
    not_borrowed: String,
}

async fn upload(deserializer: JsonDeserializer<Data<'_>>) -> Response {
    let data = match deserializer.deserialize() {
        Ok(data) => data,
        Err(e) => return e.into_response(),
    };

    // payload is a `Data` with borrowed data from `deserializer`,
    // which owns the request body (`Bytes`).

    StatusCode::OK.into_response()
}

let app = Router::new().route("/upload", post(upload));
# let _: Router = app;
```

--------------------------------

### OptionalQuery usage example with Router

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/struct.OptionalQuery.html

Example showing how to use OptionalQuery to parse query strings into Option<Pagination>. Empty query strings yield None, and invalid query strings cause a 400 Bad Request response.

```rust
use axum::{routing::get, Router};
use axum_extra::extract::OptionalQuery;
use serde::Deserialize;

#[derive(Deserialize)]
struct Pagination {
    page: usize,
    per_page: usize,
}

// This will parse query strings like `?page=2&per_page=30` into `Some(Pagination)` and
// empty query string into `None`
async fn list_things(OptionalQuery(pagination): OptionalQuery<Pagination>) {
    match pagination {
        Some(Pagination{ page, per_page }) => { /* return specified page */ },
        None => { /* return fist page */ }
    }
    // ...
}

let app = Router::new().route("/list_things", get(list_things));
```

--------------------------------

### Example: returning a file as an Attachment

Source: https://docs.rs/axum-extra/latest/axum_extra/response/struct.Attachment.html

Shows a handler that reads `Cargo.toml` and returns an `Attachment` with a filename and content type. If the file is not found, it returns a `404` status with an error message.

```rust
use axum::{http::StatusCode, routing::get, Router};
use axum_extra::response::Attachment;

async fn cargo_toml() -> Result<Attachment<String>, (StatusCode, String)> {
    let file_contents = tokio::fs::read_to_string("Cargo.toml")
        .await
        .map_err(|err| (StatusCode::NOT_FOUND, format!("File not found: {err}")))?;
    Ok(Attachment::new(file_contents)
        .filename("Cargo.toml")
        .content_type("text/x-toml"))
}

let app = Router::new().route("/Cargo.toml", get(cargo_toml));
let _: Router = app;
```

--------------------------------

### Example: Using TypedPath with RouterExt

Source: https://docs.rs/axum-extra/latest/axum_extra/routing/trait.TypedPath.html

This example shows how to define a typed path with #[derive(TypedPath)] and use it in a router with typed_get, typed_post, and typed_delete. It demonstrates that the TypedPath must be the first argument to the handler function.

```rust
use serde::Deserialize;
use axum::{Router, extract::Json};
use axum_extra::routing::{
    TypedPath,
    RouterExt, // for `Router::typed_*`
};

// A type safe route with `/users/{id}` as its associated path.
#[derive(TypedPath, Deserialize)]
#[typed_path("/users/{id}")]
struct UsersMember {
    id: u32,
}

// A regular handler function that takes `UsersMember` as the first argument
// and thus creates a typed connection between this handler and the `/users/{id}` path.
//
// The `TypedPath` must be the first argument to the function.
async fn users_show(
    UsersMember { id }: UsersMember,
) {
    // ...
}

let app = Router::new()
    // Add our typed route to the router.
    //
    // The path will be inferred to `/users/{id}` since `users_show`'s
    // first argument is `UsersMember` which implements `TypedPath`
    .typed_get(users_show)
    .typed_post(users_create)
    .typed_delete(users_destroy);

#[derive(TypedPath)]
#[typed_path("/users")]
struct UsersCollection;

#[derive(Deserialize)]
struct UsersCreatePayload { /* ... */ }

async fn users_create(
    _: UsersCollection,
    // Our handlers can accept other extractors.
    Json(payload): Json<UsersCreatePayload>,
) {
    // ...
}

async fn users_destroy(_: UsersCollection) { /* ... */ }
```

--------------------------------

### expires method example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.Cookie.html

Shows how to use Cookie::expires() to get the Expiration. Returns None when not set, Some(Expiration::Session) when explicitly set to None, and Some(Expiration::DateTime) when a date is provided.

```rust
use cookie::{Cookie, Expiration};

let c = Cookie::parse("name=value").unwrap();
assert_eq!(c.expires(), None);

// Here, `cookie.expires_datetime()` returns `None`.
let c = Cookie::build(("name", "value")).expires(None).build();
assert_eq!(c.expires(), Some(Expiration::Session));

let expire_time = "Wed, 21 Oct 2017 07:28:00 GMT";
let cookie_str = format!("name=value; Expires={}", expire_time);
let c = Cookie::parse(cookie_str).unwrap();
assert_eq!(c.expires().and_then(|e| e.datetime()).map(|t| t.year()), Some(2017));
```

--------------------------------

### Get a cookie from the jar

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/struct.CookieJar.html

Shows how to retrieve a cookie by name from a CookieJar, returning an Option<String> with the cookie's value. The example uses an async handler that takes a CookieJar as an argument.

```rust
use axum_extra::extract::cookie::CookieJar;
use axum::response::IntoResponse;

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

--------------------------------

### Response example: Protobuf as response

Source: https://docs.rs/axum-extra/latest/axum_extra/protobuf/struct.Protobuf.html

Shows how to return a Protobuf<User> from an Axum handler. Requires the User type to implement prost::Message. If no Content-Type header is set, the response uses Content-Type: application/octet-stream.

```rust
use axum::{
    extract::Path,
    routing::get,
    Router,
};
use axum_extra::protobuf::Protobuf;

#[derive(prost::Message)]
struct User {
    #[prost(string, tag="1")]
    username: String,
}

async fn get_user(Path(user_id) : Path<String>) -> Protobuf<User> {
    let user = find_user(user_id).await;
    Protobuf(user)
}

async fn find_user(user_id: String) -> User {
    // ...
}

let app = Router::new().route("/users/{id}", get(get_user));
```

--------------------------------

### is_lax example

Source: https://docs.rs/axum-extra/latest/axum_extra/extract/cookie/enum.SameSite.html

Shows how to use SameSite::is_lax to check if a SameSite value is Lax.

```rust
use cookie::SameSite;

let lax = SameSite::Lax;
assert!(lax.is_lax());
assert!(!lax.is_strict());
assert!(!lax.is_none());
```
Tokens:
Raw