Struct Client 

pub struct Client<L = RpcLink> { /* private fields */ }

oRPC client for calling remote procedures.

Wraps a Link implementation and provides typed convenience methods for queries, mutations, and subscriptions.

Example

use orpc_client::Client;

let client = Client::new("http://localhost:3000/rpc");

// Query / Mutation
let planet: Planet = client.call("planet.find", &FindInput { name: "Earth".into() }).await?;

// Subscription (SSE stream)
use futures_util::StreamExt;
let mut stream = client.subscribe::<Planet>("planet.stream", &()).await?;
while let Some(result) = stream.next().await {
    let planet = result?;
    println!("New planet: {planet:?}");
}

Implementations

impl Client<RpcLink>

pub fn new(base_url: impl Into<String>) -> Self

Create a new client with a default RpcLink targeting the given base URL.

impl<L: Link> Client<L>

pub fn with_link(link: L) -> Self

Create a client with a custom Link implementation.

pub async fn call<I, O>(&self, path: &str, input: &I) -> Result<O, ClientError>

where I: Serialize, O: DeserializeOwned,

Call a procedure and deserialize the response.

Works for both queries (read) and mutations (write).

pub async fn subscribe<O>( &self, path: &str, input: &impl Serialize, ) -> Result<impl Stream<Item = Result<O, ClientError>>, ClientError>

where O: DeserializeOwned + 'static,

Subscribe to a streaming procedure.

Returns a stream of deserialized values. The stream ends when the server sends a done event or an error event.

pub async fn subscribe_from<O>( &self, path: &str, input: &impl Serialize, last_event_id: Option<u64>, ) -> Result<impl Stream<Item = Result<O, ClientError>>, ClientError>

where O: DeserializeOwned + 'static,

Subscribe with a specific last_event_id for SSE reconnection.

The server will resume from events after last_event_id.