Upgrade workspace + Axum 0.7

Cargo.toml

@@ -42,18 +42,18 @@ bit-vec = ["specta/bit-vec"]
 bson = ["specta/bson"]
 
 [dependencies]
-specta = { version = "1.0.0", features = ["serde", "typescript"] }
-httpz = { version = "0.0.4", optional = true } # TODO: Move back to crates.io release
-serde = { version = "1.0.152", features = ["derive"] }
-serde_json = "1.0.93"
-thiserror = "1.0.38"
-futures = "0.3.26"
-tokio = { version = "1.26.0", features = ["sync", "rt", "macros"] }
-tauri = { version = "1.2.4", optional = true }
-tracing = { version = "0.1.37", optional = true }
+specta = { version = "1.0.5", features = ["serde", "typescript"] }
+httpz = { version = "0.0.6", optional = true } # TODO: Move back to crates.io release
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.114"
+thiserror = "1.0.58"
+futures = "0.3.30"
+tokio = { version = "1.36.0", features = ["sync", "rt", "macros"] }
+tauri = { version = "1.6.1", optional = true }
+tracing = { version = "0.1.40", optional = true }
 
 [dev-dependencies]
-async-stream = "0.3.4"
+async-stream = "0.3.5"
 
 [workspace]
-members = ["./examples", "./examples/axum"]
+members = ["./crates/*", "./examples", "./examples/axum", "crates/axum"]

crates/axum/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "rspc-axum"
+description = "Axum adapter for rspc"
+version = "0.0.1"
+authors = ["Oscar Beaumont <[email protected]>"]
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/oscartbeaumont/rspc"
+documentation = "https://docs.rs/rspc-axum/latest/rspc-axum"
+keywords = ["async", "specta", "rust-to-ts", "typescript", "typesafe"]
+categories = ["web-programming", "asynchronous"]
+
+[dependencies]
+axum = "0.7.4"
+httpz = { version = "0.0.6", features = ["axum"] }
+rspc = { version = "0.1.3", path = "../.." }

crates/axum/src/lib.rs

@@ -0,0 +1,146 @@
+//! rspc-axum: Axum integration for [rspc](https://rspc.dev).
+use std::sync::Arc;
+
+use axum::{
+ body::{to_bytes, Body},
+ extract::State,
+ http::{HeaderMap, StatusCode},
+ routing::{on, MethodFilter},
+ Router,
+};
+use httpz::{Endpoint, HttpEndpoint, HttpResponse, Server};
+
+fn method_interop(method: httpz::http::Method) -> axum::http::Method {
+ match method {
+ httpz::http::Method::OPTIONS => axum::http::Method::OPTIONS,
+ httpz::http::Method::GET => axum::http::Method::GET,
+ httpz::http::Method::POST => axum::http::Method::POST,
+ httpz::http::Method::PUT => axum::http::Method::PUT,
+ httpz::http::Method::DELETE => axum::http::Method::DELETE,
+ httpz::http::Method::HEAD => axum::http::Method::HEAD,
+ httpz::http::Method::TRACE => axum::http::Method::TRACE,
+ httpz::http::Method::CONNECT => axum::http::Method::CONNECT,
+ httpz::http::Method::PATCH => axum::http::Method::PATCH,
+ _ => unreachable!(),
+ }
+}
+
+fn method_interop2(method: axum::http::Method) -> httpz::http::Method {
+ match method {
+ axum::http::Method::OPTIONS => httpz::http::Method::OPTIONS,
+ axum::http::Method::GET => httpz::http::Method::GET,
+ axum::http::Method::POST => httpz::http::Method::POST,
+ axum::http::Method::PUT => httpz::http::Method::PUT,
+ axum::http::Method::DELETE => httpz::http::Method::DELETE,
+ axum::http::Method::HEAD => httpz::http::Method::HEAD,
+ axum::http::Method::TRACE => httpz::http::Method::TRACE,
+ axum::http::Method::CONNECT => httpz::http::Method::CONNECT,
+ axum::http::Method::PATCH => httpz::http::Method::PATCH,
+ _ => unreachable!(),
+ }
+}
+
+fn status_interop(status: httpz::http::StatusCode) -> axum::http::StatusCode {
+ axum::http::StatusCode::from_u16(status.as_u16()).expect("unreachable")
+}
+
+fn headers_interop(headers: httpz::http::HeaderMap) -> axum::http::HeaderMap {
+ let mut new_headers = axum::http::HeaderMap::new();
+ for (key, value) in headers.iter() {
+ new_headers.insert(
+ axum::http::HeaderName::from_bytes(key.as_str().as_bytes()).expect("unreachable"),
+ axum::http::HeaderValue::from_bytes(value.as_bytes()).expect("unreachable"),
+ );
+ }
+ new_headers
+}
+
+fn headers_interop2(headers: axum::http::HeaderMap) -> httpz::http::HeaderMap {
+ let mut new_headers = httpz::http::HeaderMap::new();
+ for (key, value) in headers.iter() {
+ new_headers.insert(
+ httpz::http::HeaderName::from_bytes(key.as_str().as_bytes()).expect("unreachable"),
+ httpz::http::HeaderValue::from_bytes(value.as_bytes()).expect("unreachable"),
+ );
+ }
+ new_headers
+}
+
+pub fn endpoint<S>(mut endpoint: Endpoint<impl HttpEndpoint>) -> Router<S>
+where
+ S: Clone + Send + Sync + 'static,
+{
+ let (url, methods) = endpoint.endpoint.register();
+ let endpoint = Arc::new(endpoint.endpoint);
+
+ let mut method_filter = None::<MethodFilter>;
+ for method in methods.as_ref().iter() {
+ #[allow(clippy::unwrap_used)] // TODO: Error handling
+ let new_filter = MethodFilter::try_from(method_interop(method.clone())).unwrap();
+ if let Some(filter) = method_filter {
+ method_filter = Some(filter.or(new_filter));
+ } else {
+ method_filter = Some(new_filter);
+ }
+ }
+
+ Router::<S>::new().route(
+ url.as_ref(),
+ on(
+ method_filter.expect("no methods specified"), // Unreachable because rspc specifies at least one method
+ |state: State<S>, request: axum::extract::Request<Body>| async move {
+ let (mut parts, body) = request.into_parts();
+ parts.extensions.insert(state);
+
+ // TODO: Should probs limit the size of the body
+ let body = match to_bytes(body, usize::MAX).await {
+ Ok(body) => body.to_vec(),
+ Err(err) => {
+ return (
+ StatusCode::BAD_REQUEST,
+ HeaderMap::new(),
+ err.to_string().as_bytes().to_vec(),
+ );
+ }
+ };
+
+ let (mut new_parts, _) = httpz::http::Request::new(()).into_parts();
+ new_parts.method = method_interop2(parts.method);
+ new_parts.uri =
+ httpz::http::Uri::try_from(parts.uri.to_string()).expect("unreachable");
+ new_parts.version = match parts.version {
+ axum::http::Version::HTTP_10 => httpz::http::Version::HTTP_10,
+ axum::http::Version::HTTP_11 => httpz::http::Version::HTTP_11,
+ axum::http::Version::HTTP_2 => httpz::http::Version::HTTP_2,
+ axum::http::Version::HTTP_3 => httpz::http::Version::HTTP_3,
+ _ => unreachable!(),
+ };
+ new_parts.headers = headers_interop2(parts.headers);
+ // new_parts.extensions = parts.extensions; // TODO: We can't interop this
+
+ match endpoint
+ .handler(httpz::Request::new(
+ httpz::http::Request::from_parts(new_parts, body),
+ Server::Axum,
+ ))
+ .await
+ .into_response()
+ {
+ Ok(resp) => {
+ let (parts, body) = resp.into_parts();
+ (
+ status_interop(parts.status),
+ headers_interop(parts.headers),
+ body,
+ )
+ }
+ Err(err) => (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ HeaderMap::new(),
+ err.to_string().as_bytes().to_vec(),
+ ),
+ }
+ },
+ ),
+ )
+}

examples/Cargo.toml

@@ -6,13 +6,13 @@ publish = false
 
 [dependencies]
 rspc = { path = "../", features = ["axum"] }
-async-stream = "0.3.4"
-axum = "0.6.10"
-chrono = { version = "0.4.23", features = ["serde"] }
-serde = { version = "1.0.152", features = ["derive"] }
-time = "0.3.20"
-tokio = { version = "1.26.0", features = ["rt-multi-thread", "macros", "time", "sync"], default-features = false }
-tower-cookies = "0.9.0"
-tower-http = { version = "0.4.0", default-features = false, features = ["cors"] }
-uuid = { version = "1.3.0", features = ["v4", "serde"] }
-serde_json = "1.0.93"
+async-stream = "0.3.5"
+axum = "0.7.4"
+chrono = { version = "0.4.35", features = ["serde"] }
+serde = { version = "1.0.197", features = ["derive"] }
+time = "0.3.34"
+tokio = { version = "1.36.0", features = ["rt-multi-thread", "macros", "time", "sync"], default-features = false }
+tower-cookies = "0.10.0"
+tower-http = { version = "0.5.2", default-features = false, features = ["cors"] }
+uuid = { version = "1.7.0", features = ["v4", "serde"] }
+serde_json = "1.0.114"

examples/axum/Cargo.toml

@@ -6,7 +6,10 @@ publish = false
 
 [dependencies]
 rspc = { path = "../../", features = ["axum"] }
-tokio = { version = "1.26.0", features = ["full"] }
-async-stream = "0.3.4"
-axum = { version = "0.6.10", features = ["ws"] }
-tower-http = { version = "0.4.0", default-features = false, features = ["cors"] }
+rspc-axum = { path = "../../crates/axum" }
+tokio = { version = "1.36.0", features = ["full"] }
+async-stream = "0.3.5"
+axum = { version = "0.7.4", features = ["ws"] }
+tower-http = { version = "0.5.2", default-features = false, features = [
+ "cors",
+] }

examples/axum/src/main.rs

@@ -67,20 +67,16 @@ async fn main() {
  .route("/", get(|| async { "Hello 'rspc'!" }))
  .nest(
  "/rspc",
- router
- .clone()
- .endpoint(|req: Request| {
- println!("Client requested operation '{}'", req.uri().path());
- Ctx {}
- })
- .axum(),
+ rspc_axum::endpoint(router.clone().endpoint(|req: Request| {
+ println!("Client requested operation '{}'", req.uri().path());
+ Ctx {}
+ })),
  )
  .layer(cors);
 
  let addr = "[::]:4000".parse::<std::net::SocketAddr>().unwrap(); // This listens on IPv6 and IPv4
  println!("listening on http://{}/rspc/version", addr);
- axum::Server::bind(&addr)
- .serve(app.into_make_service())
+ axum::serve(tokio::net::TcpListener::bind(addr).await.unwrap(), app)
  .await
  .unwrap();
 }