Vendor dependencies

notes-service/vendor/axum-macros/tests/from_request/pass/container.rs

@@ -0,0 +1,21 @@
+use axum::{
+    extract::{FromRequest, Json},
+    response::Response,
+};
+use serde::Deserialize;
+
+#[derive(Deserialize, FromRequest)]
+#[from_request(via(Json))]
+struct Extractor {
+    one: i32,
+    two: String,
+    three: bool,
+}
+
+fn assert_from_request()
+where
+    Extractor: FromRequest<(), Rejection = Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/container_parts.rs

@@ -0,0 +1,20 @@
+use axum::{
+    extract::{Extension, FromRequestParts},
+    response::Response,
+};
+
+#[derive(Clone, FromRequestParts)]
+#[from_request(via(Extension))]
+struct Extractor {
+    one: i32,
+    two: String,
+    three: bool,
+}
+
+fn assert_from_request()
+where
+    Extractor: FromRequestParts<(), Rejection = Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/empty_named.rs

@@ -0,0 +1,12 @@
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<(), Rejection = std::convert::Infallible>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/empty_named_parts.rs

@@ -0,0 +1,12 @@
+use axum_macros::FromRequestParts;
+
+#[derive(FromRequestParts)]
+struct Extractor {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequestParts<(), Rejection = std::convert::Infallible>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/empty_tuple.rs

@@ -0,0 +1,12 @@
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor();
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<(), Rejection = std::convert::Infallible>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/empty_tuple_parts.rs

@@ -0,0 +1,12 @@
+use axum_macros::FromRequestParts;
+
+#[derive(FromRequestParts)]
+struct Extractor();
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequestParts<(), Rejection = std::convert::Infallible>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/enum_via.rs

@@ -0,0 +1,12 @@
+use axum::{routing::get, Extension, Router};
+use axum_macros::FromRequest;
+
+#[derive(FromRequest, Clone)]
+#[from_request(via(Extension))]
+enum Extractor {}
+
+async fn foo(_: Extractor) {}
+
+fn main() {
+    _ = Router::<()>::new().route("/", get(foo));
+}

notes-service/vendor/axum-macros/tests/from_request/pass/enum_via_parts.rs

@@ -0,0 +1,12 @@
+use axum::{routing::get, Extension, Router};
+use axum_macros::FromRequestParts;
+
+#[derive(FromRequestParts, Clone)]
+#[from_request(via(Extension))]
+enum Extractor {}
+
+async fn foo(_: Extractor) {}
+
+fn main() {
+    _ = Router::<()>::new().route("/", get(foo));
+}

notes-service/vendor/axum-macros/tests/from_request/pass/named.rs

@@ -0,0 +1,24 @@
+use axum::{extract::FromRequest, response::Response};
+use axum_extra::{
+    headers::{self, UserAgent},
+    typed_header::TypedHeaderRejection,
+    TypedHeader,
+};
+
+#[derive(FromRequest)]
+struct Extractor {
+    uri: axum::http::Uri,
+    user_agent: TypedHeader<UserAgent>,
+    content_type: TypedHeader<headers::ContentType>,
+    etag: Option<TypedHeader<headers::ETag>>,
+    host: Result<TypedHeader<headers::Host>, TypedHeaderRejection>,
+    body: String,
+}
+
+fn assert_from_request()
+where
+    Extractor: FromRequest<(), Rejection = Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/named_parts.rs

@@ -0,0 +1,23 @@
+use axum::{extract::FromRequestParts, response::Response};
+use axum_extra::{
+    headers::{self, UserAgent},
+    typed_header::TypedHeaderRejection,
+    TypedHeader,
+};
+
+#[derive(FromRequestParts)]
+struct Extractor {
+    uri: axum::http::Uri,
+    user_agent: TypedHeader<UserAgent>,
+    content_type: TypedHeader<headers::ContentType>,
+    etag: Option<TypedHeader<headers::ETag>>,
+    host: Result<TypedHeader<headers::Host>, TypedHeaderRejection>,
+}
+
+fn assert_from_request()
+where
+    Extractor: FromRequestParts<(), Rejection = Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/named_via.rs

@@ -0,0 +1,34 @@
+use axum::{
+    extract::{Extension, FromRequest},
+    response::Response,
+};
+use axum_extra::{
+    headers::{self, UserAgent},
+    typed_header::TypedHeaderRejection,
+    TypedHeader,
+};
+
+#[derive(FromRequest)]
+struct Extractor {
+    #[from_request(via(Extension))]
+    state: State,
+    #[from_request(via(TypedHeader))]
+    user_agent: UserAgent,
+    #[from_request(via(TypedHeader))]
+    content_type: headers::ContentType,
+    #[from_request(via(TypedHeader))]
+    etag: Option<headers::ETag>,
+    #[from_request(via(TypedHeader))]
+    host: Result<headers::Host, TypedHeaderRejection>,
+}
+
+fn assert_from_request()
+where
+    Extractor: FromRequest<(), Rejection = Response>,
+{
+}
+
+#[derive(Clone)]
+struct State;
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/named_via_parts.rs

@@ -0,0 +1,34 @@
+use axum::{
+    extract::{Extension, FromRequestParts},
+    response::Response,
+};
+use axum_extra::{
+    headers::{self, UserAgent},
+    typed_header::TypedHeaderRejection,
+    TypedHeader,
+};
+
+#[derive(FromRequestParts)]
+struct Extractor {
+    #[from_request(via(Extension))]
+    state: State,
+    #[from_request(via(TypedHeader))]
+    user_agent: UserAgent,
+    #[from_request(via(TypedHeader))]
+    content_type: headers::ContentType,
+    #[from_request(via(TypedHeader))]
+    etag: Option<headers::ETag>,
+    #[from_request(via(TypedHeader))]
+    host: Result<headers::Host, TypedHeaderRejection>,
+}
+
+fn assert_from_request()
+where
+    Extractor: FromRequestParts<(), Rejection = Response>,
+{
+}
+
+#[derive(Clone)]
+struct State;
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/override_rejection.rs

@@ -0,0 +1,58 @@
+use axum::{
+    extract::{rejection::ExtensionRejection, FromRequest, Request},
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    routing::get,
+    Extension, Router,
+};
+
+fn main() {
+    let _: Router = Router::new().route("/", get(handler).post(handler_result));
+}
+
+async fn handler(_: MyExtractor) {}
+
+async fn handler_result(_: Result<MyExtractor, MyRejection>) {}
+
+#[derive(FromRequest)]
+#[from_request(rejection(MyRejection))]
+struct MyExtractor {
+    one: Extension<String>,
+    #[from_request(via(Extension))]
+    two: String,
+    three: OtherExtractor,
+}
+
+struct OtherExtractor;
+
+impl<S> FromRequest<S> for OtherExtractor
+where
+    S: Send + Sync,
+{
+    // this rejection doesn't implement `Display` and `Error`
+    type Rejection = (StatusCode, String);
+
+    async fn from_request(_req: Request, _state: &S) -> Result<Self, Self::Rejection> {
+        todo!()
+    }
+}
+
+struct MyRejection {}
+
+impl From<ExtensionRejection> for MyRejection {
+    fn from(_: ExtensionRejection) -> Self {
+        todo!()
+    }
+}
+
+impl From<(StatusCode, String)> for MyRejection {
+    fn from(_: (StatusCode, String)) -> Self {
+        todo!()
+    }
+}
+
+impl IntoResponse for MyRejection {
+    fn into_response(self) -> Response {
+        todo!()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/override_rejection_non_generic.rs

@@ -0,0 +1,36 @@
+use axum::{
+    extract::rejection::JsonRejection,
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequest;
+use serde::Deserialize;
+use std::collections::HashMap;
+
+fn main() {
+    let _: Router = Router::new().route("/", get(handler).post(handler_result));
+}
+
+async fn handler(_: MyJson) {}
+
+async fn handler_result(_: Result<MyJson, MyJsonRejection>) {}
+
+#[derive(FromRequest, Deserialize)]
+#[from_request(via(axum::extract::Json), rejection(MyJsonRejection))]
+#[serde(transparent)]
+struct MyJson(HashMap<String, String>);
+
+struct MyJsonRejection {}
+
+impl From<JsonRejection> for MyJsonRejection {
+    fn from(_: JsonRejection) -> Self {
+        todo!()
+    }
+}
+
+impl IntoResponse for MyJsonRejection {
+    fn into_response(self) -> Response {
+        todo!()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/override_rejection_non_generic_parts.rs

@@ -0,0 +1,36 @@
+use axum::{
+    extract::rejection::QueryRejection,
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequestParts;
+use serde::Deserialize;
+use std::collections::HashMap;
+
+fn main() {
+    let _: Router = Router::new().route("/", get(handler).post(handler_result));
+}
+
+async fn handler(_: MyQuery) {}
+
+async fn handler_result(_: Result<MyQuery, MyQueryRejection>) {}
+
+#[derive(FromRequestParts, Deserialize)]
+#[from_request(via(axum::extract::Query), rejection(MyQueryRejection))]
+#[serde(transparent)]
+struct MyQuery(HashMap<String, String>);
+
+struct MyQueryRejection {}
+
+impl From<QueryRejection> for MyQueryRejection {
+    fn from(_: QueryRejection) -> Self {
+        todo!()
+    }
+}
+
+impl IntoResponse for MyQueryRejection {
+    fn into_response(self) -> Response {
+        todo!()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/override_rejection_parts.rs

@@ -0,0 +1,58 @@
+use axum::{
+    extract::{rejection::ExtensionRejection, FromRequestParts},
+    http::{request::Parts, StatusCode},
+    response::{IntoResponse, Response},
+    routing::get,
+    Extension, Router,
+};
+
+fn main() {
+    let _: Router = Router::new().route("/", get(handler).post(handler_result));
+}
+
+async fn handler(_: MyExtractor) {}
+
+async fn handler_result(_: Result<MyExtractor, MyRejection>) {}
+
+#[derive(FromRequestParts)]
+#[from_request(rejection(MyRejection))]
+struct MyExtractor {
+    one: Extension<String>,
+    #[from_request(via(Extension))]
+    two: String,
+    three: OtherExtractor,
+}
+
+struct OtherExtractor;
+
+impl<S> FromRequestParts<S> for OtherExtractor
+where
+    S: Send + Sync,
+{
+    // this rejection doesn't implement `Display` and `Error`
+    type Rejection = (StatusCode, String);
+
+    async fn from_request_parts(_parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
+        todo!()
+    }
+}
+
+struct MyRejection {}
+
+impl From<ExtensionRejection> for MyRejection {
+    fn from(_: ExtensionRejection) -> Self {
+        todo!()
+    }
+}
+
+impl From<(StatusCode, String)> for MyRejection {
+    fn from(_: (StatusCode, String)) -> Self {
+        todo!()
+    }
+}
+
+impl IntoResponse for MyRejection {
+    fn into_response(self) -> Response {
+        todo!()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/override_rejection_with_via_on_enum.rs

@@ -0,0 +1,33 @@
+use axum::{
+    extract::rejection::ExtensionRejection,
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequest;
+
+fn main() {
+    let _: Router = Router::new().route("/", get(handler).post(handler_result));
+}
+
+async fn handler(_: MyExtractor) {}
+
+async fn handler_result(_: Result<MyExtractor, MyRejection>) {}
+
+#[derive(FromRequest, Clone)]
+#[from_request(via(axum::Extension), rejection(MyRejection))]
+enum MyExtractor {}
+
+struct MyRejection {}
+
+impl From<ExtensionRejection> for MyRejection {
+    fn from(_: ExtensionRejection) -> Self {
+        todo!()
+    }
+}
+
+impl IntoResponse for MyRejection {
+    fn into_response(self) -> Response {
+        todo!()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/override_rejection_with_via_on_enum_parts.rs

@@ -0,0 +1,33 @@
+use axum::{
+    extract::rejection::ExtensionRejection,
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequestParts;
+
+fn main() {
+    let _: Router = Router::new().route("/", get(handler).post(handler_result));
+}
+
+async fn handler(_: MyExtractor) {}
+
+async fn handler_result(_: Result<MyExtractor, MyRejection>) {}
+
+#[derive(FromRequestParts, Clone)]
+#[from_request(via(axum::Extension), rejection(MyRejection))]
+enum MyExtractor {}
+
+struct MyRejection {}
+
+impl From<ExtensionRejection> for MyRejection {
+    fn from(_: ExtensionRejection) -> Self {
+        todo!()
+    }
+}
+
+impl IntoResponse for MyRejection {
+    fn into_response(self) -> Response {
+        todo!()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/override_rejection_with_via_on_struct.rs

@@ -0,0 +1,37 @@
+use axum::{
+    extract::rejection::JsonRejection,
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequest;
+use serde::Deserialize;
+
+fn main() {
+    let _: Router = Router::new().route("/", get(handler).post(handler_result));
+}
+
+#[derive(Deserialize)]
+struct Payload {}
+
+async fn handler(_: MyJson<Payload>) {}
+
+async fn handler_result(_: Result<MyJson<Payload>, MyJsonRejection>) {}
+
+#[derive(FromRequest)]
+#[from_request(via(axum::Json), rejection(MyJsonRejection))]
+struct MyJson<T>(T);
+
+struct MyJsonRejection {}
+
+impl From<JsonRejection> for MyJsonRejection {
+    fn from(_: JsonRejection) -> Self {
+        todo!()
+    }
+}
+
+impl IntoResponse for MyJsonRejection {
+    fn into_response(self) -> Response {
+        todo!()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/override_rejection_with_via_on_struct_parts.rs

@@ -0,0 +1,37 @@
+use axum::{
+    extract::rejection::QueryRejection,
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequestParts;
+use serde::Deserialize;
+
+fn main() {
+    let _: Router = Router::new().route("/", get(handler).post(handler_result));
+}
+
+#[derive(Deserialize)]
+struct Payload {}
+
+async fn handler(_: MyQuery<Payload>) {}
+
+async fn handler_result(_: Result<MyQuery<Payload>, MyQueryRejection>) {}
+
+#[derive(FromRequestParts)]
+#[from_request(via(axum::extract::Query), rejection(MyQueryRejection))]
+struct MyQuery<T>(T);
+
+struct MyQueryRejection {}
+
+impl From<QueryRejection> for MyQueryRejection {
+    fn from(_: QueryRejection) -> Self {
+        todo!()
+    }
+}
+
+impl IntoResponse for MyQueryRejection {
+    fn into_response(self) -> Response {
+        todo!()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/state_cookie.rs

@@ -0,0 +1,27 @@
+use axum::extract::FromRef;
+use axum_extra::extract::cookie::{Key, PrivateCookieJar};
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+#[from_request(state(AppState))]
+struct Extractor {
+    cookies: PrivateCookieJar,
+}
+
+struct AppState {
+    key: Key,
+}
+
+impl FromRef<AppState> for Key {
+    fn from_ref(input: &AppState) -> Self {
+        input.key.clone()
+    }
+}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<AppState, Rejection = axum::response::Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/state_enum_via.rs

@@ -0,0 +1,35 @@
+use axum::{
+    extract::{FromRef, State},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequest;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/a", get(|_: AppState| async {}))
+        .route("/b", get(|_: InnerState| async {}))
+        .with_state(AppState::default());
+}
+
+#[derive(Clone, FromRequest)]
+#[from_request(via(State))]
+enum AppState {
+    One,
+}
+
+impl Default for AppState {
+    fn default() -> AppState {
+        Self::One
+    }
+}
+
+#[derive(FromRequest)]
+#[from_request(via(State), state(AppState))]
+enum InnerState {}
+
+impl FromRef<AppState> for InnerState {
+    fn from_ref(_: &AppState) -> Self {
+        todo!("🤷")
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/state_enum_via_parts.rs

@@ -0,0 +1,36 @@
+use axum::{
+    extract::{FromRef, State},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequestParts;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/a", get(|_: AppState| async {}))
+        .route("/b", get(|_: InnerState| async {}))
+        .route("/c", get(|_: AppState, _: InnerState| async {}))
+        .with_state(AppState::default());
+}
+
+#[derive(Clone, FromRequestParts)]
+#[from_request(via(State))]
+enum AppState {
+    One,
+}
+
+impl Default for AppState {
+    fn default() -> AppState {
+        Self::One
+    }
+}
+
+#[derive(FromRequestParts)]
+#[from_request(via(State), state(AppState))]
+enum InnerState {}
+
+impl FromRef<AppState> for InnerState {
+    fn from_ref(_: &AppState) -> Self {
+        todo!("🤷")
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/state_explicit.rs

@@ -0,0 +1,45 @@
+use axum::{
+    extract::{FromRef, State},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequest;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/b", get(|_: Extractor| async {}))
+        .with_state(AppState::default());
+}
+
+#[derive(FromRequest)]
+#[from_request(state(AppState))]
+struct Extractor {
+    app_state: State<AppState>,
+    one: State<One>,
+    two: State<Two>,
+    other_extractor: String,
+}
+
+#[derive(Clone, Default)]
+struct AppState {
+    one: One,
+    two: Two,
+}
+
+#[derive(Clone, Default)]
+struct One {}
+
+impl FromRef<AppState> for One {
+    fn from_ref(input: &AppState) -> Self {
+        input.one.clone()
+    }
+}
+
+#[derive(Clone, Default)]
+struct Two {}
+
+impl FromRef<AppState> for Two {
+    fn from_ref(input: &AppState) -> Self {
+        input.two.clone()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/state_explicit_parts.rs

@@ -0,0 +1,34 @@
+use axum::{
+    extract::{FromRef, Query, State},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequestParts;
+use std::collections::HashMap;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/b", get(|_: Extractor| async {}))
+        .with_state(AppState::default());
+}
+
+#[derive(FromRequestParts)]
+#[from_request(state(AppState))]
+struct Extractor {
+    inner_state: State<InnerState>,
+    other: Query<HashMap<String, String>>,
+}
+
+#[derive(Default, Clone)]
+struct AppState {
+    inner: InnerState,
+}
+
+#[derive(Clone, Default)]
+struct InnerState {}
+
+impl FromRef<AppState> for InnerState {
+    fn from_ref(input: &AppState) -> Self {
+        input.inner.clone()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/state_field_explicit.rs

@@ -0,0 +1,35 @@
+use axum::{
+    extract::{FromRef, State},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequest;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/", get(|_: Extractor| async {}))
+        .with_state(AppState::default());
+}
+
+#[derive(FromRequest)]
+#[from_request(state(AppState))]
+struct Extractor {
+    #[from_request(via(State))]
+    state: AppState,
+    #[from_request(via(State))]
+    inner: InnerState,
+}
+
+#[derive(Clone, Default)]
+struct AppState {
+    inner: InnerState,
+}
+
+#[derive(Clone, Default)]
+struct InnerState {}
+
+impl FromRef<AppState> for InnerState {
+    fn from_ref(input: &AppState) -> Self {
+        input.inner.clone()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/state_field_infer.rs

@@ -0,0 +1,17 @@
+use axum::{extract::State, routing::get, Router};
+use axum_macros::FromRequest;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/", get(|_: Extractor| async {}))
+        .with_state(AppState::default());
+}
+
+#[derive(FromRequest)]
+struct Extractor {
+    #[from_request(via(State))]
+    state: AppState,
+}
+
+#[derive(Clone, Default)]
+struct AppState {}

notes-service/vendor/axum-macros/tests/from_request/pass/state_infer.rs

@@ -0,0 +1,18 @@
+use axum::extract::State;
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor {
+    inner_state: State<AppState>,
+}
+
+#[derive(Clone)]
+struct AppState {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<AppState, Rejection = axum::response::Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/state_infer_multiple.rs

@@ -0,0 +1,19 @@
+use axum::extract::State;
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor {
+    inner_state: State<AppState>,
+    also_inner_state: State<AppState>,
+}
+
+#[derive(Clone)]
+struct AppState {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<AppState, Rejection = axum::response::Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/state_infer_parts.rs

@@ -0,0 +1,18 @@
+use axum::extract::State;
+use axum_macros::FromRequestParts;
+
+#[derive(FromRequestParts)]
+struct Extractor {
+    inner_state: State<AppState>,
+}
+
+#[derive(Clone)]
+struct AppState {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequestParts<AppState, Rejection = axum::response::Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/state_via.rs

@@ -0,0 +1,29 @@
+use axum::{
+    extract::{FromRef, State},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequest;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/b", get(|_: (), _: AppState| async {}))
+        .route("/c", get(|_: (), _: InnerState| async {}))
+        .with_state(AppState::default());
+}
+
+#[derive(Clone, Default, FromRequest)]
+#[from_request(via(State), state(AppState))]
+struct AppState {
+    inner: InnerState,
+}
+
+#[derive(Clone, Default, FromRequest)]
+#[from_request(via(State), state(AppState))]
+struct InnerState {}
+
+impl FromRef<AppState> for InnerState {
+    fn from_ref(input: &AppState) -> Self {
+        input.inner.clone()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/state_via_infer.rs

@@ -0,0 +1,14 @@
+use axum::{extract::State, routing::get, Router};
+use axum_macros::FromRequest;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/b", get(|_: AppState| async {}))
+        .with_state(AppState::default());
+}
+
+// if we're extract "via" `State<AppState>` and not specifying state
+// assume `AppState` is the state
+#[derive(Clone, Default, FromRequest)]
+#[from_request(via(State))]
+struct AppState {}

notes-service/vendor/axum-macros/tests/from_request/pass/state_via_parts.rs

@@ -0,0 +1,30 @@
+use axum::{
+    extract::{FromRef, State},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequestParts;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/a", get(|_: AppState, _: InnerState, _: String| async {}))
+        .route("/b", get(|_: AppState, _: String| async {}))
+        .route("/c", get(|_: InnerState, _: String| async {}))
+        .with_state(AppState::default());
+}
+
+#[derive(Clone, Default, FromRequestParts)]
+#[from_request(via(State))]
+struct AppState {
+    inner: InnerState,
+}
+
+#[derive(Clone, Default, FromRequestParts)]
+#[from_request(via(State), state(AppState))]
+struct InnerState {}
+
+impl FromRef<AppState> for InnerState {
+    fn from_ref(input: &AppState) -> Self {
+        input.inner.clone()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/state_with_rejection.rs

@@ -0,0 +1,37 @@
+use axum::{
+    extract::State,
+    response::{IntoResponse, Response},
+    routing::get,
+    Router,
+};
+use axum_macros::FromRequest;
+use std::convert::Infallible;
+
+fn main() {
+    let _: axum::Router = Router::new()
+        .route("/a", get(|_: Extractor| async {}))
+        .with_state(AppState::default());
+}
+
+#[derive(Clone, Default, FromRequest)]
+#[from_request(rejection(MyRejection))]
+struct Extractor {
+    state: State<AppState>,
+}
+
+#[derive(Clone, Default)]
+struct AppState {}
+
+struct MyRejection {}
+
+impl From<Infallible> for MyRejection {
+    fn from(err: Infallible) -> Self {
+        match err {}
+    }
+}
+
+impl IntoResponse for MyRejection {
+    fn into_response(self) -> Response {
+        ().into_response()
+    }
+}

notes-service/vendor/axum-macros/tests/from_request/pass/tuple.rs

@@ -0,0 +1,12 @@
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor(axum::http::HeaderMap, String);
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<()>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/tuple_parts.rs

@@ -0,0 +1,12 @@
+use axum_macros::FromRequestParts;
+
+#[derive(FromRequestParts)]
+struct Extractor(axum::http::HeaderMap, axum::http::Method);
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequestParts<()>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/tuple_same_type_twice.rs

@@ -0,0 +1,17 @@
+use axum::extract::Query;
+use axum_macros::FromRequest;
+use serde::Deserialize;
+
+#[derive(FromRequest)]
+struct Extractor(Query<Payload>, axum::extract::Json<Payload>);
+
+#[derive(Deserialize)]
+struct Payload {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<()>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/tuple_same_type_twice_parts.rs

@@ -0,0 +1,17 @@
+use axum::extract::Query;
+use axum_macros::FromRequestParts;
+use serde::Deserialize;
+
+#[derive(FromRequestParts)]
+struct Extractor(Query<Payload>, axum::extract::Path<Payload>);
+
+#[derive(Deserialize)]
+struct Payload {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequestParts<()>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/tuple_same_type_twice_via.rs

@@ -0,0 +1,21 @@
+use axum::extract::Query;
+use axum::response::Response;
+use axum_macros::FromRequest;
+use serde::Deserialize;
+
+#[derive(FromRequest)]
+struct Extractor(
+    #[from_request(via(Query))] Payload,
+    #[from_request(via(axum::extract::Json))] Payload,
+);
+
+#[derive(Deserialize)]
+struct Payload {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<(), Rejection = Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/tuple_same_type_twice_via_parts.rs

@@ -0,0 +1,21 @@
+use axum::extract::Query;
+use axum::response::Response;
+use axum_macros::FromRequestParts;
+use serde::Deserialize;
+
+#[derive(FromRequestParts)]
+struct Extractor(
+    #[from_request(via(Query))] Payload,
+    #[from_request(via(axum::extract::Path))] Payload,
+);
+
+#[derive(Deserialize)]
+struct Payload {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequestParts<(), Rejection = Response>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/tuple_via.rs

@@ -0,0 +1,16 @@
+use axum::Extension;
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor(#[from_request(via(Extension))] State);
+
+#[derive(Clone)]
+struct State;
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<()>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/tuple_via_parts.rs

@@ -0,0 +1,16 @@
+use axum::Extension;
+use axum_macros::FromRequestParts;
+
+#[derive(FromRequestParts)]
+struct Extractor(#[from_request(via(Extension))] State);
+
+#[derive(Clone)]
+struct State;
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequestParts<()>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/unit.rs

@@ -0,0 +1,12 @@
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor;
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<(), Rejection = std::convert::Infallible>,
+{
+}
+
+fn main() {}

notes-service/vendor/axum-macros/tests/from_request/pass/unit_parts.rs

@@ -0,0 +1,12 @@
+use axum_macros::FromRequestParts;
+
+#[derive(FromRequestParts)]
+struct Extractor;
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequestParts<(), Rejection = std::convert::Infallible>,
+{
+}
+
+fn main() {}