);
5 | | ^^^^^^^^^
6 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/tuple.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequest;
2 |
3 | #[derive(FromRequest)]
4 | struct Extractor(axum::http::HeaderMap, String);
5 |
6 | fn assert_from_request()
7 | where
8 | Extractor: axum::extract::FromRequest<()>,
9 | {
10 | }
11 |
12 | fn main() {}
13 |
--------------------------------------------------------------------------------
/examples/templates-minijinja/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-templates-minijinja"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | minijinja = "2.3.1"
10 | tokio = { version = "1.0", features = ["full"] }
11 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/unit.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequest;
2 |
3 | #[derive(FromRequest)]
4 | struct Extractor;
5 |
6 | fn assert_from_request()
7 | where
8 | Extractor: axum::extract::FromRequest<(), Rejection = std::convert::Infallible>,
9 | {
10 | }
11 |
12 | fn main() {}
13 |
--------------------------------------------------------------------------------
/examples/cors/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-cors"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tower-http = { version = "0.6.1", features = ["cors"] }
11 |
--------------------------------------------------------------------------------
/examples/routes-and-handlers-close-together/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-routes-and-handlers-close-together"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | tokio = { version = "1.0", features = ["full"] }
10 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/via_on_container_and_field.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequest;
2 |
3 | #[derive(FromRequest)]
4 | #[from_request(via(axum::Extension))]
5 | struct Extractor(#[from_request(via(axum::Extension))] State);
6 |
7 | #[derive(Clone)]
8 | struct State;
9 |
10 | fn main() {}
11 |
--------------------------------------------------------------------------------
/examples/websockets-http2/assets/index.html:
--------------------------------------------------------------------------------
1 | Open this page in two windows and try sending some messages!
2 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/pass/state_and_body.rs:
--------------------------------------------------------------------------------
1 | use axum::{extract::Request, extract::State};
2 | use axum_macros::debug_handler;
3 |
4 | #[debug_handler(state = AppState)]
5 | async fn handler(_: State, _: Request) {}
6 |
7 | #[derive(Clone)]
8 | struct AppState;
9 |
10 | fn main() {}
11 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/enum_from_request_ident_in_variant.stderr:
--------------------------------------------------------------------------------
1 | error: `#[from_request(via(...))]` cannot be used inside variants
2 | --> tests/from_request/fail/enum_from_request_ident_in_variant.rs:7:24
3 | |
4 | 7 | #[from_request(via(axum::Extension))]
5 | | ^^^
6 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/empty_named.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequest;
2 |
3 | #[derive(FromRequest)]
4 | struct Extractor {}
5 |
6 | fn assert_from_request()
7 | where
8 | Extractor: axum::extract::FromRequest<(), Rejection = std::convert::Infallible>,
9 | {
10 | }
11 |
12 | fn main() {}
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/empty_tuple.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequest;
2 |
3 | #[derive(FromRequest)]
4 | struct Extractor();
5 |
6 | fn assert_from_request()
7 | where
8 | Extractor: axum::extract::FromRequest<(), Rejection = std::convert::Infallible>,
9 | {
10 | }
11 |
12 | fn main() {}
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/double_via_attr.stderr:
--------------------------------------------------------------------------------
1 | error: `via` specified more than once
2 | --> tests/from_request/fail/double_via_attr.rs:4:55
3 | |
4 | 4 | struct Extractor(#[from_request(via(axum::Extension), via(axum::Extension))] State);
5 | | ^^^
6 |
--------------------------------------------------------------------------------
/examples/templates-minijinja/templates/content.jinja:
--------------------------------------------------------------------------------
1 | {% extends "layout" %}
2 | {% block title %}{{ super() }} | {{ title }} {% endblock %}
3 | {% block body %}
4 | {{ title }}
5 | {% for data_entry in entries %}
6 |
9 | {% endfor %}
10 | {% endblock %}
11 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/generic_without_via.rs:
--------------------------------------------------------------------------------
1 | use axum::{routing::get, Router};
2 | use axum_macros::FromRequest;
3 |
4 | #[derive(FromRequest, Clone)]
5 | struct Extractor(T);
6 |
7 | async fn foo(_: Extractor<()>) {}
8 |
9 | fn main() {
10 | _ = Router::<()>::new().route("/", get(foo));
11 | }
12 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/unit_parts.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequestParts;
2 |
3 | #[derive(FromRequestParts)]
4 | struct Extractor;
5 |
6 | fn assert_from_request()
7 | where
8 | Extractor: axum::extract::FromRequestParts<(), Rejection = std::convert::Infallible>,
9 | {
10 | }
11 |
12 | fn main() {}
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/tuple_parts.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequestParts;
2 |
3 | #[derive(FromRequestParts)]
4 | struct Extractor(axum::http::HeaderMap, axum::http::Method);
5 |
6 | fn assert_from_request()
7 | where
8 | Extractor: axum::extract::FromRequestParts<()>,
9 | {
10 | }
11 |
12 | fn main() {}
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/empty_named_parts.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequestParts;
2 |
3 | #[derive(FromRequestParts)]
4 | struct Extractor {}
5 |
6 | fn assert_from_request()
7 | where
8 | Extractor: axum::extract::FromRequestParts<(), Rejection = std::convert::Infallible>,
9 | {
10 | }
11 |
12 | fn main() {}
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/empty_tuple_parts.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequestParts;
2 |
3 | #[derive(FromRequestParts)]
4 | struct Extractor();
5 |
6 | fn assert_from_request()
7 | where
8 | Extractor: axum::extract::FromRequestParts<(), Rejection = std::convert::Infallible>,
9 | {
10 | }
11 |
12 | fn main() {}
13 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/config.yml:
--------------------------------------------------------------------------------
1 | contact_links:
2 | - name: 🙏 Q&A (GitHub Discussions)
3 | url: https://github.com/tokio-rs/axum/discussions/categories/q-a
4 | about: Q&A all around axum usage
5 | - name: 💬 Tokio Discord
6 | url: https://discord.gg/tokio
7 | about: Community chat for Tokio (axum channel is under libs)
8 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/enum_from_request_ident_in_variant.rs:
--------------------------------------------------------------------------------
1 | use axum_macros::FromRequest;
2 |
3 | #[derive(FromRequest, Clone)]
4 | #[from_request(via(axum::Extension))]
5 | enum Extractor {
6 | Foo {
7 | #[from_request(via(axum::Extension))]
8 | foo: (),
9 | },
10 | }
11 |
12 | fn main() {}
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_middleware/fail/takes_next_twice.rs:
--------------------------------------------------------------------------------
1 | use axum::{debug_middleware, extract::Request, middleware::Next, response::Response};
2 |
3 | #[debug_middleware]
4 | async fn my_middleware(request: Request, next: Next, next2: Next) -> Response {
5 | let _ = next2;
6 | next.run(request).await
7 | }
8 |
9 | fn main() {}
10 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_middleware/fail/doesnt_take_next.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | debug_middleware,
3 | extract::Request,
4 | response::{IntoResponse, Response},
5 | };
6 |
7 | #[debug_middleware]
8 | async fn my_middleware(request: Request) -> Response {
9 | let _ = request;
10 | ().into_response()
11 | }
12 |
13 | fn main() {}
14 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/enum_via.rs:
--------------------------------------------------------------------------------
1 | use axum::{routing::get, Extension, Router};
2 | use axum_macros::FromRequest;
3 |
4 | #[derive(FromRequest, Clone)]
5 | #[from_request(via(Extension))]
6 | enum Extractor {}
7 |
8 | async fn foo(_: Extractor) {}
9 |
10 | fn main() {
11 | _ = Router::<()>::new().route("/", get(foo));
12 | }
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/typed_path/pass/wildcards.rs:
--------------------------------------------------------------------------------
1 | use axum_extra::routing::{RouterExt, TypedPath};
2 | use serde::Deserialize;
3 |
4 | #[derive(TypedPath, Deserialize)]
5 | #[typed_path("/{*rest}")]
6 | struct MyPath {
7 | rest: String,
8 | }
9 |
10 | fn main() {
11 | _ = axum::Router::<()>::new().typed_get(|_: MyPath| async {});
12 | }
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/parts_extracting_body.rs:
--------------------------------------------------------------------------------
1 | use axum::{extract::FromRequestParts, response::Response};
2 |
3 | #[derive(FromRequestParts)]
4 | struct Extractor {
5 | body: String,
6 | }
7 |
8 | fn assert_from_request()
9 | where
10 | Extractor: FromRequestParts<(), Rejection = Response>,
11 | {
12 | }
13 |
14 | fn main() {}
15 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/enum_no_via.stderr:
--------------------------------------------------------------------------------
1 | error: missing `#[from_request(via(...))]`
2 | --> tests/from_request/fail/enum_no_via.rs:3:10
3 | |
4 | 3 | #[derive(FromRequest, Clone)]
5 | | ^^^^^^^^^^^
6 | |
7 | = note: this error originates in the derive macro `FromRequest` (in Nightly builds, run with -Z macro-backtrace for more info)
8 |
--------------------------------------------------------------------------------
/examples/global-404-handler/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-global-404-handler"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tracing = "0.1"
11 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
12 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/enum_via_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::{routing::get, Extension, Router};
2 | use axum_macros::FromRequestParts;
3 |
4 | #[derive(FromRequestParts, Clone)]
5 | #[from_request(via(Extension))]
6 | enum Extractor {}
7 |
8 | async fn foo(_: Extractor) {}
9 |
10 | fn main() {
11 | _ = Router::<()>::new().route("/", get(foo));
12 | }
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/generic_without_via_rejection.rs:
--------------------------------------------------------------------------------
1 | use axum::{routing::get, Router};
2 | use axum_macros::FromRequest;
3 |
4 | #[derive(FromRequest, Clone)]
5 | #[from_request(rejection(Foo))]
6 | struct Extractor(T);
7 |
8 | async fn foo(_: Extractor<()>) {}
9 |
10 | fn main() {
11 | _ = Router::<()>::new().route("/", get(foo));
12 | }
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/via_on_container_and_field.stderr:
--------------------------------------------------------------------------------
1 | error: `#[from_request(via(...))]` on a field cannot be used together with `#[from_request(...)]` on the container
2 | --> tests/from_request/fail/via_on_container_and_field.rs:5:33
3 | |
4 | 5 | struct Extractor(#[from_request(via(axum::Extension))] State);
5 | | ^^^
6 |
--------------------------------------------------------------------------------
/examples/tokio-redis/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-tokio-redis"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | bb8-redis = "0.24"
10 | tokio = { version = "1.0", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/tuple_via.rs:
--------------------------------------------------------------------------------
1 | use axum::Extension;
2 | use axum_macros::FromRequest;
3 |
4 | #[derive(FromRequest)]
5 | struct Extractor(#[from_request(via(Extension))] State);
6 |
7 | #[derive(Clone)]
8 | struct State;
9 |
10 | fn assert_from_request()
11 | where
12 | Extractor: axum::extract::FromRequest<()>,
13 | {
14 | }
15 |
16 | fn main() {}
17 |
--------------------------------------------------------------------------------
/examples/reverse-proxy/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-reverse-proxy"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | hyper = { version = "1.0.0", features = ["full"] }
10 | hyper-util = { version = "0.1.1", features = ["client-legacy"] }
11 | tokio = { version = "1", features = ["full"] }
12 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/multiple_request_consumers.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | body::Bytes,
3 | http::{Method, Uri},
4 | Json,
5 | };
6 | use axum_macros::debug_handler;
7 |
8 | #[debug_handler]
9 | async fn one(_: Json<()>, _: String, _: Uri) {}
10 |
11 | #[debug_handler]
12 | async fn two(_: Json<()>, _: Method, _: Bytes, _: Uri, _: String) {}
13 |
14 | fn main() {}
15 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/not_enum_or_struct.stderr:
--------------------------------------------------------------------------------
1 | error: expected `struct` or `enum`
2 | --> tests/from_request/fail/not_enum_or_struct.rs:4:1
3 | |
4 | 4 | union Extractor {}
5 | | ^^^^^^^^^^^^^^^^^^
6 |
7 | error: unions cannot have zero fields
8 | --> tests/from_request/fail/not_enum_or_struct.rs:4:1
9 | |
10 | 4 | union Extractor {}
11 | | ^^^^^^^^^^^^^^^^^^
12 |
--------------------------------------------------------------------------------
/axum-macros/tests/typed_path/pass/unit_struct.rs:
--------------------------------------------------------------------------------
1 | use axum_extra::routing::TypedPath;
2 |
3 | #[derive(TypedPath)]
4 | #[typed_path("/users")]
5 | struct MyPath;
6 |
7 | fn main() {
8 | _ = axum::Router::<()>::new().route("/", axum::routing::get(|_: MyPath| async {}));
9 |
10 | assert_eq!(MyPath::PATH, "/users");
11 | assert_eq!(format!("{}", MyPath), "/users");
12 | }
13 |
--------------------------------------------------------------------------------
/examples/readme/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-readme"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | serde = { version = "1.0", features = ["derive"] }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/tuple_via_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::Extension;
2 | use axum_macros::FromRequestParts;
3 |
4 | #[derive(FromRequestParts)]
5 | struct Extractor(#[from_request(via(Extension))] State);
6 |
7 | #[derive(Clone)]
8 | struct State;
9 |
10 | fn assert_from_request()
11 | where
12 | Extractor: axum::extract::FromRequestParts<()>,
13 | {
14 | }
15 |
16 | fn main() {}
17 |
--------------------------------------------------------------------------------
/examples/print-request-response/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-print-request-response"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | http-body-util = "0.1.0"
10 | tokio = { version = "1.0", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
--------------------------------------------------------------------------------
/examples/anyhow-error-response/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-anyhow-error-response"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | anyhow = "1.0"
9 | axum = { path = "../../axum" }
10 | tokio = { version = "1.0", features = ["full"] }
11 |
12 | [dev-dependencies]
13 | http-body-util = "0.1.0"
14 | tower = { version = "0.5.2", features = ["util"] }
15 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/pass/returns_self.rs:
--------------------------------------------------------------------------------
1 | use axum::response::{IntoResponse, Response};
2 | use axum_macros::debug_handler;
3 |
4 | struct A;
5 |
6 | impl A {
7 | #[debug_handler]
8 | async fn handler() -> Self {
9 | A
10 | }
11 | }
12 |
13 | impl IntoResponse for A {
14 | fn into_response(self) -> Response {
15 | todo!()
16 | }
17 | }
18 |
19 | fn main() {}
20 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_middleware/fail/doesnt_take_next.stderr:
--------------------------------------------------------------------------------
1 | error: Middleware functions must take `axum::middleware::Next` as the last argument
2 | --> tests/debug_middleware/fail/doesnt_take_next.rs:7:1
3 | |
4 | 7 | #[debug_middleware]
5 | | ^^^^^^^^^^^^^^^^^^^
6 | |
7 | = note: this error originates in the attribute macro `debug_middleware` (in Nightly builds, run with -Z macro-backtrace for more info)
8 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_middleware/fail/takes_next_twice.stderr:
--------------------------------------------------------------------------------
1 | error: Middleware functions can only take one argument of type `axum::middleware::Next`
2 | --> tests/debug_middleware/fail/takes_next_twice.rs:3:1
3 | |
4 | 3 | #[debug_middleware]
5 | | ^^^^^^^^^^^^^^^^^^^
6 | |
7 | = note: this error originates in the attribute macro `debug_middleware` (in Nightly builds, run with -Z macro-backtrace for more info)
8 |
--------------------------------------------------------------------------------
/examples/consume-body-in-extractor-or-middleware/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-consume-body-in-extractor-or-middleware"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | http-body-util = "0.1.0"
10 | tokio = { version = "1.0", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
--------------------------------------------------------------------------------
/examples/customize-path-rejection/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-customize-path-rejection"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | serde = { version = "1.0", features = ["derive"] }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
--------------------------------------------------------------------------------
/examples/tokio-postgres/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-tokio-postgres"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | bb8 = "0.9.0"
10 | bb8-postgres = "0.9.0"
11 | tokio = { version = "1.0", features = ["full"] }
12 | tokio-postgres = "0.7.2"
13 | tracing = "0.1"
14 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
15 |
--------------------------------------------------------------------------------
/examples/graceful-shutdown/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-graceful-shutdown"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["tracing"] }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tower-http = { version = "0.6.1", features = ["timeout", "trace"] }
11 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
12 |
--------------------------------------------------------------------------------
/examples/query-params-with-empty-strings/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-query-params-with-empty-strings"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | http-body-util = "0.1.0"
10 | serde = { version = "1.0", features = ["derive"] }
11 | tokio = { version = "1.0", features = ["full"] }
12 | tower = { version = "0.5.2", features = ["util"] }
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/tuple_same_type_twice.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::Query;
2 | use axum_macros::FromRequest;
3 | use serde::Deserialize;
4 |
5 | #[derive(FromRequest)]
6 | struct Extractor(Query, axum::extract::Json);
7 |
8 | #[derive(Deserialize)]
9 | struct Payload {}
10 |
11 | fn assert_from_request()
12 | where
13 | Extractor: axum::extract::FromRequest<()>,
14 | {
15 | }
16 |
17 | fn main() {}
18 |
--------------------------------------------------------------------------------
/examples/handle-head-request/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-handle-head-request"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | tokio = { version = "1.0", features = ["full"] }
10 |
11 | [dev-dependencies]
12 | http-body-util = "0.1.0"
13 | hyper = { version = "1.0.0", features = ["full"] }
14 | tower = { version = "0.5.2", features = ["util"] }
15 |
--------------------------------------------------------------------------------
/examples/request-id/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-request-id"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tower = "0.5.2"
11 | tower-http = { version = "0.6", features = ["request-id", "trace"] }
12 | tracing = "0.1"
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 |
--------------------------------------------------------------------------------
/examples/testing-websockets/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-testing-websockets"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["ws"] }
9 | futures-channel = "0.3"
10 | futures-util = { version = "0.3", default-features = false, features = ["sink", "std"] }
11 | tokio = { version = "1.0", features = ["full"] }
12 | tokio-tungstenite = "0.28"
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/too_many_extractors.stderr:
--------------------------------------------------------------------------------
1 | error: Handlers cannot take more than 16 arguments. Use `(a, b): (ExtractorA, ExtractorA)` to further nest extractors
2 | --> tests/debug_handler/fail/too_many_extractors.rs:6:5
3 | |
4 | 6 | / _e1: Uri,
5 | 7 | | _e2: Uri,
6 | 8 | | _e3: Uri,
7 | 9 | | _e4: Uri,
8 | ... |
9 | 21 | | _e16: Uri,
10 | 22 | | _e17: Uri,
11 | | |______________^
12 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_infer.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::State;
2 | use axum_macros::FromRequest;
3 |
4 | #[derive(FromRequest)]
5 | struct Extractor {
6 | inner_state: State,
7 | }
8 |
9 | #[derive(Clone)]
10 | struct AppState {}
11 |
12 | fn assert_from_request()
13 | where
14 | Extractor: axum::extract::FromRequest,
15 | {
16 | }
17 |
18 | fn main() {}
19 |
--------------------------------------------------------------------------------
/axum/src/docs/handlers_intro.md:
--------------------------------------------------------------------------------
1 | In axum a "handler" is an async function that accepts zero or more
2 | ["extractors"](crate::extract) as arguments and returns something that
3 | can be converted [into a response](crate::response).
4 |
5 | Handlers are where your application logic lives and axum applications are built
6 | by routing between handlers.
7 |
8 | [`debug_handler`]: https://docs.rs/axum-macros/latest/axum_macros/attr.debug_handler.html
9 |
--------------------------------------------------------------------------------
/examples/chat/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-chat"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["ws"] }
9 | futures-util = { version = "0.3", default-features = false, features = ["sink", "std"] }
10 | tokio = { version = "1", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
--------------------------------------------------------------------------------
/examples/parse-body-based-on-content-type/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-parse-body-based-on-content-type"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | serde = { version = "1.0", features = ["derive"] }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
--------------------------------------------------------------------------------
/examples/sqlx-postgres/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-sqlx-postgres"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tracing = "0.1"
11 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
12 |
13 | sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "any", "postgres"] }
14 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/state_infer_multiple_different_types.stderr:
--------------------------------------------------------------------------------
1 | error: can't infer state type, please add `#[from_request(state = MyStateType)]` attribute
2 | --> tests/from_request/fail/state_infer_multiple_different_types.rs:4:10
3 | |
4 | 4 | #[derive(FromRequest)]
5 | | ^^^^^^^^^^^
6 | |
7 | = note: this error originates in the derive macro `FromRequest` (in Nightly builds, run with -Z macro-backtrace for more info)
8 |
--------------------------------------------------------------------------------
/examples/multipart-form/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-multipart-form"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["multipart"] }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tower-http = { version = "0.6.1", features = ["limit", "trace"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
--------------------------------------------------------------------------------
/examples/serve-with-hyper/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-serve-with-hyper"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | hyper = { version = "1.0", features = [] }
10 | hyper-util = { version = "0.1", features = ["tokio", "server-auto", "http1"] }
11 | tokio = { version = "1.0", features = ["full"] }
12 | tower = { version = "0.5.2", features = ["util"] }
13 |
--------------------------------------------------------------------------------
/examples/tracing-aka-logging/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-tracing-aka-logging"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["tracing"] }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tower-http = { version = "0.6.1", features = ["trace"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
--------------------------------------------------------------------------------
/examples/tls-rustls/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-tls-rustls"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | axum-extra = { path = "../../axum-extra" }
10 | axum-server = { version = "0.7", features = ["tls-rustls"] }
11 | tokio = { version = "1", features = ["full"] }
12 | tracing = "0.1"
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 |
--------------------------------------------------------------------------------
/examples/templates-minijinja/templates/layout.jinja:
--------------------------------------------------------------------------------
1 |
2 |
3 | {% block title %}Website Name{% endblock %}
4 |
5 |
12 | {% block body %}{% endblock %}
13 |
14 |
15 |
--------------------------------------------------------------------------------
/examples/versioning/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-versioning"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tracing = "0.1"
11 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
12 |
13 | [dev-dependencies]
14 | http-body-util = "0.1.0"
15 | tower = { version = "0.5.2", features = ["util"] }
16 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_infer_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::State;
2 | use axum_macros::FromRequestParts;
3 |
4 | #[derive(FromRequestParts)]
5 | struct Extractor {
6 | inner_state: State,
7 | }
8 |
9 | #[derive(Clone)]
10 | struct AppState {}
11 |
12 | fn assert_from_request()
13 | where
14 | Extractor: axum::extract::FromRequestParts,
15 | {
16 | }
17 |
18 | fn main() {}
19 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/tuple_same_type_twice_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::Query;
2 | use axum_macros::FromRequestParts;
3 | use serde::Deserialize;
4 |
5 | #[derive(FromRequestParts)]
6 | struct Extractor(Query, axum::extract::Path);
7 |
8 | #[derive(Deserialize)]
9 | struct Payload {}
10 |
11 | fn assert_from_request()
12 | where
13 | Extractor: axum::extract::FromRequestParts<()>,
14 | {
15 | }
16 |
17 | fn main() {}
18 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/returning_request_parts.stderr:
--------------------------------------------------------------------------------
1 | error[E0308]: mismatched types
2 | --> tests/debug_handler/fail/returning_request_parts.rs:3:5
3 | |
4 | 3 | axum::http::request::Parts, // this should be response parts, not request parts
5 | | ^^^^^^^^^^^^^^^^^^^^^^^^^^
6 | | |
7 | | expected `axum::http::response::Parts`, found `axum::http::request::Parts`
8 | | expected `axum::http::response::Parts` because of return type
9 |
--------------------------------------------------------------------------------
/examples/websockets-http2/assets/script.js:
--------------------------------------------------------------------------------
1 | const socket = new WebSocket('wss://localhost:3000/ws');
2 |
3 | socket.addEventListener('message', e => {
4 | document.getElementById("messages").append(e.data, document.createElement("br"));
5 | });
6 |
7 | const form = document.querySelector("form");
8 | form.addEventListener("submit", () => {
9 | socket.send(form.elements.namedItem("content").value);
10 | form.elements.namedItem("content").value = "";
11 | });
12 |
--------------------------------------------------------------------------------
/examples/templates/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-templates"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | askama = "0.14"
9 | axum = { path = "../../axum" }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
14 | [dev-dependencies]
15 | http-body-util = "0.1.0"
16 | tower = { version = "0.5.2", features = ["util"] }
17 |
--------------------------------------------------------------------------------
/examples/tls-graceful-shutdown/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-tls-graceful-shutdown"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | axum-extra = { path = "../../axum-extra" }
10 | axum-server = { version = "0.7", features = ["tls-rustls"] }
11 | tokio = { version = "1", features = ["full"] }
12 | tracing = "0.1"
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 |
--------------------------------------------------------------------------------
/examples/http-proxy/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-http-proxy"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | hyper = { version = "1", features = ["full"] }
10 | hyper-util = "0.1.1"
11 | tokio = { version = "1.0", features = ["full"] }
12 | tower = { version = "0.5.2", features = ["make", "util"] }
13 | tracing = "0.1"
14 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
15 |
--------------------------------------------------------------------------------
/examples/static-file-server/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-static-file-server"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tower = { version = "0.5.2", features = ["util"] }
11 | tower-http = { version = "0.6.1", features = ["fs", "trace"] }
12 | tracing = "0.1"
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 |
--------------------------------------------------------------------------------
/examples/form/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-form"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | serde = { version = "1.0", features = ["derive"] }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 |
14 | [dev-dependencies]
15 | http-body-util = "0.1.3"
16 | mime = "0.3.17"
17 | tower = "0.5.2"
18 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/container.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::{
2 | rejection::JsonRejection,
3 | FromRequest,
4 | Json,
5 | };
6 | use serde::Deserialize;
7 |
8 | #[derive(Deserialize, FromRequest)]
9 | #[from_request(via(Json))]
10 | struct Extractor {
11 | one: i32,
12 | two: String,
13 | three: bool,
14 | }
15 |
16 | fn assert_from_request()
17 | where
18 | Extractor: FromRequest<(), Rejection = JsonRejection>,
19 | {
20 | }
21 |
22 | fn main() {}
23 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_infer_multiple.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::State;
2 | use axum_macros::FromRequest;
3 |
4 | #[derive(FromRequest)]
5 | struct Extractor {
6 | inner_state: State,
7 | also_inner_state: State,
8 | }
9 |
10 | #[derive(Clone)]
11 | struct AppState {}
12 |
13 | fn assert_from_request()
14 | where
15 | Extractor: axum::extract::FromRequest,
16 | {
17 | }
18 |
19 | fn main() {}
20 |
--------------------------------------------------------------------------------
/examples/error-handling/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-error-handling"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["macros"] }
9 | serde = { version = "1.0", features = ["derive"] }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tower-http = { version = "0.6.1", features = ["trace"] }
12 | tracing = "0.1"
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 |
--------------------------------------------------------------------------------
/examples/mongodb/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-mongodb"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | mongodb = "3.3.0"
10 | serde = { version = "1.0", features = ["derive"] }
11 | tokio = { version = "1.0", features = ["full"] }
12 | tower-http = { version = "0.6.1", features = ["add-extension", "trace"] }
13 | tracing = "0.1"
14 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
15 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/container_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::{
2 | rejection::ExtensionRejection,
3 | Extension,
4 | FromRequestParts,
5 | };
6 |
7 | #[derive(Clone, FromRequestParts)]
8 | #[from_request(via(Extension))]
9 | struct Extractor {
10 | one: i32,
11 | two: String,
12 | three: bool,
13 | }
14 |
15 | fn assert_from_request()
16 | where
17 | Extractor: FromRequestParts<(), Rejection = ExtensionRejection>,
18 | {
19 | }
20 |
21 | fn main() {}
22 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_field_infer.rs:
--------------------------------------------------------------------------------
1 | use axum::{extract::State, routing::get, Router};
2 | use axum_macros::FromRequest;
3 |
4 | fn main() {
5 | let _: axum::Router = Router::new()
6 | .route("/", get(|_: Extractor| async {}))
7 | .with_state(AppState::default());
8 | }
9 |
10 | #[derive(FromRequest)]
11 | struct Extractor {
12 | #[from_request(via(State))]
13 | state: AppState,
14 | }
15 |
16 | #[derive(Clone, Default)]
17 | struct AppState {}
18 |
--------------------------------------------------------------------------------
/examples/prometheus-metrics/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-prometheus-metrics"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | metrics = { version = "0.24", default-features = false }
10 | metrics-exporter-prometheus = { version = "0.17", default-features = false }
11 | tokio = { version = "1.0", features = ["full"] }
12 | tracing = "0.1"
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 |
--------------------------------------------------------------------------------
/examples/reqwest-response/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-reqwest-response"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | reqwest = { version = "0.12", features = ["stream"] }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tokio-stream = "0.1"
12 | tower-http = { version = "0.6.1", features = ["trace"] }
13 | tracing = "0.1"
14 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
15 |
--------------------------------------------------------------------------------
/examples/unix-domain-socket/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-unix-domain-socket"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | http-body-util = "0.1"
10 | hyper = { version = "1.0.0", features = ["full"] }
11 | hyper-util = { version = "0.1", features = ["tokio", "server-auto", "http1"] }
12 | tokio = { version = "1.0", features = ["full"] }
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 |
--------------------------------------------------------------------------------
/examples/websockets-http2/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-websockets-http2"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["ws", "http2"] }
9 | axum-server = { version = "0.7", features = ["tls-rustls"] }
10 | tokio = { version = "1", features = ["full"] }
11 | tower-http = { version = "0.6", features = ["fs"] }
12 | tracing = "0.1"
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 |
--------------------------------------------------------------------------------
/examples/dependency-injection/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-dependency-injection"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["tracing", "macros"] }
9 | serde = { version = "1.0", features = ["derive"] }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tracing = "0.1"
12 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
13 | uuid = { version = "1.0", features = ["serde", "v4"] }
14 |
--------------------------------------------------------------------------------
/examples/low-level-native-tls/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-low-level-native-tls"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | hyper = { version = "1.0.0", features = ["full"] }
10 | hyper-util = { version = "0.1" }
11 | tokio = { version = "1", features = ["full"] }
12 | tokio-native-tls = "0.3.1"
13 | tower-service = "0.3.2"
14 | tracing = "0.1"
15 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
16 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/extract_self_ref.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::{FromRequest, Request};
2 | use axum_macros::debug_handler;
3 |
4 | struct A;
5 |
6 | impl FromRequest for A
7 | where
8 | S: Send + Sync,
9 | {
10 | type Rejection = ();
11 |
12 | async fn from_request(_req: Request, _state: &S) -> Result {
13 | unimplemented!()
14 | }
15 | }
16 |
17 | impl A {
18 | #[debug_handler]
19 | async fn handler(&self) {}
20 | }
21 |
22 | fn main() {}
23 |
--------------------------------------------------------------------------------
/axum/src/docs/method_routing/merge.md:
--------------------------------------------------------------------------------
1 | Merge two routers into one.
2 |
3 | This is useful for breaking routers into smaller pieces and combining them
4 | into one.
5 |
6 | ```rust
7 | use axum::{
8 | routing::{get, post},
9 | Router,
10 | };
11 |
12 | let get = get(|| async {});
13 | let post = post(|| async {});
14 |
15 | let merged = get.merge(post);
16 |
17 | let app = Router::new().route("/", merged);
18 |
19 | // Our app now accepts
20 | // - GET /
21 | // - POST /
22 | # let _: Router = app;
23 | ```
24 |
--------------------------------------------------------------------------------
/examples/low-level-rustls/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-low-level-rustls"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | hyper = { version = "1.0.0", features = ["full"] }
10 | hyper-util = { version = "0.1", features = ["http2"] }
11 | tokio = { version = "1", features = ["full"] }
12 | tokio-rustls = "0.26"
13 | tower-service = "0.3.2"
14 | tracing = "0.1"
15 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
16 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/extract_self_mut.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::{FromRequest, Request};
2 | use axum_macros::debug_handler;
3 |
4 | struct A;
5 |
6 | impl FromRequest for A
7 | where
8 | S: Send + Sync,
9 | {
10 | type Rejection = ();
11 |
12 | async fn from_request(_req: Request, _state: &S) -> Result {
13 | unimplemented!()
14 | }
15 | }
16 |
17 | impl A {
18 | #[debug_handler]
19 | async fn handler(&mut self) {}
20 | }
21 |
22 | fn main() {}
23 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/output_tuple_too_many.stderr:
--------------------------------------------------------------------------------
1 | error: Cannot return tuples with more than 17 elements
2 | --> tests/debug_handler/fail/output_tuple_too_many.rs:4:20
3 | |
4 | 4 | async fn handler() -> (
5 | | ____________________^
6 | 5 | | axum::http::StatusCode,
7 | 6 | | AppendHeaders<[(axum::http::HeaderName, &'static str); 1]>,
8 | 7 | | AppendHeaders<[(axum::http::HeaderName, &'static str); 1]>,
9 | ... |
10 | 23 | | axum::http::StatusCode,
11 | 24 | | ) {
12 | | |_^
13 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_via_infer.rs:
--------------------------------------------------------------------------------
1 | use axum::{extract::State, routing::get, Router};
2 | use axum_macros::FromRequest;
3 |
4 | fn main() {
5 | let _: axum::Router = Router::new()
6 | .route("/b", get(|_: AppState| async {}))
7 | .with_state(AppState::default());
8 | }
9 |
10 | // if we're extract "via" `State` and not specifying state
11 | // assume `AppState` is the state
12 | #[derive(Clone, Default, FromRequest)]
13 | #[from_request(via(State))]
14 | struct AppState {}
15 |
--------------------------------------------------------------------------------
/axum/src/test_helpers/mod.rs:
--------------------------------------------------------------------------------
1 | #![allow(clippy::disallowed_names)]
2 |
3 | use crate::{extract::Request, response::Response, serve};
4 |
5 | mod test_client;
6 | pub use self::test_client::*;
7 |
8 | #[cfg(test)]
9 | pub(crate) mod tracing_helpers;
10 |
11 | #[cfg(test)]
12 | pub(crate) mod counting_cloneable_state;
13 |
14 | #[cfg(test)]
15 | pub(crate) fn assert_send() {}
16 | #[cfg(test)]
17 | pub(crate) fn assert_sync() {}
18 |
19 | #[allow(dead_code)]
20 | pub(crate) struct NotSendSync(*const ());
21 |
--------------------------------------------------------------------------------
/examples/stream-to-file/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-stream-to-file"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["multipart"] }
9 | futures-util = { version = "0.3", default-features = false, features = ["sink", "std"] }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tokio-util = { version = "0.7", features = ["io"] }
12 | tracing = "0.1"
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/too_many_extractors.rs:
--------------------------------------------------------------------------------
1 | use axum::http::Uri;
2 | use axum_macros::debug_handler;
3 |
4 | #[debug_handler]
5 | async fn handler(
6 | _e1: Uri,
7 | _e2: Uri,
8 | _e3: Uri,
9 | _e4: Uri,
10 | _e5: Uri,
11 | _e6: Uri,
12 | _e7: Uri,
13 | _e8: Uri,
14 | _e9: Uri,
15 | _e10: Uri,
16 | _e11: Uri,
17 | _e12: Uri,
18 | _e13: Uri,
19 | _e14: Uri,
20 | _e15: Uri,
21 | _e16: Uri,
22 | _e17: Uri,
23 | ) {
24 | }
25 |
26 | fn main() {}
27 |
--------------------------------------------------------------------------------
/examples/auto-reload/README.md:
--------------------------------------------------------------------------------
1 | # auto-reload
2 |
3 | This example shows how you can set up a development environment for your axum
4 | service such that whenever the source code changes, the app is recompiled and
5 | restarted. It uses `listenfd` to be able to migrate connections from an old
6 | version of the app to a newly-compiled version.
7 |
8 | ## Setup
9 |
10 | ```sh
11 | cargo install cargo-watch systemfd
12 | ```
13 |
14 | ## Running
15 |
16 | ```sh
17 | systemfd --no-pid -s http::3000 -- cargo watch -x run
18 | ```
19 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/wrong_order.stderr:
--------------------------------------------------------------------------------
1 | error: `Json<_>` consumes the request body and thus must be the last argument to the handler function
2 | --> tests/debug_handler/fail/wrong_order.rs:5:17
3 | |
4 | 5 | async fn one(_: Json<()>, _: Uri) {}
5 | | ^^^^^^^^
6 |
7 | error: `String` consumes the request body and thus must be the last argument to the handler function
8 | --> tests/debug_handler/fail/wrong_order.rs:8:17
9 | |
10 | 8 | async fn two(_: String, _: Uri) {}
11 | | ^^^^^^
12 |
--------------------------------------------------------------------------------
/examples/jwt/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-jwt"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | axum-extra = { path = "../../axum-extra", features = ["typed-header"] }
10 | jsonwebtoken = { version = "10", features = ["aws_lc_rs"] }
11 | serde = { version = "1.0", features = ["derive"] }
12 | serde_json = "1.0"
13 | tokio = { version = "1.0", features = ["full"] }
14 | tracing = "0.1"
15 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
16 |
--------------------------------------------------------------------------------
/examples/low-level-openssl/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-low-level-openssl"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | hyper = { version = "1.0.0", features = ["full"] }
10 | hyper-util = { version = "0.1" }
11 | openssl = "0.10"
12 | tokio = { version = "1", features = ["full"] }
13 | tokio-openssl = "0.6"
14 | tower = { version = "0.5.2", features = ["make"] }
15 | tracing = "0.1"
16 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
17 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/state_infer_multiple_different_types.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::State;
2 | use axum_macros::FromRequest;
3 |
4 | #[derive(FromRequest)]
5 | struct Extractor {
6 | inner_state: State,
7 | other_state: State,
8 | }
9 |
10 | #[derive(Clone)]
11 | struct AppState {}
12 |
13 | #[derive(Clone)]
14 | struct OtherState {}
15 |
16 | fn assert_from_request()
17 | where
18 | Extractor: axum::extract::FromRequest,
19 | {
20 | }
21 |
22 | fn main() {}
23 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/tuple_same_type_twice_via.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::Query;
2 | use axum::response::Response;
3 | use axum_macros::FromRequest;
4 | use serde::Deserialize;
5 |
6 | #[derive(FromRequest)]
7 | struct Extractor(
8 | #[from_request(via(Query))] Payload,
9 | #[from_request(via(axum::extract::Json))] Payload,
10 | );
11 |
12 | #[derive(Deserialize)]
13 | struct Payload {}
14 |
15 | fn assert_from_request()
16 | where
17 | Extractor: axum::extract::FromRequest<(), Rejection = Response>,
18 | {
19 | }
20 |
21 | fn main() {}
22 |
--------------------------------------------------------------------------------
/axum-macros/tests/typed_path/pass/tuple_struct.rs:
--------------------------------------------------------------------------------
1 | use axum_extra::routing::TypedPath;
2 | use serde::Deserialize;
3 |
4 | pub type Result = std::result::Result;
5 |
6 | #[derive(TypedPath, Deserialize)]
7 | #[typed_path("/users/{user_id}/teams/{team_id}")]
8 | struct MyPath(u32, u32);
9 |
10 | fn main() {
11 | _ = axum::Router::<()>::new().route("/", axum::routing::get(|_: MyPath| async {}));
12 |
13 | assert_eq!(MyPath::PATH, "/users/{user_id}/teams/{team_id}");
14 | assert_eq!(format!("{}", MyPath(1, 2)), "/users/1/teams/2");
15 | }
16 |
--------------------------------------------------------------------------------
/examples/customize-extractor-error/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-customize-extractor-error"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["macros"] }
9 | axum-extra = { path = "../../axum-extra", features = ["with-rejection"] }
10 | serde = { version = "1.0", features = ["derive"] }
11 | serde_json = "1.0"
12 | thiserror = "2"
13 | tokio = { version = "1.20", features = ["full"] }
14 | tracing = "0.1"
15 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
16 |
--------------------------------------------------------------------------------
/examples/diesel-async-postgres/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-diesel-async-postgres"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["macros"] }
9 | diesel = "~2.3"
10 | diesel-async = { version = "0.7", features = ["postgres", "bb8", "migrations"] }
11 | diesel_migrations = "~2.3"
12 | serde = { version = "1.0", features = ["derive"] }
13 | tokio = { version = "1.0", features = ["full"] }
14 | tracing = "0.1"
15 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
16 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/tuple_same_type_twice_via_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::Query;
2 | use axum::response::Response;
3 | use axum_macros::FromRequestParts;
4 | use serde::Deserialize;
5 |
6 | #[derive(FromRequestParts)]
7 | struct Extractor(
8 | #[from_request(via(Query))] Payload,
9 | #[from_request(via(axum::extract::Path))] Payload,
10 | );
11 |
12 | #[derive(Deserialize)]
13 | struct Payload {}
14 |
15 | fn assert_from_request()
16 | where
17 | Extractor: axum::extract::FromRequestParts<(), Rejection = Response>,
18 | {
19 | }
20 |
21 | fn main() {}
22 |
--------------------------------------------------------------------------------
/examples/diesel-postgres/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-diesel-postgres"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum", features = ["macros"] }
9 | deadpool-diesel = { version = "0.6.1", features = ["postgres"] }
10 | diesel = { version = "2", features = ["postgres"] }
11 | diesel_migrations = "2"
12 | serde = { version = "1.0", features = ["derive"] }
13 | tokio = { version = "1.0", features = ["full"] }
14 | tracing = "0.1"
15 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
16 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/pass/set_state.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::{FromRef, FromRequest, Request};
2 | use axum_macros::debug_handler;
3 |
4 | #[debug_handler(state = AppState)]
5 | async fn handler(_: A) {}
6 |
7 | #[derive(Clone)]
8 | struct AppState;
9 |
10 | struct A;
11 |
12 | impl FromRequest for A
13 | where
14 | S: Send + Sync,
15 | AppState: FromRef,
16 | {
17 | type Rejection = ();
18 |
19 | async fn from_request(_req: Request, _state: &S) -> Result {
20 | unimplemented!()
21 | }
22 | }
23 |
24 | fn main() {}
25 |
--------------------------------------------------------------------------------
/axum-macros/tests/typed_path/pass/into_uri.rs:
--------------------------------------------------------------------------------
1 | use axum::http::Uri;
2 | use axum_extra::routing::TypedPath;
3 | use serde::Deserialize;
4 |
5 | #[derive(TypedPath, Deserialize)]
6 | #[typed_path("/{id}")]
7 | struct Named {
8 | id: u32,
9 | }
10 |
11 | #[derive(TypedPath, Deserialize)]
12 | #[typed_path("/{id}")]
13 | struct Unnamed(u32);
14 |
15 | #[derive(TypedPath, Deserialize)]
16 | #[typed_path("/")]
17 | struct Unit;
18 |
19 | fn main() {
20 | let _: Uri = Named { id: 1 }.to_uri();
21 | let _: Uri = Unnamed(1).to_uri();
22 | let _: Uri = Unit.to_uri();
23 | }
24 |
--------------------------------------------------------------------------------
/examples/todos/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-todos"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | serde = { version = "1.0", features = ["derive"] }
10 | tokio = { version = "1.0", features = ["full"] }
11 | tower = { version = "0.5.2", features = ["util", "timeout"] }
12 | tower-http = { version = "0.6.1", features = ["add-extension", "trace"] }
13 | tracing = "0.1"
14 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
15 | uuid = { version = "1.0", features = ["serde", "v4"] }
16 |
--------------------------------------------------------------------------------
/examples/validator/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | edition = "2021"
3 | name = "example-validator"
4 | publish = false
5 | version = "0.1.0"
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | serde = { version = "1.0", features = ["derive"] }
10 | thiserror = "2"
11 | tokio = { version = "1.0", features = ["full"] }
12 | tracing = "0.1"
13 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
14 | validator = { version = "0.20.0", features = ["derive"] }
15 |
16 | [dev-dependencies]
17 | http-body-util = "0.1.0"
18 | tower = { version = "0.5.2", features = ["util"] }
19 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_ref/pass/basic.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::{FromRef, State},
3 | routing::get,
4 | Router,
5 | };
6 |
7 | // This will implement `FromRef` for each field in the struct.
8 | #[derive(Clone, FromRef)]
9 | struct AppState {
10 | auth_token: String,
11 | }
12 |
13 | // So those types can be extracted via `State`
14 | async fn handler(_: State) {}
15 |
16 | fn main() {
17 | let state = AppState {
18 | auth_token: Default::default(),
19 | };
20 |
21 | let _: axum::Router = Router::new().route("/", get(handler)).with_state(state);
22 | }
23 |
--------------------------------------------------------------------------------
/examples/key-value-store/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-key-value-store"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | tokio = { version = "1.0", features = ["full"] }
10 | tower = { version = "0.5.2", features = ["util", "timeout", "load-shed", "limit"] }
11 | tower-http = { version = "0.6.1", features = [
12 | "add-extension",
13 | "auth",
14 | "compression-full",
15 | "limit",
16 | "trace",
17 | ] }
18 | tracing = "0.1"
19 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
20 |
--------------------------------------------------------------------------------
/examples/compression/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-compression"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | serde_json = "1"
10 | tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
11 | tower = "0.5.2"
12 | tower-http = { version = "0.6.1", features = ["compression-full", "decompression-full"] }
13 | tracing = "0.1"
14 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
15 |
16 | [dev-dependencies]
17 | assert-json-diff = "2.0"
18 | brotli = "8"
19 | flate2 = "1"
20 | http = "1"
21 | zstd = "0.13"
22 |
--------------------------------------------------------------------------------
/examples/testing/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-testing"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | http-body-util = "0.1.0"
10 | hyper-util = { version = "0.1", features = ["client", "http1", "client-legacy"] }
11 | mime = "0.3"
12 | serde_json = "1.0"
13 | tokio = { version = "1.0", features = ["full"] }
14 | tower-http = { version = "0.6.1", features = ["trace"] }
15 | tracing = "0.1"
16 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
17 |
18 | [dev-dependencies]
19 | tower = { version = "0.5.2", features = ["util"] }
20 |
--------------------------------------------------------------------------------
/axum-macros/tests/typed_path/pass/url_encoding.rs:
--------------------------------------------------------------------------------
1 | use axum_extra::routing::TypedPath;
2 | use serde::Deserialize;
3 |
4 | #[derive(TypedPath, Deserialize)]
5 | #[typed_path("/{param}")]
6 | struct Named {
7 | param: String,
8 | }
9 |
10 | #[derive(TypedPath, Deserialize)]
11 | #[typed_path("/{param}")]
12 | struct Unnamed(String);
13 |
14 | fn main() {
15 | assert_eq!(
16 | format!(
17 | "{}",
18 | Named {
19 | param: "a b".to_string()
20 | }
21 | ),
22 | "/a%20b"
23 | );
24 |
25 | assert_eq!(format!("{}", Unnamed("a b".to_string()),), "/a%20b");
26 | }
27 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/pass/infer_state.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::State;
2 | use axum_macros::debug_handler;
3 |
4 | #[debug_handler]
5 | async fn handler(_: State) {}
6 |
7 | #[debug_handler]
8 | async fn handler_2(_: axum::extract::State) {}
9 |
10 | #[debug_handler]
11 | async fn handler_3(_: axum::extract::State, _: axum::extract::State) {}
12 |
13 | #[debug_handler]
14 | async fn handler_4(_: State, _: State) {}
15 |
16 | #[debug_handler]
17 | async fn handler_5(_: axum::extract::State, _: State) {}
18 |
19 | #[derive(Clone)]
20 | struct AppState;
21 |
22 | fn main() {}
23 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_cookie.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::FromRef;
2 | use axum_extra::extract::cookie::{Key, PrivateCookieJar};
3 | use axum_macros::FromRequest;
4 |
5 | #[derive(FromRequest)]
6 | #[from_request(state(AppState))]
7 | struct Extractor {
8 | cookies: PrivateCookieJar,
9 | }
10 |
11 | struct AppState {
12 | key: Key,
13 | }
14 |
15 | impl FromRef for Key {
16 | fn from_ref(input: &AppState) -> Self {
17 | input.key.clone()
18 | }
19 | }
20 |
21 | fn assert_from_request()
22 | where
23 | Extractor: axum::extract::FromRequest,
24 | {
25 | }
26 |
27 | fn main() {}
28 |
--------------------------------------------------------------------------------
/examples/customize-extractor-error/README.md:
--------------------------------------------------------------------------------
1 | This example explores 3 different ways you can create custom rejections for
2 | already existing extractors
3 |
4 | - [`with_rejection`](src/with_rejection.rs): Uses
5 | `axum_extra::extract::WithRejection` to transform one rejection into another
6 | - [`derive_from_request`](src/derive_from_request.rs): Uses the
7 | `axum::extract::FromRequest` derive macro to wrap another extractor and
8 | customize the rejection
9 | - [`custom_extractor`](src/custom_extractor.rs): Manual implementation of
10 | `FromRequest` that wraps another extractor
11 |
12 | Run with
13 |
14 | ```sh
15 | cargo run -p example-customize-extractor-error
16 | ```
17 |
--------------------------------------------------------------------------------
/.github/DISCUSSION_TEMPLATE/q-a.yml:
--------------------------------------------------------------------------------
1 | body:
2 | - type: textarea
3 | attributes:
4 | label: Summary
5 | description: 'Your question:'
6 | validations:
7 | required: true
8 | - type: input
9 | attributes:
10 | label: axum version
11 | description: 'Please look it up in `Cargo.lock`, or as described below'
12 | validations:
13 | required: true
14 | - type: markdown
15 | attributes:
16 | value: |
17 | > If you have `jq` installed, you can look up the version by running
18 | >
19 | > ```bash
20 | > cargo metadata --format-version=1 | jq -r '.packages[] | select(.name == "axum") | .version'
21 | > ```
22 |
--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
1 |
9 |
10 | ## Motivation
11 |
12 |
17 |
18 | ## Solution
19 |
20 |
24 |
--------------------------------------------------------------------------------
/axum-macros/tests/typed_path/fail/missing_capture.stderr:
--------------------------------------------------------------------------------
1 | error[E0027]: pattern does not mention field `id`
2 | --> tests/typed_path/fail/missing_capture.rs:5:14
3 | |
4 | 5 | #[typed_path("/users")]
5 | | ^^^^^^^^ missing field `id`
6 | |
7 | help: include the missing field in the pattern
8 | |
9 | 5 | #[typed_path("/users" { id })]
10 | | ++++++
11 | help: if you don't care about this missing field, you can explicitly ignore it
12 | |
13 | 5 | #[typed_path("/users" { id: _ })]
14 | | +++++++++
15 | help: or always ignore missing fields here
16 | |
17 | 5 | #[typed_path("/users" { .. })]
18 | | ++++++
19 |
--------------------------------------------------------------------------------
/examples/hello-world/src/main.rs:
--------------------------------------------------------------------------------
1 | //! Run with
2 | //!
3 | //! ```not_rust
4 | //! cargo run -p example-hello-world
5 | //! ```
6 |
7 | use axum::{response::Html, routing::get, Router};
8 |
9 | #[tokio::main]
10 | async fn main() {
11 | // build our application with a route
12 | let app = Router::new().route("/", get(handler));
13 |
14 | // run it
15 | let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
16 | .await
17 | .unwrap();
18 | println!("listening on {}", listener.local_addr().unwrap());
19 | axum::serve(listener, app).await.unwrap();
20 | }
21 |
22 | async fn handler() -> Html<&'static str> {
23 | Html("Hello, World!
")
24 | }
25 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/named_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::{extract::FromRequestParts, response::Response};
2 | use axum_extra::{
3 | headers::{self, UserAgent},
4 | typed_header::TypedHeaderRejection,
5 | TypedHeader,
6 | };
7 |
8 | #[derive(FromRequestParts)]
9 | struct Extractor {
10 | uri: axum::http::Uri,
11 | user_agent: TypedHeader,
12 | content_type: TypedHeader,
13 | etag: Option>,
14 | host: Result, TypedHeaderRejection>,
15 | }
16 |
17 | fn assert_from_request()
18 | where
19 | Extractor: FromRequestParts<(), Rejection = Response>,
20 | {
21 | }
22 |
23 | fn main() {}
24 |
--------------------------------------------------------------------------------
/examples/oauth/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-oauth"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | anyhow = "1"
9 | async-session = "3.0.0"
10 | axum = { path = "../../axum" }
11 | axum-extra = { path = "../../axum-extra", features = ["typed-header"] }
12 | http = "1.0.0"
13 | oauth2 = "5"
14 | # Use Rustls because it makes it easier to cross-compile on CI
15 | reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "json"] }
16 | serde = { version = "1.0", features = ["derive"] }
17 | tokio = { version = "1.0", features = ["full"] }
18 | tracing = "0.1"
19 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
20 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/multiple_request_consumers.stderr:
--------------------------------------------------------------------------------
1 | error: Can't have two extractors that consume the request body. `Json<_>` and `String` both do that.
2 | --> tests/debug_handler/fail/multiple_request_consumers.rs:9:14
3 | |
4 | 9 | async fn one(_: Json<()>, _: String, _: Uri) {}
5 | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
6 |
7 | error: Can't have more than one extractor that consume the request body. `Json<_>`, `Bytes`, and `String` all do that.
8 | --> tests/debug_handler/fail/multiple_request_consumers.rs:12:14
9 | |
10 | 12 | async fn two(_: Json<()>, _: Method, _: Bytes, _: Uri, _: String) {}
11 | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
12 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/named.rs:
--------------------------------------------------------------------------------
1 | use axum::{extract::FromRequest, response::Response};
2 | use axum_extra::{
3 | headers::{self, UserAgent},
4 | typed_header::TypedHeaderRejection,
5 | TypedHeader,
6 | };
7 |
8 | #[derive(FromRequest)]
9 | struct Extractor {
10 | uri: axum::http::Uri,
11 | user_agent: TypedHeader,
12 | content_type: TypedHeader,
13 | etag: Option>,
14 | host: Result, TypedHeaderRejection>,
15 | body: String,
16 | }
17 |
18 | fn assert_from_request()
19 | where
20 | Extractor: FromRequest<(), Rejection = Response>,
21 | {
22 | }
23 |
24 | fn main() {}
25 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/multiple_paths.stderr:
--------------------------------------------------------------------------------
1 | error: Multiple parameters must be extracted with a tuple `Path<(_, _)>` or a struct `Path`, not by applying multiple `Path<_>` extractors
2 | --> tests/debug_handler/fail/multiple_paths.rs:5:18
3 | |
4 | 5 | async fn handler(_: Path, _: Path) {}
5 | | ^^^^^^^^^^^^^^^
6 |
7 | error: Multiple parameters must be extracted with a tuple `Path<(_, _)>` or a struct `Path`, not by applying multiple `Path<_>` extractors
8 | --> tests/debug_handler/fail/multiple_paths.rs:5:35
9 | |
10 | 5 | async fn handler(_: Path, _: Path) {}
11 | | ^^^^^^^^^^^^^^^
12 |
--------------------------------------------------------------------------------
/axum-macros/tests/typed_path/pass/named_fields_struct.rs:
--------------------------------------------------------------------------------
1 | use axum_extra::routing::TypedPath;
2 | use serde::Deserialize;
3 |
4 | #[derive(TypedPath, Deserialize)]
5 | #[typed_path("/users/{user_id}/teams/{team_id}")]
6 | struct MyPath {
7 | user_id: u32,
8 | team_id: u32,
9 | }
10 |
11 | fn main() {
12 | _ = axum::Router::<()>::new().route("/", axum::routing::get(|_: MyPath| async {}));
13 |
14 | assert_eq!(MyPath::PATH, "/users/{user_id}/teams/{team_id}");
15 | assert_eq!(
16 | format!(
17 | "{}",
18 | MyPath {
19 | user_id: 1,
20 | team_id: 2
21 | }
22 | ),
23 | "/users/1/teams/2"
24 | );
25 | }
26 |
--------------------------------------------------------------------------------
/axum-macros/tests/typed_path/pass/result_handler.rs:
--------------------------------------------------------------------------------
1 | use axum::{extract::rejection::PathRejection, http::StatusCode};
2 | use axum_extra::routing::{RouterExt, TypedPath};
3 | use serde::Deserialize;
4 |
5 | #[derive(TypedPath, Deserialize)]
6 | #[typed_path("/users/{id}")]
7 | struct UsersShow {
8 | id: String,
9 | }
10 |
11 | async fn result_handler(_: Result) {}
12 |
13 | #[derive(TypedPath, Deserialize)]
14 | #[typed_path("/users")]
15 | struct UsersIndex;
16 |
17 | async fn result_handler_unit_struct(_: Result) {}
18 |
19 | fn main() {
20 | _ = axum::Router::<()>::new()
21 | .typed_post(result_handler)
22 | .typed_post(result_handler_unit_struct);
23 | }
24 |
--------------------------------------------------------------------------------
/axum-extra/src/extract/rejection.rs:
--------------------------------------------------------------------------------
1 | //! Rejection response types.
2 |
3 | use axum_core::{
4 | __composite_rejection as composite_rejection, __define_rejection as define_rejection,
5 | };
6 |
7 | define_rejection! {
8 | #[status = BAD_REQUEST]
9 | #[body = "No host found in request"]
10 | /// Rejection type used if the [`Host`](super::Host) extractor is unable to
11 | /// resolve a host.
12 | pub struct FailedToResolveHost;
13 | }
14 |
15 | composite_rejection! {
16 | /// Rejection used for [`Host`](super::Host).
17 | ///
18 | /// Contains one variant for each way the [`Host`](super::Host) extractor
19 | /// can fail.
20 | pub enum HostRejection {
21 | FailedToResolveHost,
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature_request.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: 💡 Feature Request
3 | about: I have a suggestion (and may want to implement it 🙂)!
4 | ---
5 |
6 | - [ ] I have looked for existing issues (including closed) about this
7 |
8 | ## Feature Request
9 |
10 | ### Motivation
11 |
12 |
15 |
16 | ### Proposal
17 |
18 |
22 |
23 | ### Alternatives
24 |
25 |
30 |
--------------------------------------------------------------------------------
/examples/simple-router-wasm/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-simple-router-wasm"
3 | version = "0.1.0"
4 | edition = "2018"
5 | publish = false
6 |
7 | [package.metadata.cargo-machete]
8 | ignored = ["axum-extra"]
9 |
10 | [dependencies]
11 | # `default-features = false` to not depend on tokio features which don't support wasm
12 | # you can still pull in tokio manually and only add features that tokio supports for wasm
13 | axum = { path = "../../axum", default-features = false }
14 | # we don't strictly use axum-extra in this example but wanna make sure that
15 | # works in wasm as well
16 | axum-extra = { path = "../../axum-extra", default-features = false }
17 | futures-executor = "0.3.21"
18 | http = "1.0.0"
19 | tower-service = "0.3.1"
20 |
--------------------------------------------------------------------------------
/examples/sse/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-sse"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [dependencies]
8 | axum = { path = "../../axum" }
9 | axum-extra = { path = "../../axum-extra", features = ["typed-header"] }
10 | futures-util = { version = "0.3", default-features = false, features = ["sink", "std"] }
11 | headers = "0.4"
12 | tokio = { version = "1.0", features = ["full"] }
13 | tokio-stream = "0.1"
14 | tower-http = { version = "0.6.1", features = ["fs", "trace"] }
15 | tracing = "0.1"
16 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
17 |
18 | [dev-dependencies]
19 | eventsource-stream = "0.2"
20 | reqwest = { version = "0.12", features = ["stream"] }
21 | reqwest-eventsource = "0.6"
22 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/wrong_return_tuple.rs:
--------------------------------------------------------------------------------
1 | #![allow(unused_parens)]
2 |
3 | #[axum::debug_handler]
4 | async fn named_type() -> (
5 | axum::http::StatusCode,
6 | axum::Json<&'static str>,
7 | axum::response::AppendHeaders<[(axum::http::HeaderName, &'static str); 1]>,
8 | ) {
9 | panic!()
10 | }
11 |
12 | struct CustomIntoResponse {}
13 | impl axum::response::IntoResponse for CustomIntoResponse {
14 | fn into_response(self) -> axum::response::Response {
15 | todo!()
16 | }
17 | }
18 | #[axum::debug_handler]
19 | async fn custom_type() -> (
20 | axum::http::StatusCode,
21 | CustomIntoResponse,
22 | axum::response::AppendHeaders<[(axum::http::HeaderName, &'static str); 1]>,
23 | ) {
24 | panic!()
25 | }
26 |
27 | fn main() {}
28 |
--------------------------------------------------------------------------------
/examples/websockets/assets/script.js:
--------------------------------------------------------------------------------
1 | const socket = new WebSocket('ws://localhost:3000/ws');
2 |
3 | socket.addEventListener('open', function (event) {
4 | socket.send('Hello Server!');
5 | });
6 |
7 | socket.addEventListener('message', function (event) {
8 | console.log('Message from server ', event.data);
9 | });
10 |
11 |
12 | setTimeout(() => {
13 | const obj = { hello: "world" };
14 | const blob = new Blob([JSON.stringify(obj, null, 2)], {
15 | type: "application/json",
16 | });
17 | console.log("Sending blob over websocket");
18 | socket.send(blob);
19 | }, 1000);
20 |
21 | setTimeout(() => {
22 | socket.send('About done here...');
23 | console.log("Sending close over websocket");
24 | socket.close(3000, "Crash and Burn!");
25 | }, 3000);
--------------------------------------------------------------------------------
/deny.toml:
--------------------------------------------------------------------------------
1 | [graph]
2 | exclude-unpublished = true
3 |
4 | [advisories]
5 | unmaintained = "none"
6 | ignore = []
7 |
8 | [licenses]
9 | confidence-threshold = 0.8
10 | allow = [
11 | "Apache-2.0",
12 | "BSD-3-Clause",
13 | "MIT",
14 | "Unicode-3.0",
15 | ]
16 |
17 | [bans]
18 | multiple-versions = "deny"
19 | highlight = "all"
20 | skip-tree = [
21 | # currently duplicated through header, reqwest, tower-http and cookie
22 | # C.f. https://github.com/tokio-rs/axum/pull/1641
23 | { name = "base64" },
24 | # parking_lot pulls in old versions of windows-sys
25 | { name = "windows-sys" },
26 | # pulled in by quickcheck and cookie
27 | { name = "rand" },
28 | ]
29 |
30 | [sources]
31 | unknown-registry = "warn"
32 | unknown-git = "warn"
33 | allow-git = []
34 |
--------------------------------------------------------------------------------
/examples/websockets/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | name = "example-websockets"
3 | version = "0.1.0"
4 | edition = "2021"
5 | publish = false
6 |
7 | [[bin]]
8 | name = "example-websockets"
9 | path = "src/main.rs"
10 |
11 | [[bin]]
12 | name = "example-client"
13 | path = "src/client.rs"
14 |
15 | [dependencies]
16 | axum = { path = "../../axum", features = ["ws"] }
17 | axum-extra = { path = "../../axum-extra", features = ["typed-header"] }
18 | futures-util = { version = "0.3", default-features = false, features = ["sink", "std"] }
19 | headers = "0.4"
20 | tokio = { version = "1.0", features = ["full"] }
21 | tokio-tungstenite = "0.28.0"
22 | tower-http = { version = "0.6.1", features = ["fs", "trace"] }
23 | tracing = "0.1"
24 | tracing-subscriber = { version = "0.3", features = ["env-filter"] }
25 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_via.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::{FromRef, State},
3 | routing::get,
4 | Router,
5 | };
6 | use axum_macros::FromRequest;
7 |
8 | fn main() {
9 | let _: axum::Router = Router::new()
10 | .route("/b", get(|_: (), _: AppState| async {}))
11 | .route("/c", get(|_: (), _: InnerState| async {}))
12 | .with_state(AppState::default());
13 | }
14 |
15 | #[derive(Clone, Default, FromRequest)]
16 | #[from_request(via(State), state(AppState))]
17 | struct AppState {
18 | inner: InnerState,
19 | }
20 |
21 | #[derive(Clone, Default, FromRequest)]
22 | #[from_request(via(State), state(AppState))]
23 | struct InnerState {}
24 |
25 | impl FromRef for InnerState {
26 | fn from_ref(input: &AppState) -> Self {
27 | input.inner.clone()
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/pass/self_receiver.rs:
--------------------------------------------------------------------------------
1 | use axum::extract::{FromRequest, Request};
2 | use axum_macros::debug_handler;
3 |
4 | struct A;
5 |
6 | impl FromRequest for A
7 | where
8 | S: Send + Sync,
9 | {
10 | type Rejection = ();
11 |
12 | async fn from_request(_req: Request, _state: &S) -> Result {
13 | unimplemented!()
14 | }
15 | }
16 |
17 | impl FromRequest for Box
18 | where
19 | S: Send + Sync,
20 | {
21 | type Rejection = ();
22 |
23 | async fn from_request(_req: Request, _state: &S) -> Result {
24 | unimplemented!()
25 | }
26 | }
27 |
28 | impl A {
29 | #[debug_handler]
30 | async fn handler(self) {}
31 |
32 | #[debug_handler]
33 | async fn handler_with_qualified_self(self: Box) {}
34 | }
35 |
36 | fn main() {}
37 |
--------------------------------------------------------------------------------
/examples/compression/README.md:
--------------------------------------------------------------------------------
1 | # compression
2 |
3 | This example shows how to:
4 | - automatically decompress request bodies when necessary
5 | - compress response bodies based on the `accept` header.
6 |
7 | ## Running
8 |
9 | ```
10 | cargo run -p example-compression
11 | ```
12 |
13 | ## Sending compressed requests
14 |
15 | ```
16 | curl -v -g 'http://localhost:3000/' \
17 | -H "Content-Type: application/json" \
18 | -H "Content-Encoding: gzip" \
19 | --compressed \
20 | --data-binary @data/products.json.gz
21 | ```
22 |
23 | (Notice the `Content-Encoding: gzip` in the request, and `content-encoding: gzip` in the response.)
24 |
25 | ## Sending uncompressed requests
26 |
27 | ```
28 | curl -v -g 'http://localhost:3000/' \
29 | -H "Content-Type: application/json" \
30 | --compressed \
31 | --data-binary @data/products.json
32 | ```
33 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_enum_via.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::{FromRef, State},
3 | routing::get,
4 | Router,
5 | };
6 | use axum_macros::FromRequest;
7 |
8 | fn main() {
9 | let _: axum::Router = Router::new()
10 | .route("/a", get(|_: AppState| async {}))
11 | .route("/b", get(|_: InnerState| async {}))
12 | .with_state(AppState::default());
13 | }
14 |
15 | #[derive(Clone, FromRequest)]
16 | #[from_request(via(State))]
17 | enum AppState {
18 | One,
19 | }
20 |
21 | impl Default for AppState {
22 | fn default() -> AppState {
23 | Self::One
24 | }
25 | }
26 |
27 | #[derive(FromRequest)]
28 | #[from_request(via(State), state(AppState))]
29 | enum InnerState {}
30 |
31 | impl FromRef for InnerState {
32 | fn from_ref(_: &AppState) -> Self {
33 | todo!("🤷")
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_field_explicit.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::{FromRef, State},
3 | routing::get,
4 | Router,
5 | };
6 | use axum_macros::FromRequest;
7 |
8 | fn main() {
9 | let _: axum::Router = Router::new()
10 | .route("/", get(|_: Extractor| async {}))
11 | .with_state(AppState::default());
12 | }
13 |
14 | #[derive(FromRequest)]
15 | #[from_request(state(AppState))]
16 | struct Extractor {
17 | #[from_request(via(State))]
18 | state: AppState,
19 | #[from_request(via(State))]
20 | inner: InnerState,
21 | }
22 |
23 | #[derive(Clone, Default)]
24 | struct AppState {
25 | inner: InnerState,
26 | }
27 |
28 | #[derive(Clone, Default)]
29 | struct InnerState {}
30 |
31 | impl FromRef for InnerState {
32 | fn from_ref(input: &AppState) -> Self {
33 | input.inner.clone()
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_explicit_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::{FromRef, Query, State},
3 | routing::get,
4 | Router,
5 | };
6 | use axum_macros::FromRequestParts;
7 | use std::collections::HashMap;
8 |
9 | fn main() {
10 | let _: axum::Router = Router::new()
11 | .route("/b", get(|_: Extractor| async {}))
12 | .with_state(AppState::default());
13 | }
14 |
15 | #[derive(FromRequestParts)]
16 | #[from_request(state(AppState))]
17 | struct Extractor {
18 | inner_state: State,
19 | other: Query>,
20 | }
21 |
22 | #[derive(Default, Clone)]
23 | struct AppState {
24 | inner: InnerState,
25 | }
26 |
27 | #[derive(Clone, Default)]
28 | struct InnerState {}
29 |
30 | impl FromRef for InnerState {
31 | fn from_ref(input: &AppState) -> Self {
32 | input.inner.clone()
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/fail/override_rejection_on_enum_without_via.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::rejection::ExtensionRejection,
3 | response::{IntoResponse, Response},
4 | routing::get,
5 | Router,
6 | };
7 | use axum_macros::FromRequest;
8 |
9 | fn main() {
10 | let _: Router = Router::new().route("/", get(handler).post(handler_result));
11 | }
12 |
13 | async fn handler(_: MyExtractor) {}
14 |
15 | async fn handler_result(_: Result) {}
16 |
17 | #[derive(FromRequest, Clone)]
18 | #[from_request(rejection(MyRejection))]
19 | enum MyExtractor {}
20 |
21 | struct MyRejection {}
22 |
23 | impl From for MyRejection {
24 | fn from(_: ExtensionRejection) -> Self {
25 | todo!()
26 | }
27 | }
28 |
29 | impl IntoResponse for MyRejection {
30 | fn into_response(self) -> Response {
31 | todo!()
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/named_via.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::{Extension, FromRequest},
3 | response::Response,
4 | };
5 | use axum_extra::{
6 | headers::{self, UserAgent},
7 | typed_header::TypedHeaderRejection,
8 | TypedHeader,
9 | };
10 |
11 | #[derive(FromRequest)]
12 | struct Extractor {
13 | #[from_request(via(Extension))]
14 | state: State,
15 | #[from_request(via(TypedHeader))]
16 | user_agent: UserAgent,
17 | #[from_request(via(TypedHeader))]
18 | content_type: headers::ContentType,
19 | #[from_request(via(TypedHeader))]
20 | etag: Option,
21 | #[from_request(via(TypedHeader))]
22 | host: Result,
23 | }
24 |
25 | fn assert_from_request()
26 | where
27 | Extractor: FromRequest<(), Rejection = Response>,
28 | {
29 | }
30 |
31 | #[derive(Clone)]
32 | struct State;
33 |
34 | fn main() {}
35 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/override_rejection_with_via_on_enum.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::rejection::ExtensionRejection,
3 | response::{IntoResponse, Response},
4 | routing::get,
5 | Router,
6 | };
7 | use axum_macros::FromRequest;
8 |
9 | fn main() {
10 | let _: Router = Router::new().route("/", get(handler).post(handler_result));
11 | }
12 |
13 | async fn handler(_: MyExtractor) {}
14 |
15 | async fn handler_result(_: Result) {}
16 |
17 | #[derive(FromRequest, Clone)]
18 | #[from_request(via(axum::Extension), rejection(MyRejection))]
19 | enum MyExtractor {}
20 |
21 | struct MyRejection {}
22 |
23 | impl From for MyRejection {
24 | fn from(_: ExtensionRejection) -> Self {
25 | todo!()
26 | }
27 | }
28 |
29 | impl IntoResponse for MyRejection {
30 | fn into_response(self) -> Response {
31 | todo!()
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/axum-core/src/error.rs:
--------------------------------------------------------------------------------
1 | use crate::BoxError;
2 | use std::{error::Error as StdError, fmt};
3 |
4 | /// Errors that can happen when using axum.
5 | #[derive(Debug)]
6 | pub struct Error {
7 | inner: BoxError,
8 | }
9 |
10 | impl Error {
11 | /// Create a new `Error` from a boxable error.
12 | pub fn new(error: impl Into) -> Self {
13 | Self {
14 | inner: error.into(),
15 | }
16 | }
17 |
18 | /// Convert an `Error` back into the underlying boxed trait object.
19 | #[must_use]
20 | pub fn into_inner(self) -> BoxError {
21 | self.inner
22 | }
23 | }
24 |
25 | impl fmt::Display for Error {
26 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
27 | self.inner.fmt(f)
28 | }
29 | }
30 |
31 | impl StdError for Error {
32 | fn source(&self) -> Option<&(dyn StdError + 'static)> {
33 | Some(&*self.inner)
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_via_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::{FromRef, State},
3 | routing::get,
4 | Router,
5 | };
6 | use axum_macros::FromRequestParts;
7 |
8 | fn main() {
9 | let _: axum::Router = Router::new()
10 | .route("/a", get(|_: AppState, _: InnerState, _: String| async {}))
11 | .route("/b", get(|_: AppState, _: String| async {}))
12 | .route("/c", get(|_: InnerState, _: String| async {}))
13 | .with_state(AppState::default());
14 | }
15 |
16 | #[derive(Clone, Default, FromRequestParts)]
17 | #[from_request(via(State))]
18 | struct AppState {
19 | inner: InnerState,
20 | }
21 |
22 | #[derive(Clone, Default, FromRequestParts)]
23 | #[from_request(via(State), state(AppState))]
24 | struct InnerState {}
25 |
26 | impl FromRef for InnerState {
27 | fn from_ref(input: &AppState) -> Self {
28 | input.inner.clone()
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/axum/src/docs/method_routing/layer.md:
--------------------------------------------------------------------------------
1 | Apply a [`tower::Layer`] to all routes in the router.
2 |
3 | This can be used to add additional processing to a request for a group
4 | of routes.
5 |
6 | Note that the middleware is only applied to existing routes. So you have to
7 | first add your routes (and / or fallback) and then call `layer` afterwards. Additional
8 | routes added after `layer` is called will not have the middleware added.
9 |
10 | Works similarly to [`Router::layer`](super::Router::layer). See that method for
11 | more details.
12 |
13 | # Example
14 |
15 | ```rust
16 | use axum::{routing::get, Router};
17 | use tower::limit::ConcurrencyLimitLayer;
18 |
19 | async fn handler() {}
20 |
21 | let app = Router::new().route(
22 | "/",
23 | // All requests to `GET /` will be sent through `ConcurrencyLimitLayer`
24 | get(handler).layer(ConcurrencyLimitLayer::new(64)),
25 | );
26 | # let _: Router = app;
27 | ```
28 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/named_via_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::{Extension, FromRequestParts},
3 | response::Response,
4 | };
5 | use axum_extra::{
6 | headers::{self, UserAgent},
7 | typed_header::TypedHeaderRejection,
8 | TypedHeader,
9 | };
10 |
11 | #[derive(FromRequestParts)]
12 | struct Extractor {
13 | #[from_request(via(Extension))]
14 | state: State,
15 | #[from_request(via(TypedHeader))]
16 | user_agent: UserAgent,
17 | #[from_request(via(TypedHeader))]
18 | content_type: headers::ContentType,
19 | #[from_request(via(TypedHeader))]
20 | etag: Option,
21 | #[from_request(via(TypedHeader))]
22 | host: Result,
23 | }
24 |
25 | fn assert_from_request()
26 | where
27 | Extractor: FromRequestParts<(), Rejection = Response>,
28 | {
29 | }
30 |
31 | #[derive(Clone)]
32 | struct State;
33 |
34 | fn main() {}
35 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/override_rejection_with_via_on_enum_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::rejection::ExtensionRejection,
3 | response::{IntoResponse, Response},
4 | routing::get,
5 | Router,
6 | };
7 | use axum_macros::FromRequestParts;
8 |
9 | fn main() {
10 | let _: Router = Router::new().route("/", get(handler).post(handler_result));
11 | }
12 |
13 | async fn handler(_: MyExtractor) {}
14 |
15 | async fn handler_result(_: Result) {}
16 |
17 | #[derive(FromRequestParts, Clone)]
18 | #[from_request(via(axum::Extension), rejection(MyRejection))]
19 | enum MyExtractor {}
20 |
21 | struct MyRejection {}
22 |
23 | impl From for MyRejection {
24 | fn from(_: ExtensionRejection) -> Self {
25 | todo!()
26 | }
27 | }
28 |
29 | impl IntoResponse for MyRejection {
30 | fn into_response(self) -> Response {
31 | todo!()
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/wrong_return_type.stderr:
--------------------------------------------------------------------------------
1 | error[E0277]: the trait bound `bool: IntoResponse` is not satisfied
2 | --> tests/debug_handler/fail/wrong_return_type.rs:4:23
3 | |
4 | 4 | async fn handler() -> bool {
5 | | ^^^^ the trait `IntoResponse` is not implemented for `bool`
6 | |
7 | = help: the following other types implement trait `IntoResponse`:
8 | &'static [u8; N]
9 | &'static [u8]
10 | &'static str
11 | ()
12 | (R,)
13 | (Response<()>, R)
14 | (Response<()>, T1, R)
15 | (Response<()>, T1, T2, R)
16 | and $N others
17 | note: required by a bound in `__axum_macros_check_handler_into_response::{closure#0}::check`
18 | --> tests/debug_handler/fail/wrong_return_type.rs:4:23
19 | |
20 | 4 | async fn handler() -> bool {
21 | | ^^^^ required by this bound in `check`
22 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_with_rejection.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::State,
3 | response::{IntoResponse, Response},
4 | routing::get,
5 | Router,
6 | };
7 | use axum_macros::FromRequest;
8 | use std::convert::Infallible;
9 |
10 | fn main() {
11 | let _: axum::Router = Router::new()
12 | .route("/a", get(|_: Extractor| async {}))
13 | .with_state(AppState::default());
14 | }
15 |
16 | #[derive(Clone, Default, FromRequest)]
17 | #[from_request(rejection(MyRejection))]
18 | struct Extractor {
19 | state: State,
20 | }
21 |
22 | #[derive(Clone, Default)]
23 | struct AppState {}
24 |
25 | struct MyRejection {}
26 |
27 | impl From for MyRejection {
28 | fn from(err: Infallible) -> Self {
29 | match err {}
30 | }
31 | }
32 |
33 | impl IntoResponse for MyRejection {
34 | fn into_response(self) -> Response {
35 | ().into_response()
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/axum-macros/tests/from_request/pass/state_enum_via_parts.rs:
--------------------------------------------------------------------------------
1 | use axum::{
2 | extract::{FromRef, State},
3 | routing::get,
4 | Router,
5 | };
6 | use axum_macros::FromRequestParts;
7 |
8 | fn main() {
9 | let _: axum::Router = Router::new()
10 | .route("/a", get(|_: AppState| async {}))
11 | .route("/b", get(|_: InnerState| async {}))
12 | .route("/c", get(|_: AppState, _: InnerState| async {}))
13 | .with_state(AppState::default());
14 | }
15 |
16 | #[derive(Clone, FromRequestParts)]
17 | #[from_request(via(State))]
18 | enum AppState {
19 | One,
20 | }
21 |
22 | impl Default for AppState {
23 | fn default() -> AppState {
24 | Self::One
25 | }
26 | }
27 |
28 | #[derive(FromRequestParts)]
29 | #[from_request(via(State), state(AppState))]
30 | enum InnerState {}
31 |
32 | impl FromRef for InnerState {
33 | fn from_ref(_: &AppState) -> Self {
34 | todo!("🤷")
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/axum-core/src/extract/from_ref.rs:
--------------------------------------------------------------------------------
1 | /// Used to do reference-to-value conversions thus not consuming the input value.
2 | ///
3 | /// This is mainly used with [`State`] to extract "substates" from a reference to main application
4 | /// state.
5 | ///
6 | /// See [`State`] for more details on how library authors should use this trait.
7 | ///
8 | /// This trait can be derived using `#[derive(FromRef)]`.
9 | ///
10 | /// [`State`]: https://docs.rs/axum/0.8/axum/extract/struct.State.html
11 | // NOTE: This trait is defined in axum-core, even though it is mainly used with `State` which is
12 | // defined in axum. That allows crate authors to use it when implementing extractors.
13 | pub trait FromRef {
14 | /// Converts to this type from a reference to the input type.
15 | fn from_ref(input: &T) -> Self;
16 | }
17 |
18 | impl FromRef for T
19 | where
20 | T: Clone,
21 | {
22 | fn from_ref(input: &T) -> Self {
23 | input.clone()
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/axum-macros/tests/debug_handler/fail/not_send.stderr:
--------------------------------------------------------------------------------
1 | error: future cannot be sent between threads safely
2 | --> tests/debug_handler/fail/not_send.rs:3:1
3 | |
4 | 3 | #[debug_handler]
5 | | ^^^^^^^^^^^^^^^^ future returned by `handler` is not `Send`
6 | |
7 | = help: within `impl Future