Easily convert typed paths into URIs

axum-extra/src/routing/typed.rs

@@ -87,6 +87,8 @@ use super::sealed::Sealed;
 /// things, create links to known paths and have them verified statically. Note that the
 /// [`Display`] implementation for each field must return something that's compatible with its
 /// [`Deserialize`] implementation.
+/// - A [`TryFrom<_> for Uri`](std::convert::TryFrom) implementation to converting your paths into
+/// [`Uri`](axum::http::Uri).
 ///
 /// Additionally the macro will verify the captures in the path matches the fields of the struct.
 /// For example this fails to compile since the struct doesn't have a `team_id` field:

axum-macros/CHANGELOG.md

@@ -7,7 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 # Unreleased
 
-- Add `#[derive(TypedPath)]` for use with axum-extra's new "type safe" routing API ([#756])
+- **added:** Add `#[derive(TypedPath)]` for use with axum-extra's new "type safe" routing API ([#756])
+- **added:** `#[derive(TypedPath)]` now also generates a `TryFrom<_> for Uri`
+  implementation ([#790])
+
+[#790]: https://github.com/tokio-rs/axum/pull/790
 
 # 0.1.0 (31. January, 2022)
 

axum-macros/src/typed_path.rs

@@ -20,17 +20,29 @@ pub(crate) fn expand(item_struct: ItemStruct) -> syn::Result<TokenStream> {
 
     let Attrs { path } = parse_attrs(attrs)?;
 
-    match fields {
+    let code = match fields {
         syn::Fields::Named(_) => {
             let segments = parse_path(&path)?;
-            Ok(expand_named_fields(ident, path, &segments))
+            expand_named_fields(ident, path, &segments)
         }
         syn::Fields::Unnamed(fields) => {
             let segments = parse_path(&path)?;
-            expand_unnamed_fields(fields, ident, path, &segments)
+            expand_unnamed_fields(fields, ident, path, &segments)?
         }
-        syn::Fields::Unit => Ok(expand_unit_fields(ident, path)?),
-    }
+        syn::Fields::Unit => expand_unit_fields(ident, path)?,
+    };
+
+    Ok(quote! {
+        #code
+
+        impl ::std::convert::TryFrom<#ident> for ::axum::http::Uri {
+            type Error = ::axum::http::uri::InvalidUri;
+
+            fn try_from(value: #ident) -> ::std::result::Result<Self, Self::Error> {
+                value.to_string().parse()
+            }
+        }
+    })
 }
 
 struct Attrs {

axum-macros/tests/typed_path/pass/try_into_uri.rs

@@ -0,0 +1,24 @@
+use axum_extra::routing::TypedPath;
+use axum::http::Uri;
+use serde::Deserialize;
+use std::convert::TryInto;
+
+#[derive(TypedPath, Deserialize)]
+#[typed_path("/:id")]
+struct Named {
+    id: u32,
+}
+
+#[derive(TypedPath, Deserialize)]
+#[typed_path("/:id")]
+struct Unnamed(u32);
+
+#[derive(TypedPath, Deserialize)]
+#[typed_path("/")]
+struct Unit;
+
+fn main() {
+    let _: Uri = Named { id: 1 }.try_into().unwrap();
+    let _: Uri = Unnamed(1).try_into().unwrap();
+    let _: Uri = Unit.try_into().unwrap();
+}