convex-rust 0.0.0-stage → 0.1.1

package/rust/convex_reqwest/src/error.rs

@@ -0,0 +1,241 @@
+use std::{error::Error as StdError, fmt};
+
+use http::StatusCode;
+use url::Url;
+
+pub type BoxError = Box<dyn StdError + Send + Sync>;
+
+/// `Result<T, reqwest::Error>`.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// The errors that may occur when processing a `Request`.
+pub struct Error {
+    inner: Box<Inner>,
+}
+
+struct Inner {
+    kind: Kind,
+    source: Option<BoxError>,
+    url: Option<Url>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Kind {
+    Builder,
+    Request,
+    #[allow(dead_code)]
+    Redirect,
+    Status(StatusCode),
+    Body,
+    Decode,
+}
+
+/// Marker source for deadline expiry; `Error::is_timeout` looks for it.
+#[derive(Debug)]
+pub(crate) struct TimedOut;
+
+impl fmt::Display for TimedOut {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("operation timed out")
+    }
+}
+impl StdError for TimedOut {}
+
+/// Marker source for a failed host fetch (the closest thing to a connect error).
+#[derive(Debug)]
+pub(crate) struct FetchFailed(pub(crate) String);
+
+impl fmt::Display for FetchFailed {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+impl StdError for FetchFailed {}
+
+#[derive(Debug)]
+struct Message(String);
+impl fmt::Display for Message {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+impl StdError for Message {}
+
+impl Error {
+    pub(crate) fn new<E: Into<BoxError>>(kind: Kind, source: Option<E>) -> Error {
+        Error {
+            inner: Box::new(Inner {
+                kind,
+                source: source.map(Into::into),
+                url: None,
+            }),
+        }
+    }
+
+    pub(crate) fn builder<E: Into<BoxError>>(e: E) -> Error {
+        Error::new(Kind::Builder, Some(e))
+    }
+
+    pub(crate) fn builder_msg(m: impl Into<String>) -> Error {
+        Error::builder(Message(m.into()))
+    }
+
+    pub(crate) fn request<E: Into<BoxError>>(e: E) -> Error {
+        Error::new(Kind::Request, Some(e))
+    }
+
+    pub(crate) fn body<E: Into<BoxError>>(e: E) -> Error {
+        Error::new(Kind::Body, Some(e))
+    }
+
+    pub(crate) fn decode<E: Into<BoxError>>(e: E) -> Error {
+        Error::new(Kind::Decode, Some(e))
+    }
+
+    pub(crate) fn timeout(kind: Kind) -> Error {
+        Error::new(kind, Some(TimedOut))
+    }
+
+    pub(crate) fn status_code(url: Url, status: StatusCode) -> Error {
+        Error::new(Kind::Status(status), None::<BoxError>).with_url(url)
+    }
+
+    /// Returns a possible URL related to this error.
+    pub fn url(&self) -> Option<&Url> {
+        self.inner.url.as_ref()
+    }
+
+    /// Returns a mutable reference to the URL related to this error.
+    pub fn url_mut(&mut self) -> Option<&mut Url> {
+        self.inner.url.as_mut()
+    }
+
+    /// Adds a url related to this error (overwriting any existing).
+    pub fn with_url(mut self, url: Url) -> Self {
+        self.inner.url = Some(url);
+        self
+    }
+
+    /// Strips the related url from this error (if, for example, it contains
+    /// sensitive information).
+    pub fn without_url(mut self) -> Self {
+        self.inner.url = None;
+        self
+    }
+
+    /// Returns true if the error is from a type `Builder`.
+    pub fn is_builder(&self) -> bool {
+        matches!(self.inner.kind, Kind::Builder)
+    }
+
+    /// Returns true if the error is from a `RedirectPolicy`.
+    pub fn is_redirect(&self) -> bool {
+        matches!(self.inner.kind, Kind::Redirect)
+    }
+
+    /// Returns true if the error is from `Response::error_for_status`.
+    pub fn is_status(&self) -> bool {
+        matches!(self.inner.kind, Kind::Status(_))
+    }
+
+    /// Returns true if the error is related to a timeout.
+    pub fn is_timeout(&self) -> bool {
+        let mut source = self.inner.source.as_deref().map(|e| e as &dyn StdError);
+        while let Some(err) = source {
+            if err.is::<TimedOut>() {
+                return true;
+            }
+            source = err.source();
+        }
+        false
+    }
+
+    /// Returns true if the error is related to the request.
+    pub fn is_request(&self) -> bool {
+        matches!(self.inner.kind, Kind::Request)
+    }
+
+    /// Returns true if the error is related to connect (here: the host's
+    /// fetch task failed before a response head arrived).
+    pub fn is_connect(&self) -> bool {
+        let mut source = self.inner.source.as_deref().map(|e| e as &dyn StdError);
+        while let Some(err) = source {
+            if err.is::<FetchFailed>() {
+                return true;
+            }
+            source = err.source();
+        }
+        false
+    }
+
+    /// Returns true if the error is related to the request or response body.
+    pub fn is_body(&self) -> bool {
+        matches!(self.inner.kind, Kind::Body)
+    }
+
+    /// Returns true if the error is related to decoding the response's body.
+    pub fn is_decode(&self) -> bool {
+        matches!(self.inner.kind, Kind::Decode)
+    }
+
+    /// Returns the status code, if the error was generated from a response.
+    pub fn status(&self) -> Option<StatusCode> {
+        match self.inner.kind {
+            Kind::Status(code) => Some(code),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Debug for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut b = f.debug_struct("reqwest::Error");
+        b.field("kind", &self.inner.kind);
+        if let Some(url) = &self.inner.url {
+            b.field("url", &url.as_str());
+        }
+        if let Some(source) = &self.inner.source {
+            b.field("source", source);
+        }
+        b.finish()
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.inner.kind {
+            Kind::Builder => f.write_str("builder error")?,
+            Kind::Request => f.write_str("error sending request")?,
+            Kind::Body => f.write_str("request or response body error")?,
+            Kind::Decode => f.write_str("error decoding response body")?,
+            Kind::Redirect => f.write_str("error following redirect")?,
+            Kind::Status(code) => {
+                let prefix = if code.is_client_error() {
+                    "HTTP status client error"
+                } else {
+                    "HTTP status server error"
+                };
+                write!(f, "{prefix} ({code})")?;
+            }
+        }
+        if let Some(url) = &self.inner.url {
+            write!(f, " for url ({url})")?;
+        }
+        if let Some(e) = &self.inner.source {
+            write!(f, ": {e}")?;
+        }
+        Ok(())
+    }
+}
+
+impl StdError for Error {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.inner.source.as_ref().map(|e| &**e as _)
+    }
+}
+
+impl From<Error> for std::io::Error {
+    fn from(e: Error) -> Self {
+        std::io::Error::other(e)
+    }
+}

package/rust/convex_reqwest/src/into_url.rs

@@ -0,0 +1,57 @@
+use url::Url;
+
+use crate::error::{Error, Result};
+
+/// A trait to try to convert some type into a `Url`.
+pub trait IntoUrl: IntoUrlSealed {}
+
+impl IntoUrl for Url {}
+impl IntoUrl for String {}
+impl IntoUrl for &str {}
+impl IntoUrl for &String {}
+
+#[doc(hidden)]
+pub trait IntoUrlSealed {
+    fn into_url(self) -> Result<Url>;
+    fn as_str(&self) -> &str;
+}
+
+impl IntoUrlSealed for Url {
+    fn into_url(self) -> Result<Url> {
+        if self.has_host() {
+            Ok(self)
+        } else {
+            Err(Error::builder_msg("URL scheme is not allowed").with_url(self))
+        }
+    }
+    fn as_str(&self) -> &str {
+        self.as_ref()
+    }
+}
+
+impl IntoUrlSealed for &str {
+    fn into_url(self) -> Result<Url> {
+        Url::parse(self).map_err(Error::builder)?.into_url()
+    }
+    fn as_str(&self) -> &str {
+        self
+    }
+}
+
+impl IntoUrlSealed for &String {
+    fn into_url(self) -> Result<Url> {
+        (&**self).into_url()
+    }
+    fn as_str(&self) -> &str {
+        self.as_ref()
+    }
+}
+
+impl IntoUrlSealed for String {
+    fn into_url(self) -> Result<Url> {
+        (&*self).into_url()
+    }
+    fn as_str(&self) -> &str {
+        self.as_ref()
+    }
+}

package/rust/convex_reqwest/src/lib.rs

@@ -0,0 +1,42 @@
+//! `reqwest`-compatible HTTP client for `"use rust"` actions (DX-06, D-010).
+//!
+//! This crate is named `reqwest` and is swapped in with
+//! `[patch.crates-io] reqwest = { path = ... }` (the Convex CLI writes that
+//! into `convex/rust/.cargo/config.toml`). Vendor crates built on reqwest then
+//! send their requests through `convex_fn`'s `Fetch` task, so they keep the
+//! host's egress policy, limits, metering and logs.
+//!
+//! Notes on fidelity:
+//! - Needs the SDK's tokio runtime (`convex_fn` feature `tokio-rt`, enabled by
+//!   this crate): timeouts use `tokio::time`.
+//! - TLS, proxies, pooling, compression, cookies and redirects are the host's;
+//!   the builder options for them are accepted and ignored.
+//! - Response bodies arrive in the chunks the host delivers.
+//! - Only UTF-8 text decoding is supported.
+
+pub mod blocking;
+mod body;
+mod client;
+mod config_types;
+mod error;
+mod into_url;
+pub mod multipart;
+mod request;
+mod response;
+
+pub use bytes::Bytes;
+pub use http::{header, Method, StatusCode, Version};
+pub use url::Url;
+
+pub use self::body::Body;
+pub use self::client::{Client, ClientBuilder};
+pub use self::config_types::{redirect, tls, Proxy};
+pub use self::error::{Error, Result};
+pub use self::into_url::IntoUrl;
+pub use self::request::{Request, RequestBuilder};
+pub use self::response::{Response, ResponseBuilderExt};
+
+/// Shortcut method to quickly make a `GET` request.
+pub async fn get<T: IntoUrl>(url: T) -> Result<Response> {
+    Client::builder().build()?.get(url).send().await
+}

package/rust/convex_reqwest/src/multipart.rs

@@ -0,0 +1,140 @@
+//! `multipart/form-data` bodies, buffered (the host fetch task takes one body).
+
+use std::{
+    borrow::Cow,
+    sync::atomic::{AtomicU64, Ordering},
+};
+
+use http::header::HeaderMap;
+
+use crate::error::{Error, Result};
+
+/// A multipart/form-data request body.
+#[derive(Debug)]
+pub struct Form {
+    boundary: String,
+    parts: Vec<(Cow<'static, str>, Part)>,
+}
+
+/// A field in a multipart form.
+#[derive(Debug)]
+pub struct Part {
+    data: Vec<u8>,
+    mime: Option<String>,
+    file_name: Option<Cow<'static, str>>,
+    headers: HeaderMap,
+}
+
+impl Default for Form {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Form {
+    pub fn new() -> Form {
+        static COUNTER: AtomicU64 = AtomicU64::new(0);
+        let nanos = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_or(0, |d| d.as_nanos() as u64);
+        let n = COUNTER.fetch_add(1, Ordering::Relaxed);
+        Form {
+            boundary: format!("{nanos:016x}{n:016x}"),
+            parts: vec![],
+        }
+    }
+
+    pub fn boundary(&self) -> &str {
+        &self.boundary
+    }
+
+    pub fn text<T, U>(self, name: T, value: U) -> Form
+    where
+        T: Into<Cow<'static, str>>,
+        U: Into<Cow<'static, str>>,
+    {
+        self.part(name, Part::text(value))
+    }
+
+    pub fn part<T: Into<Cow<'static, str>>>(mut self, name: T, part: Part) -> Form {
+        self.parts.push((name.into(), part));
+        self
+    }
+
+    pub(crate) fn into_bytes(self) -> Vec<u8> {
+        let mut out = Vec::new();
+        for (name, part) in &self.parts {
+            out.extend_from_slice(format!("--{}\r\n", self.boundary).as_bytes());
+            let mut disp = format!("Content-Disposition: form-data; name=\"{}\"", escape(name));
+            if let Some(f) = &part.file_name {
+                disp.push_str(&format!("; filename=\"{}\"", escape(f)));
+            }
+            out.extend_from_slice(disp.as_bytes());
+            out.extend_from_slice(b"\r\n");
+            if let Some(m) = &part.mime {
+                out.extend_from_slice(format!("Content-Type: {m}\r\n").as_bytes());
+            }
+            for (k, v) in &part.headers {
+                out.extend_from_slice(k.as_str().as_bytes());
+                out.extend_from_slice(b": ");
+                out.extend_from_slice(v.as_bytes());
+                out.extend_from_slice(b"\r\n");
+            }
+            out.extend_from_slice(b"\r\n");
+            out.extend_from_slice(&part.data);
+            out.extend_from_slice(b"\r\n");
+        }
+        out.extend_from_slice(format!("--{}--\r\n", self.boundary).as_bytes());
+        out
+    }
+}
+
+fn escape(s: &str) -> String {
+    s.replace('\\', "\\\\")
+        .replace('"', "\\\"")
+        .replace('\r', "%0D")
+        .replace('\n', "%0A")
+}
+
+impl Part {
+    pub fn text<T: Into<Cow<'static, str>>>(value: T) -> Part {
+        Part::bytes(value.into().into_owned().into_bytes())
+    }
+
+    pub fn bytes<T: Into<Cow<'static, [u8]>>>(value: T) -> Part {
+        Part {
+            data: value.into().into_owned(),
+            mime: None,
+            file_name: None,
+            headers: HeaderMap::new(),
+        }
+    }
+
+    pub fn file_name<T: Into<Cow<'static, str>>>(mut self, filename: T) -> Part {
+        self.file_name = Some(filename.into());
+        self
+    }
+
+    pub fn mime_str(mut self, mime: &str) -> Result<Part> {
+        let m: mime_check::Mime = mime_check::parse(mime)?;
+        self.mime = Some(m);
+        Ok(self)
+    }
+
+    pub fn headers(mut self, headers: HeaderMap) -> Part {
+        self.headers = headers;
+        self
+    }
+}
+
+mod mime_check {
+    use super::*;
+    pub type Mime = String;
+    pub fn parse(s: &str) -> Result<Mime> {
+        if s.contains('/') && !s.contains(['\r', '\n']) {
+            Ok(s.to_string())
+        } else {
+            Err(Error::builder_msg(format!("invalid mime type: {s}")))
+        }
+    }
+}