Struct APIRequestBuilder 

pub struct APIRequestBuilder { /* private fields */ }

Builder for constructing and sending HTTP requests.

This builder provides a fluent API for configuring request options like headers, body, query parameters, and timeout.

Example

use viewpoint_core::api::{APIRequestContext, APIContextOptions};

let api = APIRequestContext::new(APIContextOptions::new()).await?;

// Simple GET request
let response = api.get("https://api.example.com/users").send().await?;

// POST with JSON body
let user = serde_json::json!({ "name": "John" });
let response = api.post("https://api.example.com/users")
    .json(&user)
    .header("X-Custom", "value")
    .send()
    .await?;

Implementations

impl APIRequestBuilder

pub fn header(self, name: impl Into<String>, value: impl Into<String>) -> Self

Add a header to the request.

Example

let response = api.get("https://api.example.com/data")
    .header("Authorization", "Bearer token")
    .header("Accept", "application/json")
    .send()
    .await?;

pub fn headers( self, headers: impl IntoIterator<Item = (String, String)>, ) -> Self

Add multiple headers to the request.

pub fn query<K, V>(self, params: &[(K, V)]) -> Self

where K: AsRef<str>, V: AsRef<str>,

Add query parameters to the request URL.

Example

let response = api.get("https://api.example.com/search")
    .query(&[("q", "rust"), ("page", "1")])
    .send()
    .await?;
// Request URL: https://api.example.com/search?q=rust&page=1

pub fn query_param( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

Add a single query parameter.

pub fn json<T: Serialize>(self, data: &T) -> Self

Set the request body as JSON.

This will also set the Content-Type header to application/json.

Example

let user = serde_json::json!({
    "name": "John",
    "email": "john@example.com"
});

let response = api.post("https://api.example.com/users")
    .json(&user)
    .send()
    .await?;

pub fn form<K, V>(self, data: &[(K, V)]) -> Self

where K: AsRef<str>, V: AsRef<str>,

Set the request body as form-urlencoded data.

This will also set the Content-Type header to application/x-www-form-urlencoded.

Example

let response = api.post("https://api.example.com/login")
    .form(&[("username", "john"), ("password", "secret")])
    .send()
    .await?;

pub fn multipart(self, fields: Vec<MultipartField>) -> Self

Set the request body as multipart form data.

This is used for file uploads.

Example

let file_content = vec![1, 2, 3, 4]; // or std::fs::read("document.pdf")

let response = api.post("https://api.example.com/upload")
    .multipart(vec![
        MultipartField::text("description", "My document"),
        MultipartField::file("file", "document.pdf", file_content)
            .content_type("application/pdf"),
    ])
    .send()
    .await?;

pub fn body(self, data: Vec<u8>) -> Self

Set the request body as raw bytes.

pub fn text(self, data: impl Into<String>) -> Self

Set the request body as text.

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

Set the request timeout.

This overrides the default timeout set on the API context.

Example

use std::time::Duration;

let response = api.get("https://slow-api.example.com/data")
    .timeout(Duration::from_secs(60))
    .send()
    .await?;

pub async fn send(self) -> Result<APIResponse, APIError>

Send the request and return the response.

Errors

Returns an error if:

• The context has been disposed
• The URL is invalid
• The request fails
• A timeout occurs

Trait Implementations

impl Debug for APIRequestBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl IntoFuture for APIRequestBuilder

type Output = Result<APIResponse, APIError>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <APIRequestBuilder 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.