Router, add xrpc and router abstraction to router

rust/Cargo.toml

@@ -9,4 +9,5 @@ edition = "2021"
 axum = { version = "0.8.3", features = ["json"] }
 serde = "1.0.219"
 serde_json = "1.0.140"
+sqlx = { version = "0.8.5", features = ["runtime-tokio"] }
 tokio = { version = "1.44.2", features = ["macros", "rt-multi-thread"] }

rust/src/main.rs

@@ -1,8 +1,9 @@
-use crate::router::setup;
+use crate::router::Router;
 
 mod router;
 
 #[tokio::main]
 async fn main() {
-  setup().await;
+  let router = Router::new();
+  router.serve().await;
 }

rust/src/router.rs

@@ -1,27 +1,31 @@
-use axum::{
+use crate::router::xrpc::XrpcEndpoint;
-  Json,
+use axum::Router as axumRouter;
-  routing::get,
+use core::net::SocketAddr;
-  extract::Path,
+use std::net::{IpAddr, Ipv4Addr};
-  http::StatusCode,
-  Router,
-};
-use serde_json::{Value, json};
 use tokio::net::TcpListener;
 
-pub async fn setup() {
+pub struct Router {
-  let app = Router::new()
+  addr: SocketAddr,
-    .route("/xrpc/{*nsid}", get(not_implemented).post(not_implemented));
+  xrpc: Vec<XrpcEndpoint>,
-
-  let listener = TcpListener::bind("0.0.0.0:6702").await.unwrap();
-  axum::serve(listener, app).await.unwrap();
 }
 
-async fn not_implemented(Path(_nsid): Path<String>) -> (StatusCode, Json<Value>) {
+mod xrpc;
-  (
+
-    StatusCode::NOT_IMPLEMENTED,
+impl Router {
-    Json(json!({
+  pub fn new() -> Self {
-      "error": "MethodNotImplemented",
+    let xrpc = vec![XrpcEndpoint::not_implemented()];
-      "message": "Method Not Implemented"
+    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127,0,0,1)), 6702);
-    }))
+    Router { xrpc, addr }
-  )
+  }
+
+  pub async fn serve(self) {
+    let listener = TcpListener::bind(self.addr).await.unwrap();
+    let mut router = axumRouter::new();
+
+    for endpoint in self.xrpc {
+      router = endpoint.add_to_router(router);
+    }
+
+    axum::serve(listener, router).await.unwrap();
+  }
 }

rust/src/router/xrpc.rs

@@ -0,0 +1,53 @@
+use axum::{
+  Json,
+  extract::Path,
+  routing::{
+    get,
+    method_routing::MethodRouter,
+  },
+  http::StatusCode,
+  Router as axumRouter,
+};
+use serde_json::{Value, json};
+
+enum Nsid {
+  Nsid(String),
+  NotImplemented,
+}
+
+pub struct XrpcEndpoint {
+  nsid: Nsid,
+  resolver: MethodRouter,
+}
+
+impl XrpcEndpoint {
+
+  pub fn add_to_router(self, router: axumRouter) -> axumRouter {
+    let path = match self.nsid {
+      Nsid::Nsid(s) => &("/xrpc/".to_owned() + &s),
+      Nsid::NotImplemented => "/xrpc/{*nsid}",
+    };
+
+    router.route(path, self.resolver)
+  }
+
+  pub fn not_implemented() -> XrpcEndpoint {
+    XrpcEndpoint {
+      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"
+      }))
+    )
+  }
+  
+}
+