Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
13.6 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

use crate::api::generated::GeneratedClient;
use crate::{config::AdminConfig, session::Session};
use progenitor_client::ClientInfo;
use reqwest::header::{AUTHORIZATION, HeaderMap, HeaderName, HeaderValue};
use reqwest::{Method, RequestBuilder};
use serde::Serialize;
use serde::de::DeserializeOwned;

#[derive(Debug)]
pub enum ApiError {
    Network(String),
    Http {
        status: u16,
        message: String,
        details: Option<Box<ApiErrorDetails>>,
    },
    Parse(String),
}

#[derive(Debug)]
pub struct ApiErrorDetails {
    message: Option<String>,
    errors: Vec<ApiFieldError>,
}

#[derive(Debug)]
struct ApiFieldError {
    path: Option<String>,
    message: Option<String>,
}

impl ApiErrorDetails {
    fn parse(message: &str) -> Option<Self> {
        let body: serde_json::Value = serde_json::from_str(message).ok()?;
        let errors = body["errors"]
            .as_array()
            .into_iter()
            .flatten()
            .map(|error| ApiFieldError {
                path: error["path"].as_str().map(str::to_owned),
                message: error["message"].as_str().map(str::to_owned),
            })
            .collect();
        Some(Self {
            message: body["message"].as_str().map(str::to_owned),
            errors,
        })
    }
}

impl ApiError {
    pub fn http(status: u16, message: impl Into<String>) -> Self {
        let message = message.into();
        let details = ApiErrorDetails::parse(&message).map(Box::new);
        Self::Http {
            status,
            message,
            details,
        }
    }

    pub fn refusal_message(&self, fallback: &str) -> String {
        let Self::Http {
            details: Some(details),
            ..
        } = self
        else {
            return fallback.to_owned();
        };
        details.message.as_ref().map_or_else(
            || fallback.to_owned(),
            |detail| format!("{fallback}: {detail}"),
        )
    }

    pub fn validation_message(&self) -> Option<String> {
        let Self::Http {
            status: 400,
            details: Some(details),
            ..
        } = self
        else {
            return None;
        };
        let detail = details.errors.first().and_then(|error| {
            let message = error.message.as_ref()?;
            Some(
                match error.path.as_deref().filter(|path| !path.is_empty()) {
                    Some(path) => format!("{path}: {message}"),
                    None => message.to_owned(),
                },
            )
        });
        detail.or_else(|| details.message.clone())
    }

    pub fn detail_message(&self) -> Option<String> {
        let Self::Http {
            status: 400 | 403 | 404 | 409,
            details: Some(details),
            ..
        } = self
        else {
            return None;
        };
        details
            .errors
            .first()
            .and_then(|error| error.message.as_ref())
            .or(details.message.as_ref())
            .cloned()
    }

    pub fn field_errors(&self) -> Vec<(String, String)> {
        let Self::Http {
            status: 400,
            details: Some(details),
            ..
        } = self
        else {
            return Vec::new();
        };
        details
            .errors
            .iter()
            .filter_map(|error| Some((error.path.clone()?, error.message.clone()?)))
            .collect()
    }

    pub fn has_field_error(&self, path: &str) -> bool {
        let Self::Http {
            details: Some(details),
            ..
        } = self
        else {
            return false;
        };
        details
            .errors
            .iter()
            .any(|error| error.path.as_deref() == Some(path))
    }
}

pub type ApiResult<T> = Result<T, ApiError>;

const INTERNAL_ADMIN_PROXY_CLIENT_IP: &str = "127.0.0.1";

pub trait ApiResultExt<T> {
    fn log_error(self, context: &str) -> Option<T>;
}

impl<T> ApiResultExt<T> for ApiResult<T> {
    fn log_error(self, context: &str) -> Option<T> {
        match self {
            Ok(value) => Some(value),
            Err(error) => {
                tracing::warn!(%context, %error, "admin API request failed");
                None
            }
        }
    }
}

pub struct AdminApiClient {
    generated: GeneratedClient,
}

impl AdminApiClient {
    pub fn new(http_client: &reqwest::Client, config: &AdminConfig, session: &Session) -> Self {
        let generated = GeneratedClient::new_with_client(
            &config.api_endpoint,
            http_client.clone(),
            build_session_headers(config, session),
        );
        Self { generated }
    }

    pub fn anonymous(http_client: &reqwest::Client, config: &AdminConfig) -> Self {
        let generated = GeneratedClient::new_with_client(
            &config.api_endpoint,
            http_client.clone(),
            build_proxy_client_ip_headers(config),
        );
        Self { generated }
    }

    fn build_url(&self, path: &str, query_params: Option<&[(&str, &str)]>) -> String {
        let mut url = format!("{}{}", self.generated.baseurl(), path);
        let query = query_params
            .unwrap_or_default()
            .iter()
            .filter(|(_, value)| !value.is_empty())
            .map(|(key, value)| {
                format!(
                    "{}={}",
                    urlencoding::encode(key),
                    urlencoding::encode(value)
                )
            })
            .collect::<Vec<_>>()
            .join("&");
        if !query.is_empty() {
            url.push('?');
            url.push_str(&query);
        }
        url
    }

    fn request(
        &self,
        method: Method,
        path: &str,
        query_params: Option<&[(&str, &str)]>,
        audit_log_reason: Option<&str>,
    ) -> ApiResult<RequestBuilder> {
        let url = self.build_url(path, query_params);
        Ok(self
            .generated
            .client()
            .request(method, &url)
            .header("Content-Type", "application/json")
            .headers(self.headers_with_reason(audit_log_reason)?))
    }

    fn headers_with_reason(&self, audit_log_reason: Option<&str>) -> ApiResult<HeaderMap> {
        let mut headers = self.generated.inner().clone();
        if let Some(reason) = audit_log_reason {
            headers.insert("x-audit-log-reason", audit_log_reason_header(reason)?);
        }
        Ok(headers)
    }

    async fn send_request(builder: RequestBuilder) -> ApiResult<reqwest::Response> {
        builder
            .send()
            .await
            .map_err(|e| ApiError::Network(e.to_string()))
    }

    async fn send_json<B: Serialize + ?Sized>(
        &self,
        method: Method,
        path: &str,
        body: Option<&B>,
        audit_log_reason: Option<&str>,
    ) -> ApiResult<reqwest::Response> {
        let builder = self.request(method, path, None, audit_log_reason)?;
        let builder = match body {
            Some(body) => builder.json(body),
            None => builder,
        };
        Self::send_request(builder).await
    }

    pub async fn get<T: DeserializeOwned>(
        &self,
        path: &str,
        query_params: Option<&[(&str, &str)]>,
    ) -> ApiResult<T> {
        let response =
            Self::send_request(self.request(Method::GET, path, query_params, None)?).await?;
        Self::parse_response(response).await
    }

    pub async fn get_bytes(&self, path: &str) -> ApiResult<(String, Vec<u8>)> {
        let response = Self::send_request(self.request(Method::GET, path, None, None)?).await?;
        let response = Self::check_response_status(response).await?;
        let content_type = response
            .headers()
            .get(reqwest::header::CONTENT_TYPE)
            .and_then(|value| value.to_str().ok())
            .unwrap_or("application/octet-stream")
            .to_owned();
        let body = response
            .bytes()
            .await
            .map_err(|e| ApiError::Network(e.to_string()))?;
        Ok((content_type, body.to_vec()))
    }

    pub async fn send<T, B>(
        &self,
        method: Method,
        path: &str,
        body: Option<&B>,
        audit_log_reason: Option<&str>,
    ) -> ApiResult<T>
    where
        T: DeserializeOwned,
        B: Serialize + ?Sized,
    {
        let response = self.send_json(method, path, body, audit_log_reason).await?;
        Self::parse_response(response).await
    }

    pub async fn send_void<B: Serialize + ?Sized>(
        &self,
        method: Method,
        path: &str,
        body: Option<&B>,
        audit_log_reason: Option<&str>,
    ) -> ApiResult<()> {
        let response = self.send_json(method, path, body, audit_log_reason).await?;
        Self::parse_void_response(response).await
    }

    async fn parse_void_response(response: reqwest::Response) -> ApiResult<()> {
        Self::check_response_status(response).await.map(drop)
    }

    async fn check_response_status(response: reqwest::Response) -> ApiResult<reqwest::Response> {
        if response.status().is_success() {
            return Ok(response);
        }
        let status = response.status().as_u16();
        let message = response.text().await.map_err(|error| {
            ApiError::Network(format!("failed to read error response body: {error}"))
        })?;
        Err(ApiError::http(status, message))
    }

    pub(crate) fn generated(&self) -> &GeneratedClient {
        &self.generated
    }

    pub(crate) fn generated_with_reason(
        &self,
        audit_log_reason: Option<&str>,
    ) -> ApiResult<GeneratedClient> {
        Ok(GeneratedClient::new_with_client(
            self.generated.baseurl(),
            self.generated.client().clone(),
            self.headers_with_reason(audit_log_reason)?,
        ))
    }

    pub(crate) fn generated_value<T, U>(&self, value: U) -> ApiResult<T>
    where
        T: DeserializeOwned,
        U: Serialize,
    {
        let json = serde_json::to_value(value).map_err(|e| ApiError::Parse(e.to_string()))?;
        serde_json::from_value(json).map_err(|e| ApiError::Parse(e.to_string()))
    }

    pub(crate) fn generated_error<E: std::fmt::Debug + Serialize>(
        &self,
        error: progenitor_client::Error<E>,
    ) -> ApiError {
        if let progenitor_client::Error::InvalidResponsePayload(_, err) = &error {
            return ApiError::Parse(format!("invalid response payload: {err}"));
        }
        let message = match &error {
            progenitor_client::Error::ErrorResponse(response) => {
                serde_json::to_string(response.as_ref()).unwrap_or_else(|_| format!("{error:?}"))
            }
            _ => format!("{error:?}"),
        };
        match error.status() {
            Some(status) => ApiError::http(status.as_u16(), message),
            None => ApiError::Network(message),
        }
    }

    async fn parse_response<T: DeserializeOwned>(response: reqwest::Response) -> ApiResult<T> {
        let response = Self::check_response_status(response).await?;
        let text = if response.status() == reqwest::StatusCode::NO_CONTENT {
            String::new()
        } else {
            response
                .text()
                .await
                .map_err(|e| ApiError::Network(e.to_string()))?
        };
        if text.is_empty() {
            return serde_json::from_value(serde_json::Value::Null)
                .map_err(|e| ApiError::Parse(e.to_string()));
        }
        serde_json::from_str(&text).map_err(|e| ApiError::Parse(e.to_string()))
    }
}

fn build_session_headers(config: &AdminConfig, session: &Session) -> HeaderMap {
    let mut headers = HeaderMap::new();
    let mut auth_value = HeaderValue::from_str(&format!("Bearer {}", session.access_token))
        .expect("failed to build generated API Authorization header");
    auth_value.set_sensitive(true);
    headers.insert(AUTHORIZATION, auth_value);
    headers.extend(build_proxy_client_ip_headers(config));
    headers
}

pub(crate) fn with_proxy_client_ip_header(
    builder: RequestBuilder,
    config: &AdminConfig,
) -> RequestBuilder {
    match proxy_client_ip_header_name(config) {
        Some(name) => builder.header(name, INTERNAL_ADMIN_PROXY_CLIENT_IP),
        None => builder,
    }
}

fn build_proxy_client_ip_headers(config: &AdminConfig) -> HeaderMap {
    let mut headers = HeaderMap::new();
    if let Some(name) = proxy_client_ip_header_name(config) {
        headers.insert(
            name,
            HeaderValue::from_static(INTERNAL_ADMIN_PROXY_CLIENT_IP),
        );
    }
    headers
}

fn proxy_client_ip_header_name(config: &AdminConfig) -> Option<HeaderName> {
    if !config.proxy.trust_client_ip_header {
        return None;
    }
    match HeaderName::from_bytes(config.proxy.client_ip_header_name.as_bytes()) {
        Ok(name) => Some(name),
        Err(error) => {
            tracing::warn!(
                header = %config.proxy.client_ip_header_name,
                %error,
                "invalid admin client IP header name; internal API calls may be rejected"
            );
            None
        }
    }
}

impl std::fmt::Display for ApiError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Network(msg) => write!(f, "network error: {msg}"),
            Self::Http {
                status, message, ..
            } => write!(f, "HTTP {status}: {message}"),
            Self::Parse(msg) => write!(f, "parse error: {msg}"),
        }
    }
}

fn audit_log_reason_header(reason: &str) -> ApiResult<HeaderValue> {
    let mut value = HeaderValue::from_bytes(reason.as_bytes())
        .map_err(|_| ApiError::Parse("invalid audit log reason header".to_owned()))?;
    value.set_sensitive(true);
    Ok(value)
}