Struct 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

Errors

Will return Err if payload serialization fails.

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 fn keep_alive_interval(self, new: Duration) -> Self

Sets the interval between keep alives.

Any incoming messages automatically reset this interval so keep alives may not be sent on busy connections even if this is set.

pub fn keep_alive_retries(self, count: usize) -> Self

The number of keepalive retries before a connection is considered broken.

This defaults to 3, but has no effect if keep_alive_interval is not called.

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 multiple 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.