0.3.x

.github/workflows/ci.yaml

@@ -45,19 +45,25 @@ jobs:
           command: test
           args: --workspace
 
-      - name: Run tests
+      - name: Run tests (parse)
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: -p trillium-http -p trillium-client --features parse
+
+      - name: Run tests (smol)
         uses: actions-rs/cargo@v1
         with:
           command: test
           args: --workspace --features trillium-static/smol,trillium-testing/smol
 
-      - name: Run tests
+      - name: Run tests (tokio)
         uses: actions-rs/cargo@v1
         with:
           command: test
           args: --workspace --features trillium-static/tokio,trillium-testing/tokio
 
-      - name: Run tests
+      - name: Run tests (async-std)
         uses: actions-rs/cargo@v1
         with:
           command: test

.github/workflows/coverage.yml

@@ -26,7 +26,7 @@ jobs:
       - name: Rust Cache
         uses: Swatinem/[email protected]
       - name: Generate code coverage
-        run: cargo +nightly tarpaulin --verbose --features smol,trillium-testing/smol,trillium-http/serde --workspace --timeout 120 --out xml
+        run: cargo +nightly tarpaulin
       - name: Upload to codecov.io
         uses: codecov/codecov-action@v4
         with:

api/src/api_conn_ext.rs

@@ -1,161 +1,154 @@
+use crate::{Error, Result};
 use mime::Mime;
 use serde::{de::DeserializeOwned, Serialize};
+use std::future::Future;
 use trillium::{
     Conn,
     KnownHeaderName::{Accept, ContentType},
     Status,
 };
 
-use crate::{Error, Result};
-
 /// Extension trait that adds api methods to [`trillium::Conn`]
-#[trillium::async_trait]
 pub trait ApiConnExt {
-    /**
-    Sends a json response body. This sets a status code of 200,
-    serializes the body with serde_json, sets the content-type to
-    application/json, and [halts](trillium::Conn::halt) the
-    conn. If serialization fails, a 500 status code is sent as per
-    [`trillium::conn_try`]
-
-
-    ## Examples
-
-    ```
-    use trillium_api::{json, ApiConnExt};
-    async fn handler(conn: trillium::Conn) -> trillium::Conn {
-        conn.with_json(&json!({ "json macro": "is reexported" }))
-    }
-
-    # use trillium_testing::prelude::*;
-    assert_ok!(
-        get("/").on(&handler),
-        r#"{"json macro":"is reexported"}"#,
-        "content-type" => "application/json"
-    );
-    ```
-
-    ### overriding status code
-    ```
-    use trillium_api::ApiConnExt;
-    use serde::Serialize;
-
-    #[derive(Serialize)]
-    struct ApiResponse {
-       string: &'static str,
-       number: usize
-    }
-
-    async fn handler(conn: trillium::Conn) -> trillium::Conn {
-        conn.with_json(&ApiResponse { string: "not the most creative example", number: 100 })
-            .with_status(201)
-    }
-
-    # use trillium_testing::prelude::*;
-    assert_response!(
-        get("/").on(&handler),
-        Status::Created,
-        r#"{"string":"not the most creative example","number":100}"#,
-        "content-type" => "application/json"
-    );
-    ```
-    */
+    /// Sends a json response body. This sets a status code of 200,
+    /// serializes the body with serde_json, sets the content-type to
+    /// application/json, and [halts](trillium::Conn::halt) the
+    /// conn. If serialization fails, a 500 status code is sent as per
+    /// [`trillium::conn_try`]
+    ///
+    ///
+    /// ## Examples
+    ///
+    /// ```
+    /// use trillium_api::{json, ApiConnExt};
+    /// async fn handler(conn: trillium::Conn) -> trillium::Conn {
+    /// conn.with_json(&json!({ "json macro": "is reexported" }))
+    /// }
+    ///
+    /// # use trillium_testing::prelude::*;
+    /// assert_ok!(
+    /// get("/").on(&handler),
+    /// r#"{"json macro":"is reexported"}"#,
+    /// "content-type" => "application/json"
+    /// );
+    /// ```
+    ///
+    /// ### overriding status code
+    /// ```
+    /// use trillium_api::ApiConnExt;
+    /// use serde::Serialize;
+    ///
+    /// #[derive(Serialize)]
+    /// struct ApiResponse {
+    /// string: &'static str,
+    /// number: usize
+    /// }
+    ///
+    /// async fn handler(conn: trillium::Conn) -> trillium::Conn {
+    /// conn.with_json(&ApiResponse { string: "not the most creative example", number: 100 })
+    /// .with_status(201)
+    /// }
+    ///
+    /// # use trillium_testing::prelude::*;
+    /// assert_response!(
+    /// get("/").on(&handler),
+    /// Status::Created,
+    /// r#"{"string":"not the most creative example","number":100}"#,
+    /// "content-type" => "application/json"
+    /// );
+    /// ```
     fn with_json(self, response: &impl Serialize) -> Self;
 
-    /**
-    Attempts to deserialize a type from the request body, based on the
-    request content type.
-
-    By default, both application/json and
-    application/x-www-form-urlencoded are supported, and future
-    versions may add accepted request content types. Please open an
-    issue if you need to accept another content type.
-
-
-    To exclusively accept application/json, disable default features
-    on this crate.
-
-    This sets a status code of Status::Ok if and only if no status
-    code has been explicitly set.
-
-    ## Examples
-
-    ### Deserializing to [`Value`]
-
-    ```
-    use trillium_api::{ApiConnExt, Value};
-
-    async fn handler(mut conn: trillium::Conn) -> trillium::Conn {
-        let value: Value = trillium::conn_try!(conn.deserialize().await, conn);
-        conn.with_json(&value)
-    }
-
-    # use trillium_testing::prelude::*;
-    assert_ok!(
-        post("/")
-            .with_request_body(r#"key=value"#)
-            .with_request_header("content-type", "application/x-www-form-urlencoded")
-            .on(&handler),
-        r#"{"key":"value"}"#,
-        "content-type" => "application/json"
-    );
-
-    ```
-
-    ### Deserializing a concrete type
-
-    ```
-    use trillium_api::ApiConnExt;
-
-    #[derive(serde::Deserialize)]
-    struct KvPair { key: String, value: String }
-
-    async fn handler(mut conn: trillium::Conn) -> trillium::Conn {
-        match conn.deserialize().await {
-            Ok(KvPair { key, value }) => {
-                conn.with_status(201)
-                    .with_body(format!("{} is {}", key, value))
-                    .halt()
-            }
-
-            Err(_) => conn.with_status(422).with_body("nope").halt()
-        }
-    }
-
-    # use trillium_testing::prelude::*;
-    assert_response!(
-        post("/")
-            .with_request_body(r#"key=name&value=trillium"#)
-            .with_request_header("content-type", "application/x-www-form-urlencoded")
-            .on(&handler),
-        Status::Created,
-        r#"name is trillium"#,
-    );
-
-    assert_response!(
-        post("/")
-            .with_request_body(r#"name=trillium"#)
-            .with_request_header("content-type", "application/x-www-form-urlencoded")
-            .on(&handler),
-        Status::UnprocessableEntity,
-        r#"nope"#,
-    );
-
-
-    ```
-
-    */
-    async fn deserialize<T>(&mut self) -> Result<T>
+    /// Attempts to deserialize a type from the request body, based on the
+    /// request content type.
+    ///
+    /// By default, both application/json and
+    /// application/x-www-form-urlencoded are supported, and future
+    /// versions may add accepted request content types. Please open an
+    /// issue if you need to accept another content type.
+    ///
+    ///
+    /// To exclusively accept application/json, disable default features
+    /// on this crate.
+    ///
+    /// This sets a status code of Status::Ok if and only if no status
+    /// code has been explicitly set.
+    ///
+    /// ## Examples
+    ///
+    /// ### Deserializing to [`Value`]
+    ///
+    /// ```
+    /// use trillium_api::{ApiConnExt, Value};
+    ///
+    /// async fn handler(mut conn: trillium::Conn) -> trillium::Conn {
+    /// let value: Value = trillium::conn_try!(conn.deserialize().await, conn);
+    /// conn.with_json(&value)
+    /// }
+    ///
+    /// # use trillium_testing::prelude::*;
+    /// assert_ok!(
+    /// post("/")
+    /// .with_request_body(r#"key=value"#)
+    /// .with_request_header("content-type", "application/x-www-form-urlencoded")
+    /// .on(&handler),
+    /// r#"{"key":"value"}"#,
+    /// "content-type" => "application/json"
+    /// );
+    /// ```
+    ///
+    /// ### Deserializing a concrete type
+    ///
+    /// ```
+    /// use trillium_api::ApiConnExt;
+    ///
+    /// #[derive(serde::Deserialize)]
+    /// struct KvPair {
+    ///     key: String,
+    ///     value: String,
+    /// }
+    ///
+    /// async fn handler(mut conn: trillium::Conn) -> trillium::Conn {
+    ///     match conn.deserialize().await {
+    ///         Ok(KvPair { key, value }) => conn
+    ///             .with_status(201)
+    ///             .with_body(format!("{} is {}", key, value))
+    ///             .halt(),
+    ///
+    ///         Err(_) => conn.with_status(422).with_body("nope").halt(),
+    ///     }
+    /// }
+    ///
+    /// # use trillium_testing::prelude::*;
+    /// assert_response!(
+    ///     post("/")
+    ///         .with_request_body(r#"key=name&value=trillium"#)
+    ///         .with_request_header("content-type", "application/x-www-form-urlencoded")
+    ///         .on(&handler),
+    ///     Status::Created,
+    ///     r#"name is trillium"#,
+    /// );
+    ///
+    /// assert_response!(
+    ///     post("/")
+    ///         .with_request_body(r#"name=trillium"#)
+    ///         .with_request_header("content-type", "application/x-www-form-urlencoded")
+    ///         .on(&handler),
+    ///     Status::UnprocessableEntity,
+    ///     r#"nope"#,
+    /// );
+    /// ```
+    fn deserialize<T>(&mut self) -> impl Future<Output = Result<T>> + Send
     where
         T: DeserializeOwned;
 
     /// Deserializes json without any Accepts header content negotiation
-    async fn deserialize_json<T>(&mut self) -> Result<T>
+    fn deserialize_json<T>(&mut self) -> impl Future<Output = Result<T>> + Send
     where
         T: DeserializeOwned;
 
     /// Serializes the provided body using Accepts header content negotiation
-    async fn serialize<T>(&mut self, body: &T) -> Result<()>
+    fn serialize<T>(&mut self, body: &T) -> impl Future<Output = Result<()>> + Send
     where
         T: Serialize + Sync;
 
@@ -166,7 +159,6 @@ pub trait ApiConnExt {
     fn content_type(&self) -> Result<Mime>;
 }
 
-#[trillium::async_trait]
 impl ApiConnExt for Conn {
     fn with_json(mut self, response: &impl Serialize) -> Self {
         match serde_json::to_string(&response) {
@@ -261,16 +253,14 @@ impl ApiConnExt for Conn {
         match accept {
             Some(AcceptableMime::Json) => {
                 self.set_body(serde_json::to_string(body)?);
-                self.response_headers_mut()
-                    .insert(ContentType, "application/json");
+                self.insert_response_header(ContentType, "application/json");
                 Ok(())
             }
 
             #[cfg(feature = "forms")]
             Some(AcceptableMime::Form) => {
                 self.set_body(serde_urlencoded::to_string(body)?);
-                self.response_headers_mut()
-                    .insert(ContentType, "application/x-www-form-urlencoded");
+                self.insert_response_header(ContentType, "application/x-www-form-urlencoded");
                 Ok(())
             }
 

api/src/api_handler.rs

@@ -1,6 +1,6 @@
 use crate::TryFromConn;
 use std::{future::Future, marker::PhantomData, sync::Arc};
-use trillium::{async_trait, Conn, Handler, Info, Status, Upgrade};
+use trillium::{Conn, Handler, Info, Status, Upgrade};
 
 // A trait for `async fn(conn: &mut Conn, additional: Additional) -> ReturnType`
 pub trait MutBorrowConn<'conn, ReturnType, Additional>: Send + Sync + 'conn {
@@ -16,6 +16,7 @@ where
     Fut: Future<Output = ReturnType> + Send + 'conn,
 {
     type Fut = Fut;
+
     fn call(&self, conn: &'conn mut Conn, additional: Additional) -> Fut {
         self(conn, additional)
     }
@@ -78,7 +79,6 @@ where
     ApiHandler::from(api_handler)
 }
 
-#[async_trait]
 impl<TryFromConnHandler, OutputHandler, Extracted> Handler
     for ApiHandler<TryFromConnHandler, OutputHandler, Extracted>
 where