rspc

https://github.com/specta-rs/rspc
Admin
rspc is a blazing fast and easy-to-use TRPC-like server for Rust, featuring per-request context,...
Tokens:1,088
Snippets:5
Trust Score:8.3
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### rspc-client Rust example

Source: https://github.com/specta-rs/rspc/blob/main/crates/client/README.md

This code demonstrates how to use the `rspc-client` crate to make queries to an rspc server from a Rust client. It initializes a client, executes several queries using generated bindings, and prints the results.

```Rust
// This file is generated via the `rspc::Rust` language on your server
mod bindings;

#[tokio::main]
async fn main() {
    let client = rspc_client::Client::new("http://[::]:4000/rspc");

    println!("{:?}", client.exec::<bindings::version>(()).await);
    println!(
        "{0:?}",
        client
            .exec::<bindings::echo>("Some random string!".into())
            .await
    );
    println!(
        "{0:?}",
        client
            .exec::<bindings::sendMsg>("Hello from rspc Rust client!".into())
            .await
    );
}
```

--------------------------------

### Basic Rust Invalidation Example

Source: https://github.com/specta-rs/rspc/blob/main/crates/invalidation/README.md

This is a placeholder for a basic example demonstrating the usage of rspc-invalidation in Rust. The actual implementation details and expected output are not yet available.

```rust
// TODO
```

--------------------------------

### rspc Invalidation Middleware Examples (Rust)

Source: https://github.com/specta-rs/rspc/blob/main/crates/invalidation/RESEARCH.md

Demonstrates the application of invalidation middleware in rspc using both pull-based and push-based strategies. It includes examples of how to define invalidation logic based on operation keys, inputs, and results, as well as a stream-based invalidation approach.

```rust
use rspc_invalidation::invalidation;
use std::time::Duration;

// Placeholder for procedure builder and stream macro
struct BaseProcedure {}
impl BaseProcedure {
    fn builder() -> Self { BaseProcedure {} }
    fn with<M>(self, middleware: M) -> Self { self }
    fn query<Args>(self, _args: Args) -> Self { self }
}
struct Invalidate;

macro_rules! stream {
    ($($body:tt)*) => {
        {
            // Dummy implementation for stream macro
            let _ = async {
                $($body)*
            };
            // In a real scenario, this would return a stream
            ()
        }
    };
}

// Placeholder for operation struct and methods
struct Operation {
    key: String,
    input: Input,
}
struct Input { id: String }
impl Operation {
    fn key(&self) -> &str { &self.key }
    fn input(&self) -> &Input { &self.input }
}

// Placeholder for argument type
type TArgs = ();

fn main() {
    let _ = BaseProcedure::builder()
        // "Pull"-based. Applied to queries. (I personally a "Pull"-based approach is better)
        .with(invalidation(
            |input, result, operation| operation.key() == "store.set",
        ))
        .with(invalidation(
            // TODO: how is `input().id` even gonna work lol
            |input, result, operation| {
                operation.key() == "notes.update" && operation.input().id == input.id
            },
        ))
        // "Push"-based. Applied to mutations.
        .with(invalidation(
            |input, result, invalidate| invalidate("store.get", ())),
        )
        .with(invalidation(
            |input, result, operation| invalidate("notes.get", input.id),
        ))
        // "Pull"-based but with stream.
        .with(invalidation(|input: TArgs| {
            stream! {
                // If practice subscribe to some central event bus for changes
                loop {
                    tokio::time::sleep(Duration::from_secs(5)).await;
                    yield Invalidate; // pub struct Invalidate;
                }
            }
        }))
        .query(...);
}

```

--------------------------------

### Define rspc Router with Query and Mutation

Source: https://github.com/specta-rs/rspc/blob/main/README.md

This Rust code defines a basic rspc router. It includes a 'version' query that returns a string and a 'helloWorld' mutation that returns an async string. The router is built using a fluent API, attaching procedures with specific names and associated functions.

```rust
let router = <rspc::Router>::new()
    .query("version", |t| {
        t(|ctx, input: ()| "0.0.1")
    })
    .mutation("helloWorld", |t| {
        t(|ctx, input: ()| async { "Hello World!" })
    });
```

--------------------------------

### Configure rspc cache with Memory backend

Source: https://github.com/specta-rs/rspc/blob/main/crates/cache/README.md

This Rust code demonstrates how to set up the rspc cache using a Memory backend. It configures a query 'my_query' to use the cache with a TTL of 10 seconds. The query returns the current system time.

```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())
                })
        })
}
```
Tokens:
Raw