add TypeScript client gen

Author: andrewgazelka

Cargo.toml

@@ -9,12 +9,13 @@ members = [
     "crates/rpc-transport-stdio",
     "crates/rpc-transport-inprocess",
     "crates/rpc-server",
+    "crates/rpc-openapi",
     "examples-crate",
 ]
 
 [workspace.package]
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 rust-version = "1.75"
 license = "MIT"
 authors = ["Andrew Gazelka"]
@@ -30,6 +31,10 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 rmp-serde = "1.3"
 
+# Schema
+schema = { path = "/Users/andrewgazelka/Projects/superglide/schema/schema" }
+schema-openapi = { path = "/Users/andrewgazelka/Projects/superglide/schema/schema-openapi" }
+
 # WebSocket
 tokio = { version = "1.42", features = ["full"] }
 tokio-tungstenite = "0.24"
@@ -48,6 +53,7 @@ rpc-transport-ws = { path = "crates/rpc-transport-ws" }
 rpc-transport-stdio = { path = "crates/rpc-transport-stdio" }
 rpc-transport-inprocess = { path = "crates/rpc-transport-inprocess" }
 rpc-server = { path = "crates/rpc-server" }
+rpc-openapi = { path = "crates/rpc-openapi" }
 
 [profile.dev]
 opt-level = 0

README.md

@@ -30,9 +30,9 @@ Schema generation powered by [schema](https://github.com/andrewgazelka/schema) -
 | **Streaming** | 🚧 | Support streaming requests and responses |
 | **Any transport** | ✅ | WebSocket, HTTP, Stdio, in-process channels, custom transports |
 | **Decoupled evolution** | 🚧 | Server changes don't require client recompilation - client and server evolve independently |
-| **Schema generation** | 📋 | Generate schemas from RPC definitions for OpenAPI specs, MCP servers (requires `#[derive(Schema)]` crate) |
+| **Schema generation** | ✅ | Generate OpenAPI specs and TypeScript clients from RPC definitions via `schema` crate |
 | **Observability** | 📋 | LLM-first observability via RPC - query transaction history, inspect logs, view request/response pairs |
-| **Language agnostic** | 📋 | Work with any language, not just Rust - clients in Python, JavaScript, Go, etc. |
+| **Language agnostic** | 🚧 | TypeScript clients via codegen, Python/Go/etc. planned |
 
 ### Low Priority (Needs More Thought)
 
@@ -43,6 +43,8 @@ Schema generation powered by [schema](https://github.com/andrewgazelka/schema) -
 ## Usage
 
 ```rust
+use schema::Schema;
+
 // Define your API
 rpc! {
     extern "Rust" {
@@ -72,12 +74,40 @@ let client = client::Client::new(transport, MessagePackCodec);
 let result = client.add(2, 3).await?;  // => 5
 ```
 
+### Generate OpenAPI & TypeScript
+
+```rust
+// Get schema from RPC definition
+let schemas = client::Client::<AnyTransport, AnyCodec>::schema();
+
+// Generate OpenAPI 3.0 spec
+let openapi = generate_openapi_spec("My API", "1.0.0", schemas);
+
+// Generate TypeScript client
+let ts_client = generate_typescript_client("MyApiClient", "http://localhost:8080", schemas);
+```
+
+Output TypeScript:
+
+```typescript
+export class MyApiClient {
+  async add(arg0: number, arg1: number): Promise<number> {
+    return this.request<number>('add', [arg0, arg1]);
+  }
+
+  async greet(arg0: string): Promise<string> {
+    return this.request<string>('greet', [arg0]);
+  }
+}
+```
+
 ## Features
 
 - **Modular**: Separate crates for transport, codec, core
 - **Pluggable**: Mix & match any transport with any codec
 - **Type-safe**: Macro generates fully-typed client/server
 - **Modern**: Native async traits (Rust 1.75+)
+- **Schema-aware**: Automatic OpenAPI & TypeScript generation
 - **Flexible transports**: WebSocket, Stdio, in-process, HTTP (planned)
 
 ## Packages

crates/rpc-codec-json/Cargo.toml

@@ -10,3 +10,4 @@ repository.workspace = true
 rpc-core.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+schema.workspace = true

crates/rpc-codec-json/src/lib.rs

@@ -4,6 +4,7 @@
 //! Best for web APIs, debugging, and when message inspection is important.
 
 use rpc_core::{Codec, Error, Result};
+use schema::Schema;
 use serde::{Deserialize, Serialize};
 
 /// JSON codec using serde_json.
@@ -26,11 +27,11 @@ use serde::{Deserialize, Serialize};
 pub struct JsonCodec;
 
 impl Codec for JsonCodec {
-    fn encode<T: Serialize>(&self, value: &T) -> Result<Vec<u8>> {
+    fn encode<T: Serialize + Schema>(&self, value: &T) -> Result<Vec<u8>> {
         serde_json::to_vec(value).map_err(|e| Error::codec(format!("JSON encode error: {}", e)))
     }
 
-    fn decode<T: for<'de> Deserialize<'de>>(&self, bytes: &[u8]) -> Result<T> {
+    fn decode<T: for<'de> Deserialize<'de> + Schema>(&self, bytes: &[u8]) -> Result<T> {
         serde_json::from_slice(bytes).map_err(|e| Error::codec(format!("JSON decode error: {}", e)))
     }
 }
@@ -53,7 +54,7 @@ mod tests {
     #[test]
     fn test_json_human_readable() {
         let codec = JsonCodec;
-        let value = ("hello", 42);
+        let value = ("hello".to_string(), 42);
 
         let encoded = codec.encode(&value).unwrap();
         let json_str = String::from_utf8(encoded).unwrap();
@@ -65,17 +66,13 @@ mod tests {
 
     #[test]
     fn test_json_complex_types() {
-        use std::collections::HashMap;
-
         let codec = JsonCodec;
-        let mut map = HashMap::new();
-        map.insert("key1".to_string(), 42);
-        map.insert("key2".to_string(), 100);
+        let value = (42, "test".to_string(), true);
 
-        let encoded = codec.encode(&map).unwrap();
-        let decoded: HashMap<String, i32> = codec.decode(&encoded).unwrap();
+        let encoded = codec.encode(&value).unwrap();
+        let decoded: (i32, String, bool) = codec.decode(&encoded).unwrap();
 
-        assert_eq!(map, decoded);
+        assert_eq!(value, decoded);
     }
 
     #[test]
@@ -90,12 +87,12 @@ mod tests {
 
     #[test]
     fn test_json_nested_structures() {
-        #[derive(Debug, Serialize, Deserialize, PartialEq)]
+        #[derive(Debug, Serialize, Deserialize, Schema, PartialEq)]
         struct Inner {
             value: i32,
         }
 
-        #[derive(Debug, Serialize, Deserialize, PartialEq)]
+        #[derive(Debug, Serialize, Deserialize, Schema, PartialEq)]
         struct Outer {
             name: String,
             inner: Inner,

crates/rpc-codec-msgpack/Cargo.toml

@@ -10,3 +10,4 @@ repository.workspace = true
 rpc-core.workspace = true
 serde.workspace = true
 rmp-serde.workspace = true
+schema.workspace = true

crates/rpc-codec-msgpack/src/lib.rs

@@ -4,6 +4,7 @@
 //! Best for high-throughput applications and bandwidth-constrained scenarios.
 
 use rpc_core::{Codec, Error, Result};
+use schema::Schema;
 use serde::{Deserialize, Serialize};
 
 /// MessagePack codec using rmp-serde.
@@ -29,12 +30,12 @@ use serde::{Deserialize, Serialize};
 pub struct MessagePackCodec;
 
 impl Codec for MessagePackCodec {
-    fn encode<T: Serialize>(&self, value: &T) -> Result<Vec<u8>> {
+    fn encode<T: Serialize + Schema>(&self, value: &T) -> Result<Vec<u8>> {
         rmp_serde::to_vec(value)
             .map_err(|e| Error::codec(format!("MessagePack encode error: {}", e)))
     }
 
-    fn decode<T: for<'de> Deserialize<'de>>(&self, bytes: &[u8]) -> Result<T> {
+    fn decode<T: for<'de> Deserialize<'de> + Schema>(&self, bytes: &[u8]) -> Result<T> {
         rmp_serde::from_slice(bytes)
             .map_err(|e| Error::codec(format!("MessagePack decode error: {}", e)))
     }
@@ -69,17 +70,13 @@ mod tests {
 
     #[test]
     fn test_msgpack_complex_types() {
-        use std::collections::HashMap;
-
         let codec = MessagePackCodec;
-        let mut map = HashMap::new();
-        map.insert("key1".to_string(), 42);
-        map.insert("key2".to_string(), 100);
+        let value = (42, "test".to_string(), true);
 
-        let encoded = codec.encode(&map).unwrap();
-        let decoded: HashMap<String, i32> = codec.decode(&encoded).unwrap();
+        let encoded = codec.encode(&value).unwrap();
+        let decoded: (i32, String, bool) = codec.decode(&encoded).unwrap();
 
-        assert_eq!(map, decoded);
+        assert_eq!(value, decoded);
     }
 
     #[test]
@@ -94,12 +91,14 @@ mod tests {
 
     #[test]
     fn test_msgpack_nested_structures() {
-        #[derive(Debug, Serialize, Deserialize, PartialEq)]
+        use schema::Schema;
+
+        #[derive(Debug, Serialize, Deserialize, Schema, PartialEq)]
         struct Inner {
             value: i32,
         }
 
-        #[derive(Debug, Serialize, Deserialize, PartialEq)]
+        #[derive(Debug, Serialize, Deserialize, Schema, PartialEq)]
         struct Outer {
             name: String,
             inner: Inner,

crates/rpc-core/Cargo.toml

@@ -10,6 +10,7 @@ repository.workspace = true
 thiserror.workspace = true
 serde = { workspace = true }
 futures.workspace = true
+schema.workspace = true
 
 [dev-dependencies]
 serde_json.workspace = true

crates/rpc-core/src/lib.rs

@@ -3,6 +3,7 @@
 //! This crate provides the fundamental abstractions needed for building
 //! transport-agnostic and codec-agnostic RPC systems.
 
+use schema::Schema;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
@@ -56,14 +57,14 @@ pub trait Transport: Send {
 /// serialization format (JSON, MessagePack, Protobuf, etc.).
 pub trait Codec: Send + Sync {
     /// Encode a value to bytes
-    fn encode<T: Serialize>(&self, value: &T) -> Result<Vec<u8>>;
+    fn encode<T: Serialize + Schema>(&self, value: &T) -> Result<Vec<u8>>;
 
     /// Decode bytes to a value
-    fn decode<T: for<'de> Deserialize<'de>>(&self, bytes: &[u8]) -> Result<T>;
+    fn decode<T: for<'de> Deserialize<'de> + Schema>(&self, bytes: &[u8]) -> Result<T>;
 }
 
 /// RPC request structure
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Debug, Clone, Serialize, Deserialize, Schema, PartialEq, Eq)]
 pub struct RpcRequest {
     /// Request ID for matching responses
     pub id: u64,
@@ -74,7 +75,7 @@ pub struct RpcRequest {
 }
 
 /// RPC response structure
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Schema)]
 pub struct RpcResponse {
     /// Request ID this response corresponds to
     pub id: u64,
@@ -83,7 +84,7 @@ pub struct RpcResponse {
 }
 
 /// Result of an RPC call
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, Schema)]
 pub enum ResponseResult {
     /// Successful result with data
     Ok(Vec<u8>),

crates/rpc-macro/src/lib.rs

@@ -2,7 +2,7 @@
 
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, ItemForeignMod, ReturnType};
+use syn::{ItemForeignMod, ReturnType, parse_macro_input};
 
 /// Generate RPC client and server traits from a function signature list.
 ///
@@ -25,6 +25,7 @@ pub fn rpc(input: TokenStream) -> TokenStream {
     let mut client_methods = Vec::new();
     let mut server_methods = Vec::new();
     let mut dispatch_arms = Vec::new();
+    let mut schema_entries = Vec::new();
 
     for item in &foreign_mod.items {
         if let syn::ForeignItem::Fn(func) = item {
@@ -97,6 +98,27 @@ pub fn rpc(input: TokenStream) -> TokenStream {
                     rpc_core::ResponseResult::Ok(result_data)
                 }
             });
+
+            // Generate schema entry
+            schema_entries.push(quote! {
+                {
+                    use ::schema::Schema;
+                    schema_map.insert(
+                        #method_str.to_string(),
+                        MethodSchema {
+                            name: #method_str.to_string(),
+                            params: {
+                                let schema_type = <(#(#param_types,)*)>::schema();
+                                ::schema_openapi::to_openapi_schema(&schema_type)
+                            },
+                            returns: {
+                                let schema_type = <#return_type>::schema();
+                                ::schema_openapi::to_openapi_schema(&schema_type)
+                            },
+                        }
+                    );
+                }
+            });
         }
     }
 
@@ -137,11 +159,21 @@ pub fn rpc(input: TokenStream) -> TokenStream {
     }
 
     let expanded = quote! {
+        /// Schema information for a single RPC method
+        #[derive(Debug, Clone)]
+        pub struct MethodSchema {
+            pub name: String,
+            pub params: ::serde_json::Value,
+            pub returns: ::serde_json::Value,
+        }
+
         pub mod client {
             use rpc_core::{Transport, Codec, Message, RpcRequest, RpcResponse, ResponseResult};
             use std::sync::Arc;
             use tokio::sync::Mutex;
             use std::sync::atomic::{AtomicU64, Ordering};
+            use std::collections::HashMap;
+            use super::MethodSchema;
 
             pub struct Client<T, C>
             where
@@ -166,6 +198,13 @@ pub fn rpc(input: TokenStream) -> TokenStream {
                     }
                 }
 
+                /// Get schema information for all RPC methods
+                pub fn schema() -> HashMap<String, MethodSchema> {
+                    let mut schema_map = HashMap::new();
+                    #(#schema_entries)*
+                    schema_map
+                }
+
                 #(#client_methods)*
             }
         }

crates/rpc-openapi/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "rpc-openapi"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+
+[dependencies]
+serde = { workspace = true }
+serde_json.workspace = true
+schema.workspace = true
+schema-openapi.workspace = true