Router v2

.github/dependabot.yml

@@ -3,4 +3,7 @@ updates:
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "weekly"
+
+  # TODO: Rust
+  # TODO: npm

.gitignore

@@ -12,9 +12,6 @@ Cargo.lock
 # System Files
 .DS_Store
 
-# Typescript bindings exported by the examples
-bindings.ts
-
 # Node
 node_modules
 .pnpm-debug.log*

Cargo.toml

@@ -1,51 +1,48 @@
-[package]
-name = "rspc"
-description = "A blazing fast and easy to use TRPC server for Rust."
-version = "0.3.1"
-authors = ["Oscar Beaumont <[email protected]>"]
-edition = "2021"
-license = "MIT"
-include = ["/src", "/LICENCE", "/README.md"]
-repository = "https://github.com/specta-rs/rspc"
-documentation = "https://docs.rs/rspc/latest/rspc"
-keywords = ["async", "specta", "rust-to-ts", "typescript", "typesafe"]
-categories = ["web-programming", "asynchronous"]
-
-# /bin/sh RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features
-[package.metadata."docs.rs"]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
+[workspace]
+resolver = "2"
+members = [
+    "./crates/*",
+    "./rspc",
+    "./integrations/*",
+    "./examples/core",
+    "./examples/axum",
+    "./examples/actix-web",
+    "./examples/client",
+    "./examples/tauri/src-tauri",
+    "./examples/legacy",
+    "./examples/legacy-compat",
+    "./examples/binario",
+]
 
-[features]
-default = []
-tracing = ["dep:tracing"]
+[workspace.dependencies]
+# Private
+specta-typescript = { version = "0.0.7", default-features = false }
+pin-project-lite = { version = "0.2", default-features = false }
+erased-serde = { version = "0.4", default-features = false }
 
-[dependencies]
 # Public
-serde = { version = "1", features = ["derive"] } # TODO: Remove features
-futures = "0.3"
-specta = { version = "=2.0.0-rc.20", features = [
-    "derive",
-    "serde",
-    "serde_json",
-] } # TODO: Drop all features
-specta-util = "0.0.7"
+specta = { version = "=2.0.0-rc.20", default-features = false }
+serde = { version = "1", default-features = false }
+serde_json = { version = "1", default-features = false }
+futures = { version = "0.3", default-features = false }
+futures-core = { version = "0.3", default-features = false }
+futures-util = { version = "0.3", default-features = false }
+tracing = { version = "0.1", default-features = false }
 
-# Private
-serde-value = "0.7"
-erased-serde = "0.4"
-
-# Temporary # TODO: Remove
-specta-typescript = { version = "=0.0.7", features = [] }
-serde_json = "1.0.133"                                              # TODO: Drop this
-thiserror = "2.0.3"
-tokio = { version = "1.41.1", features = ["sync", "rt", "macros"] }
-tracing = { version = "0.1.40", optional = true }
-transient = "0.4.1"
-better_any = "0.2.0"
+[workspace.lints.clippy]
+all = { level = "warn", priority = -1 }
+cargo = { level = "warn", priority = -1 }
+unwrap_used = { level = "warn", priority = -1 }
+panic = { level = "warn", priority = -1 }
+todo = { level = "warn", priority = -1 }
+panic_in_result_fn = { level = "warn", priority = -1 }
 
-# https://github.com/rust-lang/rust/issues/77125
-typeid = "1.0.2"
+[patch.crates-io]
+specta = { git = "https://github.com/specta-rs/specta", rev = "bf3a0937cceb29eca11df207076b9e1b942ba7bb" }
+specta-serde = { git = "https://github.com/specta-rs/specta", rev = "bf3a0937cceb29eca11df207076b9e1b942ba7bb" }
+specta-typescript = { git = "https://github.com/specta-rs/specta", rev = "bf3a0937cceb29eca11df207076b9e1b942ba7bb" }
 
-[workspace]
-members = ["./crates/*", "./examples", "./examples/axum", "crates/core"]
+# specta = { path = "/Users/oscar/Desktop/specta/specta" }
+# specta-typescript = { path = "/Users/oscar/Desktop/specta/specta-typescript" }
+# specta-serde = { path = "/Users/oscar/Desktop/specta/specta-serde" }
+# specta-util = { path = "/Users/oscar/Desktop/specta/specta-util" }

crates/binario/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "rspc-binario"
+description = "Binario support for rspc"
+version = "0.0.0"
+edition = "2021"
+publish = false                          # TODO: Crate metadata & publish
+
+[dependencies]
+binario = "0.0.2"
+futures-util.workspace = true
+rspc = { path = "../../rspc" }
+specta = { workspace = true }
+tokio = "1.42.0"
+
+# /bin/sh RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features
+[package.metadata."docs.rs"]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[lints]
+workspace = true

crates/binario/README.md

@@ -0,0 +1,12 @@
+# rspc 🤝 Binario
+
+[![docs.rs](https://img.shields.io/crates/v/rspc-binario)](https://docs.rs/rspc-binario)
+
+> [!CAUTION]
+> This crate is a proof of concept.
+>
+> It is not intended for production use and will likely remain that way.
+
+Use [Binario](https://github.com/oscartbeaumont/binario) instead of [Serde](https://serde.rs) for serialization and deserialization.
+
+This is a proof of concept to show that rspc has the ability to support any serialization libraries.

crates/binario/src/lib.rs

@@ -0,0 +1,172 @@
+//! rspc-binario: Binario support for rspc
+//!
+//! TODO:
+//!  - Support for streaming the result. Right now we encode into a buffer.
+//!  - `BinarioDeserializeError` should end up as a `ProcedureError::Deserialize` not `ProcedureError::Resolver`
+//!  - Binario needs impl for `()` for procedures with no input.
+//!  - Client integration
+//!  - Cleanup HTTP endpoint on `example-binario`. Maybe don't use HTTP cause Axum's model doesn't mesh with Binario?
+//!  - Maybe actix-web example to show portability. Might be interesting with the fact that Binario depends on `tokio::AsyncRead`.
+//!
+#![forbid(unsafe_code)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![doc(
+    html_logo_url = "https://github.com/specta-rs/rspc/blob/main/.github/logo.png?raw=true",
+    html_favicon_url = "https://github.com/specta-rs/rspc/blob/main/.github/logo.png?raw=true"
+)]
+
+use std::{error, fmt, marker::PhantomData, pin::Pin};
+
+use binario::{encode, Decode, Encode};
+use futures_util::{stream, Stream, StreamExt};
+use rspc::{
+    middleware::Middleware, DynInput, ProcedureError, ProcedureStream, ResolverInput,
+    ResolverOutput,
+};
+use specta::{datatype::DataType, Generics, Type, TypeCollection};
+use tokio::io::AsyncRead;
+
+enum Repr {
+    Bytes(Vec<u8>),
+    Stream(Pin<Box<dyn AsyncRead + Send>>),
+}
+
+pub struct BinarioInput(Repr);
+
+impl BinarioInput {
+    pub fn from_bytes(bytes: Vec<u8>) -> Self {
+        Self(Repr::Bytes(bytes))
+    }
+
+    pub fn from_stream(stream: impl AsyncRead + Send + 'static) -> Self {
+        Self(Repr::Stream(Box::pin(stream)))
+    }
+}
+
+pub struct TypedBinarioInput<T>(pub BinarioInput, pub PhantomData<T>);
+
+impl<T: Decode + Type + Send + 'static> ResolverInput for TypedBinarioInput<T> {
+    fn data_type(types: &mut TypeCollection) -> DataType {
+        T::inline(types, Generics::Definition)
+    }
+
+    fn from_input(input: DynInput) -> Result<Self, ProcedureError> {
+        Ok(Self(input.value()?, PhantomData))
+    }
+}
+
+// TODO: This should probs be a stream not a buffer.
+// Binario currently only supports `impl AsyncRead` not `impl Stream`
+pub struct BinarioOutput(pub Vec<u8>);
+pub struct TypedBinarioOutput<T, M>(pub T, pub PhantomData<fn() -> M>);
+
+pub(crate) mod sealed {
+    use super::*;
+
+    pub trait ValidBinarioOutput<M>: Send + 'static {
+        type T: Encode + Send + Sync + 'static;
+        fn data_type(types: &mut TypeCollection) -> DataType;
+        fn into_stream(
+            self,
+        ) -> impl Stream<Item = Result<Self::T, ProcedureError>> + Send + 'static;
+    }
+    pub enum ValueMarker {}
+    impl<T: Encode + Type + Send + Sync + 'static> ValidBinarioOutput<ValueMarker> for T {
+        type T = T;
+        fn data_type(types: &mut TypeCollection) -> DataType {
+            T::inline(types, Generics::Definition)
+        }
+        fn into_stream(
+            self,
+        ) -> impl Stream<Item = Result<Self::T, ProcedureError>> + Send + 'static {
+            stream::once(async move { Ok(self) })
+        }
+    }
+    pub enum StreamMarker {}
+    impl<S: Stream + Send + Sync + 'static> ValidBinarioOutput<StreamMarker> for rspc::Stream<S>
+    where
+        S::Item: Encode + Type + Send + Sync + 'static,
+    {
+        type T = S::Item;
+
+        fn data_type(types: &mut TypeCollection) -> DataType {
+            S::Item::inline(types, Generics::Definition)
+        }
+        fn into_stream(
+            self,
+        ) -> impl Stream<Item = Result<Self::T, ProcedureError>> + Send + 'static {
+            self.0.map(|v| Ok(v))
+        }
+    }
+}
+
+impl<TError, M: 'static, T: sealed::ValidBinarioOutput<M>> ResolverOutput<TError>
+    for TypedBinarioOutput<T, M>
+{
+    type T = BinarioOutput;
+
+    fn data_type(types: &mut TypeCollection) -> DataType {
+        T::data_type(types)
+    }
+
+    fn into_stream(self) -> impl Stream<Item = Result<Self::T, ProcedureError>> + Send + 'static {
+        // TODO: Encoding into a buffer is not how Binario is intended to work but it's how rspc needs it.
+        self.0.into_stream().then(|v| async move {
+            let mut buf = Vec::new();
+            encode(&v?, &mut buf).await.unwrap(); // TODO: Error handling
+            Ok(BinarioOutput(buf))
+        })
+    }
+
+    fn into_procedure_stream(
+        stream: impl Stream<Item = Result<Self::T, ProcedureError>> + Send + 'static,
+    ) -> ProcedureStream {
+        ProcedureStream::from_stream_value(stream)
+    }
+}
+
+pub fn binario<TError, TCtx, TInput, TResult, M>() -> Middleware<
+    TError,
+    TCtx,
+    TypedBinarioInput<TInput>,
+    TypedBinarioOutput<TResult, M>,
+    TCtx,
+    TInput,
+    TResult,
+>
+where
+    TError: From<DeserializeError> + Send + 'static,
+    TCtx: Send + 'static,
+    TInput: Decode + Send + 'static,
+    TResult: sealed::ValidBinarioOutput<M>,
+{
+    Middleware::new(
+        move |ctx: TCtx, input: TypedBinarioInput<TInput>, next| async move {
+            let input = match input.0 .0 {
+                Repr::Bytes(bytes) => binario::decode::<TInput, _>(bytes.as_slice()).await,
+                Repr::Stream(stream) => binario::decode::<TInput, _>(stream).await,
+            }
+            .map_err(DeserializeError)?;
+
+            next.exec(ctx, input)
+                .await
+                .map(|v| TypedBinarioOutput(v, PhantomData))
+        },
+    )
+}
+
+pub struct DeserializeError(pub std::io::Error);
+
+impl fmt::Debug for DeserializeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl fmt::Display for DeserializeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl error::Error for DeserializeError {}

crates/cache/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "rspc-cache"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+moka = { version = "0.12.8", features = ["sync"] }
+pin-project-lite = { workspace = true }
+rspc = { path = "../../rspc" }
+
+# /bin/sh RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features
+[package.metadata."docs.rs"]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[lints]
+workspace = true

crates/cache/README.md

@@ -0,0 +1,34 @@
+# rspc cache
+
+[![docs.rs](https://img.shields.io/crates/v/rspc-cache)](https://docs.rs/rspc-cache)
+
+> [!CAUTION]
+> This crate is still a work in progress. You can use it but we can't guarantee that it's API won't change.
+
+Provides a simple way to cache the results of rspc queries with pluggable backends.
+
+Features:
+ - Simple to use
+ - Pluggable backends (memory, redis, etc.)
+ - Configurable cache TTL
+
+## Example
+
+```rust
+// TODO: imports
+
+fn todo() -> Router2<Ctx> {
+    Router2::new()
+        .setup(CacheState::builder(Memory::new()).mount())
+        .procedure("my_query", {
+            <BaseProcedure>::builder()
+                .with(cache())
+                .query(|_, _: ()| async {
+                    // if input.some_arg {}
+                    cache_ttl(10);
+
+                    Ok(SystemTime::now())
+                })
+        })
+}
+```