rustolio_utils/http/response/

mod.rs

//
// SPDX-License-Identifier: MPL-2.0
//
// Copyright (c) 2026 Tobias Binnewies. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
//

#[cfg(not(target_arch = "wasm32"))]
mod builder;

use bytes::Bytes;

use crate::bytes::IntoUtf8Bytes;
#[cfg(not(target_arch = "wasm32"))]
use crate::threadsafe;

use super::{Error, HeaderName, HeaderValue, Incoming, Outgoing, Result, StatusCode, Version};

#[cfg(not(target_arch = "wasm32"))]
pub use builder::Builder;

pub struct Response<B = Outgoing>(
    #[cfg(target_arch = "wasm32")] web_sys::Response,
    #[cfg(target_arch = "wasm32")] B,
    #[cfg(not(target_arch = "wasm32"))] http::Response<B>,
);

impl Response<Incoming> {
    #[cfg(not(target_arch = "wasm32"))]
    pub fn from_inner(res: http::Response<Incoming>) -> Self {
        Self(res)
    }
    #[cfg(target_arch = "wasm32")]
    pub fn from_inner(res: web_sys::Response) -> Self {
        Self(res, Incoming)
    }
}

impl Response<Outgoing> {
    #[cfg(not(target_arch = "wasm32"))]
    pub fn into_inner(self) -> http::Response<Outgoing> {
        self.0
    }
}

impl Response<()> {
    #[cfg(not(target_arch = "wasm32"))]
    pub fn builder() -> Builder<()> {
        Builder::new()
    }
}

impl<B> Response<B> {
    pub fn status(&self) -> StatusCode {
        #[cfg(target_arch = "wasm32")]
        {
            StatusCode::try_from(self.0.status())
                .expect("Response must contain a valid status code")
        }
        #[cfg(not(target_arch = "wasm32"))]
        {
            self.0.status()
        }
    }

    #[cfg(not(target_arch = "wasm32"))]
    pub fn header(&self, key: impl IntoUtf8Bytes) -> Option<&HeaderValue> {
        let key = key.into();
        let key: http::HeaderName = key.to_vec().try_into().ok()?;
        self.0.headers().get(&key)
    }

    pub fn is_success(&self) -> bool {
        self.status().is_success()
    }

    pub fn body(&self) -> &B {
        #[cfg(target_arch = "wasm32")]
        {
            &self.1
        }
        #[cfg(not(target_arch = "wasm32"))]
        {
            self.0.body()
        }
    }

    pub fn into_body(self) -> B {
        #[cfg(target_arch = "wasm32")]
        {
            self.1
        }
        #[cfg(not(target_arch = "wasm32"))]
        {
            self.0.into_body()
        }
    }
}

#[cfg(target_arch = "wasm32")]
impl Response<Incoming> {
    pub async fn text(self) -> Result<Response<String>> {
        let text = wasm_bindgen_futures::JsFuture::from(self.0.text().map_err(|_| Error::Recv)?)
            .await
            .map_err(|_| Error::Recv)?;
        let text = text.try_into().map_err(|_| Error::Parse)?;
        Ok(Response(self.0, text))
    }

    pub async fn json<T: serde::de::DeserializeOwned>(self) -> Result<Response<T>> {
        let json = wasm_bindgen_futures::JsFuture::from(self.0.json().map_err(|_| Error::Recv)?)
            .await
            .map_err(|_| Error::Recv)?;
        let json = serde_wasm_bindgen::from_value(json).map_err(|_| Error::Parse)?;
        Ok(Response(self.0, json))
    }

    // TODO: Decode using the stream instead of collecting all bytes first
    pub async fn encoded<T: crate::prelude::Decode>(self) -> Result<Response<T>> {
        self.bytes().await.and_then(|b| {
            let decoded: T =
                crate::bytes::encoding::decode_from_bytes(b.1).map_err(|_| Error::Parse)?;
            Ok(Response(b.0, decoded))
        })
    }

    pub async fn bytes(self) -> Result<Response<Bytes>> {
        let bytes =
            wasm_bindgen_futures::JsFuture::from(self.0.array_buffer().map_err(|_| Error::Recv)?)
                .await
                .map_err(|_| Error::Recv)?;
        let bytes = Bytes::from_owner(js_sys::Uint8Array::new(&bytes).to_vec());
        Ok(Response(self.0, bytes))
    }
}

#[cfg(not(target_arch = "wasm32"))]
impl<B> Response<B>
where
    B: hyper::body::Body<Error: threadsafe::Error>,
{
    pub async fn text(self) -> Result<Response<String>> {
        use http_body_util::BodyExt;

        let (parts, body) = self.0.into_parts();

        let body = body.collect().await.map_err(Error::body)?;
        let Ok(text) = String::from_utf8(body.to_bytes().to_vec()) else {
            return Err(Error::InvalidType);
        };

        Ok(Response(http::Response::from_parts(parts, text)))
    }

    pub async fn json<T: serde::de::DeserializeOwned>(self) -> Result<Response<T>> {
        use http_body_util::BodyExt;

        let Some(ty) = self.header(HeaderName::CONTENT_TYPE) else {
            return Err(Error::InvalidType);
        };
        if !ty
            .to_str()
            .map_err(|_| Error::InvalidType)?
            .starts_with("application/json")
        {
            return Err(Error::InvalidType);
        }

        let (parts, body) = self.0.into_parts();

        let body = body.collect().await.map_err(Error::body)?;
        let Ok(json) = serde_json::from_slice(&body.to_bytes()) else {
            return Err(Error::InvalidType);
        };

        Ok(Response(http::Response::from_parts(parts, json)))
    }

    // TODO: Decode using the stream instead of collecting all bytes first
    pub async fn encoded<T: crate::prelude::Decode>(self) -> Result<Response<T>> {
        self.bytes().await.and_then(|b| {
            let (parts, body) = b.0.into_parts();

            let decoded: T =
                crate::bytes::encoding::decode_from_bytes(body).map_err(Error::body)?;

            Ok(Response(http::Response::from_parts(parts, decoded)))
        })
    }

    pub async fn bytes(self) -> Result<Response<Bytes>> {
        use http_body_util::BodyExt;

        let (parts, body) = self.0.into_parts();

        let body = body.collect().await.map_err(Error::body)?;
        let bytes = body.to_bytes();

        Ok(Response(http::Response::from_parts(parts, bytes)))
    }
}