add AppState derive macro for convenient state extraction

crates/axum-app-wrapper-macros/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "axum-app-wrapper-macros"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "2"
+quote = "1"
+proc-macro2 = "1"

crates/axum-app-wrapper-macros/src/lib.rs

@@ -0,0 +1,71 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{Data, DeriveInput, Fields, parse_macro_input};
+
+/// Derive macro that implements [`TryFrom<TypeMap>`] for `T`.
+///
+/// Apply this to your state struct and each named field will be extracted from the
+/// [`TypeMap`] by type automatically. Keep in mind each field must be of a
+/// different type — if you need to store multiple values of the same type, use
+/// a wrapper like `struct Foo(type)` or `enum Foo { A(type), B(type) }`.
+///
+/// How the state is stored and cloned is up to you —
+/// if you want cheap clones, wrap your fields in `Arc` individually or use
+/// `Arc<AppState>` as your axum state type.
+///
+/// ```ignore
+/// #[derive(AppState)]
+/// struct AppState {
+///     config: Config,
+///     pool: Pool,
+///     db: Db,
+/// }
+///
+/// // Plain state — axum will clone the whole struct on each request:
+/// App::<AppState>::new()
+///
+/// // Or wrap in Arc yourself for cheap clones:
+/// App::<Arc<AppState>>::new()
+/// ```
+#[proc_macro_derive(AppState)]
+pub fn derive_app_state(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let fields = match &input.data {
+        Data::Struct(s) => match &s.fields {
+            Fields::Named(f) => &f.named,
+            _ => {
+                return syn::Error::new_spanned(
+                    name,
+                    "#[derive(AppState)] only supports structs with named fields",
+                )
+                .to_compile_error()
+                .into();
+            }
+        },
+        _ => {
+            return syn::Error::new_spanned(
+                name,
+                "#[derive(AppState)] can only be applied to structs",
+            )
+            .to_compile_error()
+            .into();
+        }
+    };
+
+    let field_names = fields.iter().map(|f| &f.ident);
+
+    quote! {
+        impl ::std::convert::TryFrom<::axum_app_wrapper::TypeMap> for #name {
+            type Error = ::anyhow::Error;
+
+            fn try_from(mut map: ::axum_app_wrapper::TypeMap) -> ::std::result::Result<Self, Self::Error> {
+                Ok(#name {
+                    #(#field_names: ::axum_app_wrapper::extract_type_field(&mut map)?,)*
+                })
+            }
+        }
+    }
+    .into()
+}