# tdx Volt client library

This library provides a Rust client for the [Volt API](https://docs.tdxvolt.com) via websockets.

The client uses JSON to send requests and receive responses from the Volt.

## build

```sh
cargo build
```

## usage

The following demonstrates creating and initialising a `VoltClient` instance, and calling the `get_resource` method to retrieve a resource from the Volt.

```rust
use serde_json::json;
use volt_client_rs::{
    volt_client::VoltClient,
    websocket_rpc::{Event, EventType},
};

#[tokio::main]
async fn main() {
    // Load the Volt configuration JSON.
    let config_json = match std::fs::read_to_string("volt.config.json") {
        Ok(config_json) => config_json,
        Err(e) => {
            println!("failed to read config file: {:?}", e);
            return;
        }
    };

    // Create the Volt API client
    let mut client = match VoltClient::create(&config_json).await {
        Ok(client) => client,
        Err(e) => {
            println!("failed to create API client: {:?}", e);
            return;
        }
    };

    // Call methods on the client
    let get_request = json!({
        "resource_id": "did:volt:46c42b5f-22f1-4a7a-af76-c2eb78dbc8ca",
    });

    match client.get_resource(&get_request).await {
        Ok(response) => println!("main: received response: {:?}", response),
        Err(e) => println!("failed to get resource: {:?}", e),
    }

    // Keep the main thread alive to listen for incoming messages
    tokio::signal::ctrl_c()
        .await
        .expect("Failed to listen for ctrl_c signal");
}
```

The `get_resource` method used above is a unary RPC, i.e. it sends a single request and receives a single response. The `VoltClient` also supports server streaming and client streaming RPCs.

```rust
    // Start a `connect` call to the Volt.
    let connect_call = match client.connect(&serde_json::Value::Null).await {
        Ok(connect1) => connect1,
        Err(e) => {
            println!("failed to connect: {:?}", e);
            return;
        }
    };

    {
        // Register a callback for the `Data` event.
        let connect_rpc = connect_call.lock().await;
        connect_rpc.on(EventType::Data, |response| {
            if let Event::Data(data) = response {
                // Do something with the data
                println!("main: received data response: {:?}", data);
            }
        });

        // Send the initial connect request.
        let connect_request = json!({
          "hello": {
            "subscribe_resource_events": true,
            "accept_invocation": false,
            "ping_interval": 10000,
          },
        });

        let _ = connect_rpc.send(&connect_request).await;
    }
```