Struct ClientBuilder 

pub struct ClientBuilder<UrlState, CredentialsState> { /* private fields */ }

Builder for creating Client instances.

Uses the typestate pattern to ensure required configuration (URL and credentials) is provided at compile time.

Required Configuration

• url(): The InferaDB API endpoint
• credentials(): Authentication credentials

Optional Configuration

• retry_config(): Retry behavior for transient failures
• cache_config(): Local caching configuration
• tls_config(): Custom TLS settings
• degradation_config(): Graceful degradation behavior
• timeout(): Request timeout

Example

use inferadb::{Client, ClientCredentialsConfig, Ed25519PrivateKey};

let client = Client::builder()
    .url("https://api.inferadb.com")
    .credentials(ClientCredentialsConfig {
        client_id: "client_123".into(),
        private_key: Ed25519PrivateKey::from_pem_file("key.pem")?,
        certificate_id: None,
    })
    .retry_config(RetryConfig::new().with_max_retries(5))
    .timeout(Duration::from_secs(10))
    .build()
    .await?;

Implementations

impl ClientBuilder<NoUrl, NoCredentials>

pub fn new() -> Self

Creates a new client builder.

impl<C> ClientBuilder<NoUrl, C>

pub fn url(self, url: impl Into<String>) -> ClientBuilder<HasUrl, C>

Sets the InferaDB API URL.

Arguments

• url - The API endpoint (e.g., https://api.inferadb.com)

Example

let builder = Client::builder()
    .url("https://api.inferadb.com");

impl<U> ClientBuilder<U, NoCredentials>

pub fn credentials( self, credentials: impl Into<Credentials>, ) -> ClientBuilder<U, HasCredentials>

Sets the authentication credentials.

Accepts any type that can be converted into Credentials:

• ClientCredentialsConfig
• BearerCredentialsConfig

Example

use inferadb::{ClientCredentialsConfig, Ed25519PrivateKey};

let builder = Client::builder()
    .credentials(ClientCredentialsConfig {
        client_id: "client_123".into(),
        private_key: Ed25519PrivateKey::generate(),
        certificate_id: None,
    });

impl<U, C> ClientBuilder<U, C>

pub fn retry_config(self, config: RetryConfig) -> Self

Sets the retry configuration.

Example

use inferadb::RetryConfig;

let builder = builder.retry_config(
    RetryConfig::new().with_max_retries(5)
);

pub fn cache_config(self, config: CacheConfig) -> Self

Sets the cache configuration.

Example

use inferadb::CacheConfig;
use std::time::Duration;

let builder = builder.cache_config(
    CacheConfig::enabled().with_ttl(Duration::from_secs(60))
);

pub fn tls_config(self, config: TlsConfig) -> Self

Sets the TLS configuration.

Example

use inferadb::TlsConfig;

let builder = builder.tls_config(
    TlsConfig::new().with_ca_cert_file("/path/to/ca.crt")
);

pub fn insecure(self) -> Self

Disables TLS certificate verification and allows HTTP connections.

WARNING: This is insecure and should only be used for local development. Never use this in production.

Example

let client = Client::builder()
    .url("http://localhost:8080")
    .insecure()
    .credentials(credentials)
    .build()
    .await?;

pub fn degradation_config(self, config: DegradationConfig) -> Self

Sets the degradation configuration.

Example

use inferadb::{DegradationConfig, FailureMode};

let builder = builder.degradation_config(
    DegradationConfig::fail_closed()
);

pub fn timeout(self, timeout: Duration) -> Self

Sets the request timeout.

This timeout applies to individual API requests, not including retries.

Example

use std::time::Duration;

let builder = builder.timeout(Duration::from_secs(10));

pub fn transport_strategy(self, strategy: TransportStrategy) -> Self

Sets the transport strategy.

Controls which transport protocol(s) the client uses:

• GrpcOnly: Use gRPC only, fail if unavailable
• RestOnly: Use REST only
• PreferGrpc: Use gRPC with automatic REST fallback (default)

Example

use inferadb::TransportStrategy;

// Use gRPC only
let builder = builder.transport_strategy(TransportStrategy::GrpcOnly);

// Use REST only
let builder = builder.transport_strategy(TransportStrategy::RestOnly);

pub fn pool_config(self, config: PoolConfig) -> Self

Sets the connection pool configuration.

Controls connection pooling behavior for the transport.

Example

use inferadb::PoolConfig;
use std::time::Duration;

let builder = builder.pool_config(
    PoolConfig::default()
        .with_max_connections(20)
        .with_pool_timeout(Duration::from_secs(30))
);

impl ClientBuilder<HasUrl, HasCredentials>

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

Builds the client.

This validates the configuration and establishes the initial connection to the InferaDB service.

Errors

Returns an error if:

• The URL is invalid
• The credentials are invalid
• The initial connection fails

Example

let client = Client::builder()
    .url("https://api.inferadb.com")
    .credentials(credentials)
    .build()
    .await?;

pub async fn build_with_shutdown( self, ) -> Result<(Client, ShutdownHandle), Error>

Builds the client with a shutdown handle.

Returns both the client and a shutdown handle that can be used to initiate graceful shutdown.

Example

use tokio::signal;
use std::time::Duration;

let (client, shutdown_handle) = Client::builder()
    .url("https://api.inferadb.com")
    .credentials(credentials)
    .build_with_shutdown()
    .await?;

tokio::select! {
    _ = signal::ctrl_c() => {
        shutdown_handle.shutdown_timeout(Duration::from_secs(30)).await;
    }
    _ = run_server(client) => {}
}

Trait Implementations

impl Default for ClientBuilder<NoUrl, NoCredentials>

fn default() -> Self

Returns the “default value” for a type.