Struct graphql_ws_client::ClientBuilder

pub struct ClientBuilder { /* private fields */ }

Builder for Graphql over Websocket clients

This can be used to configure the client prior to construction, but can also create subscriptions directly in the case where users only need to run one per connection.

use graphql_ws_client::Client;
use std::future::IntoFuture;
let (client, actor) = Client::build(connection).await?;

Implementations

impl ClientBuilder

pub fn payload<NewPayload>( self, payload: NewPayload ) -> Result<ClientBuilder, Error>

where NewPayload: Serialize,

Add payload to connection_init

pub fn subscription_buffer_size(self, new: usize) -> Self

Sets the size of the incoming message buffer that subscriptions created by this client will use

pub async fn subscribe<'a, Operation>( self, op: Operation ) -> Result<Subscription<Operation>, Error>

where Operation: GraphqlOperation + Unpin + Send + 'static,

Initialise a Client and use it to run a single subscription

use graphql_ws_client::Client;
use std::future::IntoFuture;
let stream = Client::build(connection).subscribe(subscription).await?;

Note that this takes ownership of the client, so it cannot be used to run any more operations.

If users want to run mutliple operations on a connection they should use the IntoFuture impl to construct a Client

impl ClientBuilder

pub async fn build(self) -> Result<(Client, ConnectionActor), Error>

Constructs a Client

Accepts an already built websocket connection, and returns the connection and a future that must be awaited somewhere - if the future is dropped the connection will also drop.

Trait Implementations

impl IntoFuture for ClientBuilder

type Output = Result<(Client, ConnectionActor), Error>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <ClientBuilder as IntoFuture>::Output> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.