wowlab_supabase/

client.rs

use std::{fmt, time::Duration};

use reqwest::{Client, Method, RequestBuilder, Response};
use serde::{Serialize, de::DeserializeOwned};
use wowlab_types::constants::{
    HTTP_CONNECT_TIMEOUT_SECS, HTTP_REQUEST_TIMEOUT_SECS, JSON_ERROR_PREVIEW_LEN, MS_PER_SECOND_U64,
};

use crate::{Result, SupabaseError};

const DEFAULT_RETRY_AFTER_MS: u64 = 1000;

fn require_env(name: &str) -> Result<String> {
    std::env::var(name).map_err(|error| {
        tracing::debug!(name, "Environment variable could not be read");

        SupabaseError::env_var(name, error)
    })
}

fn body_preview(body: &str) -> &str {
    let mut end = body.len().min(JSON_ERROR_PREVIEW_LEN);

    while !body.is_char_boundary(end) {
        end -= 1;
    }
    // BOUNDS: `end` starts at or below `body.len()` and only decreases to a character boundary.

    &body[..end]
}

/// HTTP client for the Supabase `PostgREST` and Storage APIs.
#[derive(Clone)]
pub struct SupabaseClient {
    pub(crate) http: Client,
    pub(crate) project_url: String,
    pub(crate) api_key: String,
}

impl SupabaseClient {
    /// Creates a client for a Supabase project and API key.
    ///
    /// # Errors
    ///
    /// Returns an error if the underlying HTTP client cannot be built.
    pub fn new(project_url: &str, api_key: &str) -> Result<Self> {
        let http = match Client::builder()
            .timeout(Duration::from_secs(HTTP_REQUEST_TIMEOUT_SECS))
            .connect_timeout(Duration::from_secs(HTTP_CONNECT_TIMEOUT_SECS))
            .build()
        {
            Ok(http) => http,
            Err(error) => return Err(SupabaseError::client_build(error)),
        };

        Ok(Self {
            http,
            project_url: project_url.trim_end_matches('/').to_string(),
            api_key: api_key.to_string(),
        })
    }

    /// Creates a client from `SUPABASE_URL` and `SUPABASE_ANON_KEY`.
    ///
    /// # Errors
    ///
    /// Returns an error when either variable is absent or the HTTP client cannot be built.
    pub fn from_env() -> Result<Self> {
        Self::from_env_key("SUPABASE_ANON_KEY")
    }

    /// Creates an administrative client from the Supabase environment variables.
    ///
    /// # Errors
    ///
    /// Returns an error when `SUPABASE_URL` or `SUPABASE_SERVICE_ROLE_KEY` is absent, or the HTTP client cannot be built.
    pub fn from_env_service_role() -> Result<Self> {
        Self::from_env_key("SUPABASE_SERVICE_ROLE_KEY")
    }

    /// Fetches a `PostgREST` resource and decodes its JSON response.
    ///
    /// # Errors
    ///
    /// Returns an error when the request fails, the server rejects it, or the response cannot be decoded as `T`.
    pub async fn get_json<T>(&self, path: &str, schema: &str) -> Result<T>
    where
        T: DeserializeOwned,
    {
        let url = self.rest_url(path);
        let response = self.send_get(&url, Some(schema)).await?;
        let body = response.text().await?;

        serde_json::from_str(&body).map_err(|error| {
            let preview = body_preview(&body);

            tracing::error!(%url, %error, body = preview, "JSON response decode failed");

            SupabaseError::decode(url, preview, error)
        })
    }

    /// Fetches a `PostgREST` resource as text.
    ///
    /// # Errors
    ///
    /// Returns an error when the request fails or the server rejects it.
    pub async fn get_text(&self, path: &str) -> Result<String> {
        let url = self.rest_url(path);

        Ok(self.send_get(&url, None).await?.text().await?)
    }

    /// Applies a partial update to a `PostgREST` resource.
    ///
    /// # Errors
    ///
    /// Returns an error when serialization, transport, or the server response fails.
    pub async fn patch<T>(&self, path: &str, body: &T) -> Result<()>
    where
        T: Serialize,
    {
        let url = self.rest_url(path);

        tracing::debug!(%url, "Sending PATCH request");
        let response = self
            .request(Method::PATCH, &url)
            .header("Content-Type", "application/json")
            .json(body)
            .send()
            .await?;

        check_response(response).await?;

        Ok(())
    }

    pub(crate) fn request(&self, method: Method, url: &str) -> RequestBuilder {
        self.http
            .request(method, url)
            .header("apikey", &self.api_key)
            .bearer_auth(&self.api_key)
    }

    fn from_env_key(key_var: &str) -> Result<Self> {
        let url = require_env("SUPABASE_URL")?;
        let key = require_env(key_var)?;

        Self::new(&url, &key)
    }

    fn rest_url(&self, path: &str) -> String {
        format!("{}/rest/v1/{path}", self.project_url)
    }

    async fn send_get(&self, url: &str, schema: Option<&str>) -> Result<Response> {
        tracing::debug!(%url, ?schema, "Sending GET request");
        let mut request = self.request(Method::GET, url);

        if let Some(schema) = schema {
            request = request.header("Accept-Profile", schema);
        }

        check_response(request.send().await?).await
    }
}

impl fmt::Debug for SupabaseClient {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("SupabaseClient")
            .field("project_url", &self.project_url)
            .field("api_key", &"<redacted>")
            .finish_non_exhaustive()
    }
}

pub(crate) async fn check_response(response: Response) -> Result<Response> {
    let status = response.status();

    if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
        let retry_after = response
            .headers()
            .get("retry-after")
            .and_then(|value| value.to_str().ok())
            .and_then(|value| value.parse::<u64>().ok());
        let retry_after_ms = retry_after.map_or(DEFAULT_RETRY_AFTER_MS, |seconds| {
            seconds.saturating_mul(MS_PER_SECOND_U64)
        });

        return Err(SupabaseError::rate_limited(retry_after_ms));
    }

    if !status.is_success() {
        let message = response.text().await?;

        return Err(SupabaseError::server(status.as_u16(), message));
    }

    Ok(response)
}