Router, Add wellknow, fix compile errors

router/src/lib.rs

@@ -7,20 +7,27 @@ use tokio::net::TcpListener;
 pub mod xrpc;
 pub mod wellknown;
 
+pub enum Error {}
+
 pub struct Router {
   addr: SocketAddr,
   router: AxumRouter,
 }
+impl Default for Router {
+  fn default() -> Self {
+    Self::new()
+  }
+}
 impl Router {
   pub fn new() -> Self {
     let mut router = AxumRouter::new();
-    // TODO: Only add if there is at least on XRPC endpoint
+    // TODO: Only add if there is at least one XRPC endpoint
     router = XrpcEndpoint::not_implemented().add_to_router(router);
     let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127,0,0,1)), 6702);
     Router { router, addr }
   }
 
-  pub fn add_endpoint(mut self, endpoint: Endpoint) -> Self {
+  pub fn add_endpoint<E: Endpoint>(mut self, endpoint: E) -> Self {
     self.router = endpoint.add_to_router(self.router);
     self
   }

router/src/wellknown.rs

@@ -4,64 +4,16 @@ use axum::{
   Router as axumRouter,
 };
 
+pub mod atproto;
+pub mod oauth;
+
 trait WellKnownEndpoint {
   fn get_known_route(&self) -> String;
   fn get_resolver(self) -> MethodRouter;
 }
 
-impl Endpoint for WellKnownEndpoint {
+impl<WK: WellKnownEndpoint> Endpoint for WK {
   fn add_to_router(self, router: axumRouter) -> axumRouter {
-    router.route(".well-known/" + self.get_known_route(), self.get_resolver())
-  }
-}
-
-pub mod atproto {
-  pub mod handle_resolution {
-    use crate::wellknown::WellKnownEndpoint;
-    use axum::{
-      routing::method_routing::MethodRouter,
-      response::Response,
-      http::{StatusCode, HeaderMap},
-    };
-
-    pub struct HandleResolutionEndpoint {
-      resolver: MethodRouter,
-    }
-
-    impl HandleResolutionEndpoint {
-      pub fn new<F>(handle_resolver: F) -> self where
-      F: Fn(atproto::types::Handle) -> Result<Option<atproto::types::Did>>
-      {
-        HandleResolutionEndpoint {
-          resolver: get(async move | headers: HeaderMap | -> Response {
-            match headers
-                .get("host")
-                .map(|s| s.parse::<atproto::types::Handle>())
-                .map(handle_resolver) {
-              Ok(maybe_did) => match maybe_did {
-                Some(did) => (StatusCode::OK, did),
-                None => (StatusCode::NOT_FOUND, "User not found")
-              },
-              Err(_) => 
-                (StatusCode::INTERNAL_SERVER_ERROR, "Internal Server Error"),
-            }
-          })
-        }
-      }
-    }
-
-    impl WellKnownEndpoint for HandleResolutionEndpoint {
-      fn get_known_route(&self) -> String { String::from("atproto-did") }
-
-      fn get_resolver(self) -> MethodRouter {
-        return self.resolver;
-      }
-    }
-  }
-}
-
-pub mod oauth {
-  mod protected_resource {}
-  pub mod authorization_server {
+    router.route(&format!(".well-known/{}", self.get_known_route()), self.get_resolver())
   }
 }

router/src/wellknown/atproto.rs

@@ -0,0 +1 @@
+pub mod handle_resolution;

router/src/wellknown/atproto/handle_resolution.rs

@@ -0,0 +1,52 @@
+use crate::{
+  wellknown::WellKnownEndpoint,
+  Error,
+};
+use atproto::types::{Handle, Did};
+use axum::{
+  routing::{
+    method_routing::MethodRouter,
+    get,
+  },
+  http::{
+    StatusCode,
+    HeaderMap,
+  },
+};
+
+pub struct HandleResolutionEndpoint {
+  resolver: MethodRouter,
+}
+
+impl HandleResolutionEndpoint {
+  pub fn new<HR>(handle_resolver: HR) -> Self where
+  HR: HandleResolver + Clone
+  {
+    HandleResolutionEndpoint {
+      resolver: get(async move | headers: HeaderMap | -> (StatusCode, String) {
+        let Some(Ok(hostname)) = headers.get("host").map(|header_value| {
+          header_value.to_str()
+        }) else {
+          return (StatusCode::INTERNAL_SERVER_ERROR, String::from("Internal Server Error"));
+        };
+        let Ok(valid_handle) = hostname.parse::<atproto::types::Handle>() else {
+          return (StatusCode::NOT_FOUND, String::from("User not found"));
+        };
+        match handle_resolver.call(valid_handle) {
+          Ok(Some(did)) => (StatusCode::OK, did.to_string()),
+          Ok(None) => (StatusCode::NOT_FOUND, String::from("User not found")),
+          Err(_) => (StatusCode::INTERNAL_SERVER_ERROR, String::from("Internal Server Error")),
+        }
+      })
+    }
+  }
+}
+
+pub trait HandleResolver: Send + Sync + 'static {
+  fn call(&self, handle: Handle) -> Result<Option<Did>, Error>;
+}
+
+impl WellKnownEndpoint for HandleResolutionEndpoint {
+  fn get_known_route(&self) -> String { String::from("atproto-did") }
+  fn get_resolver(self) -> MethodRouter { self.resolver }
+}

router/src/wellknown/oauth.rs

@@ -0,0 +1 @@
+pub mod authorization_server;

router/src/wellknown/oauth/authorization_server.rs

@@ -0,0 +1,2 @@
+
+

router/src/xrpc.rs

@@ -174,7 +174,7 @@ impl XrpcEndpoint {
 impl Endpoint for XrpcEndpoint {
   fn add_to_router(self, router: axumRouter) -> axumRouter {
     let path = match self.path {
-      Path::Nsid(nsid) => &("/xrpc/".to_owned() + nsid.as_str()),
+      Path::Nsid(nsid) => &("/xrpc/".to_owned() + &nsid.to_string()),
       Path::NotImplemented => "/xrpc/{*nsid}",
     };