Router, add xrpc function interface, test in main

Adds an interface for adding xrpc queries and procedures that is a bit
simpler than directly interfacing with axum. Should provide good
scaffolding for next steps.

rust/Cargo.lock

@@ -92,6 +92,17 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "axum-macros"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "604fde5e028fea851ce1d8570bbdc034bec850d157f7569d10f347d06808c05c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "backtrace"
 version = "0.3.74"
@@ -281,7 +292,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1099,6 +1110,7 @@ name = "rust"
 version = "0.1.0"
 dependencies = [
  "axum",
+ "axum-macros",
  "serde",
  "serde_json",
  "sqlx",
@@ -1121,7 +1133,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1525,7 +1537,7 @@ dependencies = [
  "getrandom 0.3.2",
  "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]

rust/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 
 [dependencies]
 axum = { version = "0.8.3", features = ["json"] }
+axum-macros = "0.5.0"
 serde = "1.0.219"
 serde_json = "1.0.140"
 sqlx = { version = "0.8.5", features = ["runtime-tokio"] }

rust/src/main.rs

@@ -1,9 +1,31 @@
-use crate::router::Router;
+use crate::router::{
+    Router,
+    Endpoint,
+    xrpc::{
+      QueryInput,
+      ProcedureInput,
+      Response,
+      error,
+    },
+};
+use axum::http::StatusCode;
+
 
 mod router;
+mod db;
 
 #[tokio::main]
 async fn main() {
-  let router = Router::new();
+  let mut router = Router::new();
+  router = router.add_endpoint(Endpoint::new_xrpc_query(String::from("me.woach.get"), test));
+  router = router.add_endpoint(Endpoint::new_xrpc_procedure(String::from("me.woach.post"), test2));
   router.serve().await;
 }
+
+async fn test(_data: QueryInput) -> Response {
+  error(StatusCode::OK, "error", "message")
+}
+
+async fn test2(_data: ProcedureInput) -> Response {
+  error(StatusCode::OK, "error", "message")
+}

rust/src/router.rs

@@ -1,31 +1,58 @@
-use crate::router::xrpc::XrpcEndpoint;
+use crate::router::xrpc::{
-use axum::Router as axumRouter;
+  XrpcEndpoint,
+  XrpcHandler,
+  QueryInput,
+  ProcedureInput,
+};
+use axum::Router as AxumRouter;
 use core::net::SocketAddr;
 use std::net::{IpAddr, Ipv4Addr};
 use tokio::net::TcpListener;
 
 pub struct Router {
   addr: SocketAddr,
-  xrpc: Vec<XrpcEndpoint>,
+  router: AxumRouter,
 }
 
-mod xrpc;
+// In case server ever needs to support more than just XRPC
+pub enum Endpoint {
+  Xrpc(XrpcEndpoint),
+}
+impl Endpoint {
+  pub fn new_xrpc_query<Q>(nsid: String, query: Q) -> Self
+  where
+    Q: XrpcHandler<QueryInput> + Clone
+  {
+    Endpoint::Xrpc(XrpcEndpoint::new_query(nsid,query))
+  }
+  pub fn new_xrpc_procedure<P>(nsid: String, procedure: P) -> Self
+  where
+    P: XrpcHandler<ProcedureInput> + Clone
+  {
+    Endpoint::Xrpc(XrpcEndpoint::new_procedure(nsid,procedure))
+  }
+}
+
+pub mod xrpc;
 
 impl Router {
   pub fn new() -> Self {
-    let xrpc = vec![XrpcEndpoint::not_implemented()];
+    let mut router = AxumRouter::new();
+    router = XrpcEndpoint::not_implemented().add_to_router(router);
     let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127,0,0,1)), 6702);
-    Router { xrpc, addr }
+    Router { router, addr }
+  }
+
+  pub fn add_endpoint(mut self, endpoint: Endpoint) -> Self {
+    match endpoint {
+      Endpoint::Xrpc(ep) => self.router = ep.add_to_router(self.router),
+    };
+    self
   }
 
   pub async fn serve(self) {
     let listener = TcpListener::bind(self.addr).await.unwrap();
-    let mut router = axumRouter::new();
 
-    for endpoint in self.xrpc {
+    axum::serve(listener, self.router).await.unwrap();
-      router = endpoint.add_to_router(router);
-    }
-
-    axum::serve(listener, router).await.unwrap();
   }
 }

rust/src/router/xrpc.rs

@@ -1,11 +1,27 @@
+use std::{
+  collections::HashMap,
+  pin::Pin,
+  future::Future,
+};
 use axum::{
-  Json,
+  extract::{
-  extract::Path,
+    Json,
+    Query,
+    Request,
+    FromRequest,
+    FromRequestParts,
+    rejection::QueryRejection,
+  },
+  body::Bytes,
   routing::{
     get,
+    post,
     method_routing::MethodRouter,
   },
-  http::StatusCode,
+  http::{
+    StatusCode,
+    request::Parts,
+  },
   Router as axumRouter,
 };
 use serde_json::{Value, json};
@@ -20,7 +36,122 @@ pub struct XrpcEndpoint {
   resolver: MethodRouter,
 }
 
+pub type Response = (StatusCode, Json<Value>);
+pub fn error(code: StatusCode, error: &str, message: &str) -> Response {
+  (
+    code,
+    Json(json!({
+      "error": error,
+      "message": message
+    }))
+  )
+}
+pub fn response(code: StatusCode, message: &str) -> Response {
+  error(code, "", message)
+}
+
+pub struct QueryInput {
+  parameters: HashMap<String, String>,
+}
+impl<S> FromRequestParts<S> for QueryInput
+where
+  S: Send + Sync,
+{
+  type Rejection = Response;
+
+  async fn from_request_parts(parts: &mut Parts, _state: &S)
+    -> Result<Self, Self::Rejection> {
+    let query_params: Result<Query<HashMap<String, String>>, QueryRejection> = Query::try_from_uri(&parts.uri);
+    match query_params {
+      Ok(p) => Ok(QueryInput { parameters: p.0 }),
+      Err(e) => Err(error(StatusCode::BAD_REQUEST, "Bad Parameters", &e.body_text())),
+    }
+  }
+}
+pub struct ProcedureInput {
+  parameters: HashMap<String, String>,
+  input: Json<Value>,
+}
+impl<S> FromRequest<S> for ProcedureInput 
+where
+  Bytes: FromRequest<S>,
+  S: Send + Sync,
+{
+  type Rejection = Response;
+
+  async fn from_request(req: Request, state: &S)
+    -> Result<Self, Self::Rejection> {
+    let query_params: Result<Query<HashMap<String, String>>, QueryRejection> = Query::try_from_uri(req.uri());
+    let parameters = match query_params {
+      Ok(p) => p.0,
+      Err(e) => return Err(error(StatusCode::BAD_REQUEST, "Bad Parameters", &e.body_text())),
+    };
+
+    let json_value = Json::<Value>::from_request(req, state).await;
+    let input: Json<Value> = match json_value {
+      Ok(v) => v,
+      Err(e) => return Err(error(StatusCode::BAD_REQUEST, "Bad Parameters", &e.body_text())),
+    };
+
+    Ok(ProcedureInput { parameters, input })
+  }
+}
+
+pub trait XrpcHandler<Input>: Send + Sync + 'static {
+  fn call(&self, input: Input) 
+    -> Pin<Box<dyn Future<Output = Response> + Send>>;
+}
+impl<F, Fut> XrpcHandler<QueryInput> for F
+where
+  F: Fn(QueryInput) -> Fut + Send + Sync + 'static,
+  Fut: Future<Output = Response> + Send + 'static,
+{
+  fn call(&self, input: QueryInput) 
+    -> Pin<Box<dyn Future<Output = Response>+ Send>> {
+    Box::pin((self)(input))
+  }
+}
+impl<F, Fut> XrpcHandler<ProcedureInput> for F
+where
+  F: Fn(ProcedureInput) -> Fut + Send + Sync + 'static,
+  Fut: Future<Output = Response> + Send + 'static,
+{
+  fn call(&self, input: ProcedureInput) 
+    -> Pin<Box<dyn Future<Output = Response>+ Send>> {
+    Box::pin((self)(input))
+  }
+}
+
 impl XrpcEndpoint {
+  pub fn new_query<Q>(nsid: String, query: Q) -> Self
+  where
+    Q: XrpcHandler<QueryInput> + Clone
+  {
+    XrpcEndpoint {
+      nsid: Nsid::Nsid(nsid),
+      resolver: get(async move | mut parts: Parts | -> Response {
+        match QueryInput::from_request_parts(&mut parts, &()).await {
+          Ok(qi) => query.call(qi).await,
+          Err(e) => e
+        }
+      })
+    }
+  }
+
+  pub fn new_procedure<P>(nsid: String, procedure: P) -> Self
+  where
+    P: XrpcHandler<ProcedureInput> + Clone
+  {
+    XrpcEndpoint {
+      nsid: Nsid::Nsid(nsid),
+      resolver: post(async move | req: Request | -> Response {
+        match ProcedureInput::from_request(req, &()).await {
+          Ok(pi) => procedure.call(pi).await,
+          Err(e) => e
+        }
+      })
+    }
+  }
 
   pub fn add_to_router(self, router: axumRouter) -> axumRouter {
     let path = match self.nsid {
@@ -31,23 +162,19 @@ impl XrpcEndpoint {
     router.route(path, self.resolver)
   }
 
-  pub fn not_implemented() -> XrpcEndpoint {
+  pub fn not_implemented() -> Self {
-    XrpcEndpoint {
+    let resolver = (
-      nsid: Nsid::NotImplemented,
-      resolver: get(Self::not_implemented_resolver)
-        .post(Self::not_implemented_resolver),
-    }
-  }
-
-  async fn not_implemented_resolver(Path(_nsid): Path<String>) -> (StatusCode, Json<Value>) {
-    (
       StatusCode::NOT_IMPLEMENTED,
       Json(json!({
         "error": "MethodNotImplemented",
         "message": "Method Not Implemented"
       }))
-    )
+    );
+
+    XrpcEndpoint {
+      nsid: Nsid::NotImplemented,
+      resolver: get(resolver.clone()).post(resolver),
+    }
   }
-  
 }