spiral-sdk 0.1.11

// Generated by tools/service-contracts/rust.py. Do not edit.
#![doc = "Generated reqwest client with typed errors and streaming bodies."]

use async_trait::async_trait;
use reqwest::Url;
use reqwest_middleware::ClientWithMiddleware;
use spiral_contract::auth::AuthHeader;
use spiral_contract::call::{CallError, ServiceFailure};
use spiral_contract::error::ErrorEnvelope;
use uuid::Uuid;

use crate::api::vector_indexes::VectorIndexesApi;
use crate::api::vector_indexes::objects::*;
use crate::http::default_http_client;
/// HTTP client for the vector_indexes service.
#[derive(Clone)]
pub struct VectorIndexesClient {
    http: ClientWithMiddleware,
    base: Url,
}

impl std::fmt::Debug for VectorIndexesClient {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("VectorIndexesClient")
            .field("base", &self.base)
            .finish_non_exhaustive()
    }
}

impl VectorIndexesClient {
    /// Create a redirect-disabled client; base may contain a deployment prefix.
    pub fn new(base: &str) -> Result<Self, CallError<VectorIndexesError>> {
        let http = default_http_client().map_err(CallError::transport)?;
        Self::from_http(base, http)
    }
    /// Use an existing connection pool with redirects disabled.
    pub fn from_http(
        base: &str,
        http: impl Into<ClientWithMiddleware>,
    ) -> Result<Self, CallError<VectorIndexesError>> {
        Self::from_transport(base, http.into())
    }
    /// Use a host-owned connection pool and instrumentation. Redirects must be disabled.
    pub fn from_transport(
        base: &str,
        http: ClientWithMiddleware,
    ) -> Result<Self, CallError<VectorIndexesError>> {
        let base = Url::parse(base)
            .map_err(|_| CallError::<VectorIndexesError>::protocol("invalid base URL"))?;
        if !matches!(base.scheme(), "http" | "https")
            || base.host_str().is_none()
            || !base.username().is_empty()
            || base.password().is_some()
            || base.query().is_some()
            || base.fragment().is_some()
        {
            return Err(CallError::<VectorIndexesError>::protocol(
                "invalid base URL",
            ));
        }
        Ok(Self { http, base })
    }
    /// Replace the host-owned connection pool and instrumentation. Redirects must be disabled.
    pub fn with_transport(mut self, http: ClientWithMiddleware) -> Self {
        self.http = http;
        self
    }
    /// Supply transport instrumentation or custom connection policy.
    ///
    /// The caller must disable redirects to protect bearer credentials.
    pub fn with_http(mut self, http: impl Into<ClientWithMiddleware>) -> Self {
        self.http = http.into();
        self
    }
    /// Begin an immutable build version for an exact source Table version.
    pub async fn begin_version_http(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        request: BeginVersionRequest,
    ) -> Result<BeginVersionResponse, CallError<VectorIndexesError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<VectorIndexesError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("vector-indexes");
            let segment = vector_index_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<VectorIndexesError>::protocol(
                    "dot path segment",
                ));
            }
            path.push(&segment);
            path.push("versions");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Create a Vector Index and its initial definition-only version.
    pub async fn create_vector_index_http(
        &self,
        auth_header: AuthHeader,
        request: CreateVectorIndexRequest,
    ) -> Result<CreateVectorIndexResponse, CallError<VectorIndexesError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<VectorIndexesError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("vector-indexes");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Read the definition and exact immutable version.
    pub async fn read_version_http(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        version_id: Uuid,
    ) -> Result<ReadVersionResponse, CallError<VectorIndexesError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<VectorIndexesError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("vector-indexes");
            let segment = vector_index_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<VectorIndexesError>::protocol(
                    "dot path segment",
                ));
            }
            path.push(&segment);
            path.push("versions");
            let segment = version_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<VectorIndexesError>::protocol(
                    "dot path segment",
                ));
            }
            path.push(&segment);
        }
        let builder = self.http.get(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Create an immutable definition successor without inherited build state.
    pub async fn revise_definition_http(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        request: ReviseDefinitionRequest,
    ) -> Result<ReadVersionResponse, CallError<VectorIndexesError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<VectorIndexesError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("vector-indexes");
            let segment = vector_index_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<VectorIndexesError>::protocol(
                    "dot path segment",
                ));
            }
            path.push(&segment);
            path.push("definition-versions");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Seal a build with structurally validated codec-owned physical state.
    pub async fn seal_version_http(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        version_id: Uuid,
        request: SealVersionRequest,
    ) -> Result<VersionResponse, CallError<VectorIndexesError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<VectorIndexesError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("vector-indexes");
            let segment = vector_index_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<VectorIndexesError>::protocol(
                    "dot path segment",
                ));
            }
            path.push(&segment);
            path.push("versions");
            let segment = version_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<VectorIndexesError>::protocol(
                    "dot path segment",
                ));
            }
            path.push(&segment);
            path.push("seal");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Obtain short-lived access to one version directory.
    pub async fn storage_access_http(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        request: StorageAccessRequest,
    ) -> Result<StorageAccessResponse, CallError<VectorIndexesError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<VectorIndexesError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("vector-indexes");
            let segment = vector_index_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<VectorIndexesError>::protocol(
                    "dot path segment",
                ));
            }
            path.push(&segment);
            path.push("storage-access");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    /// Obtain renewable typed storage access to one version directory.
    pub async fn storage_binding_http(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        request: StorageAccessRequest,
    ) -> Result<StorageBinding, CallError<VectorIndexesError>> {
        let mut url = self.base.clone();
        {
            let mut path = url.path_segments_mut().map_err(|_| {
                CallError::<VectorIndexesError>::protocol("base URL cannot contain path segments")
            })?;
            path.pop_if_empty();
            path.push("api");
            path.push("vector-indexes");
            let segment = vector_index_id.to_string();
            if matches!(segment.as_str(), "." | "..") {
                return Err(CallError::<VectorIndexesError>::protocol(
                    "dot path segment",
                ));
            }
            path.push(&segment);
            path.push("storage-binding");
        }
        let builder = self.http.post(url).header("accept", "application/json");
        let builder = builder.header("authorization", auth_header.as_str());
        let builder = builder
            .header("content-type", "application/json")
            .json(&request);
        let response = self.send(builder, "application/json").await?;
        let status = response.status().as_u16();
        let bytes = bounded_body(response, 8 * 1024 * 1024).await?;
        serde_json::from_slice(&bytes)
            .map_err(|_| CallError::protocol_response(status, "invalid JSON response"))
    }
    async fn send(
        &self,
        builder: reqwest_middleware::RequestBuilder,
        expected_media: &str,
    ) -> Result<reqwest::Response, CallError<VectorIndexesError>> {
        let response = builder
            .timeout(std::time::Duration::from_secs(60))
            .send()
            .await
            .map_err(CallError::transport)?;
        let status = response.status();
        if !status.is_success() {
            let status = status.as_u16();
            let content_type = response
                .headers()
                .get("content-type")
                .and_then(|value| value.to_str().ok())
                .map(str::to_owned);
            let (bytes, truncated) = bounded_error_body::<VectorIndexesError>(
                response,
                64 * 1024,
                status,
                content_type.clone(),
            )
            .await?;
            if truncated {
                return Err(CallError::unknown_remote(status, content_type, bytes, true));
            }
            return match serde_json::from_slice::<ErrorEnvelope>(&bytes) {
                Ok(envelope) => Err(CallError::Service(ServiceFailure::remote(status, envelope))),
                Err(_) => Err(CallError::unknown_remote(
                    status,
                    content_type,
                    bytes,
                    false,
                )),
            };
        }
        if !media_matches(&response, expected_media) {
            return Err(CallError::protocol_response(
                status.as_u16(),
                "unexpected response media type",
            ));
        }
        Ok(response)
    }
}

fn media_matches(response: &reqwest::Response, expected: &str) -> bool {
    response
        .headers()
        .get("content-type")
        .and_then(|value| value.to_str().ok())
        .and_then(|value| value.split(';').next())
        .is_some_and(|value| value.trim().eq_ignore_ascii_case(expected))
}

async fn bounded_body(
    mut response: reqwest::Response,
    limit: usize,
) -> Result<Vec<u8>, CallError<VectorIndexesError>> {
    let status = response.status().as_u16();
    let mut result = Vec::new();
    while let Some(chunk) = response
        .chunk()
        .await
        .map_err(|error| CallError::transport_response(status, error))?
    {
        if chunk.len() > limit.saturating_sub(result.len()) {
            return Err(CallError::protocol_response(
                status,
                "response exceeds JSON size limit",
            ));
        }
        result.extend_from_slice(&chunk);
    }
    Ok(result)
}

async fn bounded_error_body<E>(
    mut response: reqwest::Response,
    limit: usize,
    status: u16,
    content_type: Option<String>,
) -> Result<(Vec<u8>, bool), CallError<E>> {
    let mut result = Vec::new();
    loop {
        let chunk = response.chunk().await.map_err(|error| {
            CallError::unreadable_remote(status, content_type.clone(), result.clone(), error)
        })?;
        let Some(chunk) = chunk else {
            return Ok((result, false));
        };
        let remaining = limit.saturating_sub(result.len());
        if chunk.len() > remaining {
            result.extend_from_slice(&chunk[..remaining]);
            return Ok((result, true));
        }
        result.extend_from_slice(&chunk);
    }
}
#[async_trait]
impl VectorIndexesApi for VectorIndexesClient {
    async fn begin_version(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        request: BeginVersionRequest,
    ) -> Result<BeginVersionResponse, CallError<VectorIndexesError>> {
        let response =
            Self::begin_version_http(self, auth_header, vector_index_id, request).await?;
        Ok(response)
    }
    async fn create_vector_index(
        &self,
        auth_header: AuthHeader,
        request: CreateVectorIndexRequest,
    ) -> Result<CreateVectorIndexResponse, CallError<VectorIndexesError>> {
        let response = Self::create_vector_index_http(self, auth_header, request).await?;
        Ok(response)
    }
    async fn read_version(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        version_id: Uuid,
    ) -> Result<ReadVersionResponse, CallError<VectorIndexesError>> {
        let response =
            Self::read_version_http(self, auth_header, vector_index_id, version_id).await?;
        Ok(response)
    }
    async fn revise_definition(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        request: ReviseDefinitionRequest,
    ) -> Result<ReadVersionResponse, CallError<VectorIndexesError>> {
        let response =
            Self::revise_definition_http(self, auth_header, vector_index_id, request).await?;
        Ok(response)
    }
    async fn seal_version(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        version_id: Uuid,
        request: SealVersionRequest,
    ) -> Result<VersionResponse, CallError<VectorIndexesError>> {
        let response =
            Self::seal_version_http(self, auth_header, vector_index_id, version_id, request)
                .await?;
        Ok(response)
    }
    async fn storage_access(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        request: StorageAccessRequest,
    ) -> Result<StorageAccessResponse, CallError<VectorIndexesError>> {
        let response =
            Self::storage_access_http(self, auth_header, vector_index_id, request).await?;
        Ok(response)
    }
    async fn storage_binding(
        &self,
        auth_header: AuthHeader,
        vector_index_id: Uuid,
        request: StorageAccessRequest,
    ) -> Result<StorageBinding, CallError<VectorIndexesError>> {
        let response =
            Self::storage_binding_http(self, auth_header, vector_index_id, request).await?;
        Ok(response)
    }
}