Merge pull request #438 from http-rs/errors

Enable use of `?` in Endpoint

Author: yoshuawuyts

examples/chunked.rs

@@ -10,7 +10,7 @@ fn main() -> Result<(), std::io::Error> {
         app.at("/").get(|_| async move {
             let file = fs::File::open(file!()).await.unwrap();
             let res = Response::new(StatusCode::Ok).body(BufReader::new(file));
-            res
+            Ok(res)
         });
         app.listen("127.0.0.1:8080").await?;
         Ok(())

examples/cookies.rs

@@ -5,20 +5,20 @@ use tide::{Request, Response};
 
 /// Tide will use the the `Cookies`'s `Extract` implementation to build this parameter.
 ///
-async fn retrieve_cookie(cx: Request<()>) -> String {
-    format!("hello cookies: {:?}", cx.cookie("hello").unwrap())
+async fn retrieve_cookie(cx: Request<()>) -> tide::Result<String> {
+    Ok(format!("hello cookies: {:?}", cx.cookie("hello").unwrap()))
 }
 
-async fn set_cookie(_req: Request<()>) -> Response {
+async fn set_cookie(_req: Request<()>) -> tide::Result<Response> {
     let mut res = tide::Response::new(StatusCode::Ok);
     res.set_cookie(Cookie::new("hello", "world"));
-    res
+    Ok(res)
 }
 
-async fn remove_cookie(_req: Request<()>) -> Response {
+async fn remove_cookie(_req: Request<()>) -> tide::Result<Response> {
     let mut res = tide::Response::new(StatusCode::Ok);
     res.remove_cookie(Cookie::named("hello"));
-    res
+    Ok(res)
 }
 
 fn main() -> Result<(), std::io::Error> {

examples/fib.rs

@@ -9,7 +9,7 @@ fn fib(n: usize) -> usize {
     }
 }
 
-async fn fibsum(req: Request<()>) -> String {
+async fn fibsum(req: Request<()>) -> tide::Result<String> {
     use std::time::Instant;
     let n: usize = req.param("n").unwrap_or(0);
     // Start a stopwatch
@@ -19,10 +19,11 @@ async fn fibsum(req: Request<()>) -> String {
     // Stop the stopwatch
     let duration = Instant::now().duration_since(start).as_secs();
     // Return the answer
-    format!(
+    let res = format!(
         "The fib of {} is {}.\nIt was computed in {} secs.\n",
         n, fib_n, duration,
-    )
+    );
+    Ok(res)
 }
 // Example: HTTP GET to http://localhost:8080/fib/42
 // $ curl "http://localhost:8080/fib/42"

examples/graphql.rs

@@ -73,7 +73,7 @@ fn create_schema() -> Schema {
     Schema::new(QueryRoot {}, MutationRoot {})
 }
 
-async fn handle_graphql(mut cx: Request<State>) -> Response {
+async fn handle_graphql(mut cx: Request<State>) -> tide::Result<Response> {
     let query: juniper::http::GraphQLRequest = cx
         .body_json()
         .await
@@ -87,15 +87,17 @@ async fn handle_graphql(mut cx: Request<State>) -> Response {
         StatusCode::BadRequest
     };
 
-    Response::new(status)
+    let res = Response::new(status)
         .body_json(&response)
-        .expect("be able to serialize the graphql response")
+        .expect("be able to serialize the graphql response");
+    Ok(res)
 }
 
-async fn handle_graphiql(_: Request<State>) -> Response {
-    Response::new(StatusCode::Ok)
+async fn handle_graphiql(_: Request<State>) -> tide::Result<Response> {
+    let res = Response::new(StatusCode::Ok)
         .body_string(juniper::http::graphiql::graphiql_source("/graphql"))
-        .set_header("content-type".parse().unwrap(), "text/html;charset=utf-8")
+        .set_header("content-type".parse().unwrap(), "text/html;charset=utf-8");
+    Ok(res)
 }
 
 fn main() -> std::io::Result<()> {

examples/hello.rs

@@ -3,7 +3,7 @@ use async_std::task;
 fn main() -> Result<(), std::io::Error> {
     task::block_on(async {
         let mut app = tide::new();
-        app.at("/").get(|_| async move { "Hello, world!" });
+        app.at("/").get(|_| async move { Ok("Hello, world!") });
         app.listen("127.0.0.1:8080").await?;
         Ok(())
     })

examples/json.rs

@@ -14,14 +14,14 @@ fn main() -> io::Result<()> {
 
         app.at("/submit")
             .post(|mut req: tide::Request<()>| async move {
-                let cat: Cat = req.body_json().await.unwrap();
+                let cat: Cat = req.body_json().await?;
                 println!("cat name: {}", cat.name);
 
                 let cat = Cat {
                     name: "chashu".into(),
                 };
 
-                tide::Response::new(StatusCode::Ok).body_json(&cat).unwrap()
+                Ok(tide::Response::new(StatusCode::Ok).body_json(&cat)?)
             });
 
         app.listen("127.0.0.1:8080").await?;

src/endpoint.rs

@@ -1,10 +1,11 @@
-use std::sync::Arc;
-
+use crate::response::IntoResponse;
 use async_std::future::Future;
+use async_std::sync::Arc;
+use http_types::Result;
 
 use crate::middleware::Next;
 use crate::utils::BoxFuture;
-use crate::{response::IntoResponse, Middleware, Request, Response};
+use crate::{Middleware, Request, Response};
 
 /// An HTTP request handler.
 ///
@@ -23,8 +24,8 @@ use crate::{response::IntoResponse, Middleware, Request, Response};
 /// A simple endpoint that is invoked on a `GET` request and returns a `String`:
 ///
 /// ```no_run
-/// async fn hello(_req: tide::Request<()>) -> String {
-///     String::from("hello")
+/// async fn hello(_req: tide::Request<()>) -> tide::Result<String> {
+///     Ok(String::from("hello"))
 /// }
 ///
 /// fn main() {
@@ -37,8 +38,8 @@ use crate::{response::IntoResponse, Middleware, Request, Response};
 ///
 /// ```no_run
 /// # use core::future::Future;
-/// fn hello(_req: tide::Request<()>) -> impl Future<Output = String> {
-///     futures::future::ready(String::from("hello"))
+/// fn hello(_req: tide::Request<()>) -> impl Future<Output = tide::Result<String>> {
+///     futures::future::ready(Ok(String::from("hello")))
 /// }
 ///
 /// fn main() {
@@ -50,20 +51,23 @@ use crate::{response::IntoResponse, Middleware, Request, Response};
 /// Tide routes will also accept endpoints with `Fn` signatures of this form, but using the `async` keyword has better ergonomics.
 pub trait Endpoint<State>: Send + Sync + 'static {
     /// Invoke the endpoint within the given context
-    fn call<'a>(&'a self, req: Request<State>) -> BoxFuture<'a, Response>;
+    fn call<'a>(&'a self, req: Request<State>) -> BoxFuture<'a, Result<Response>>;
 }
 
 pub(crate) type DynEndpoint<State> = dyn Endpoint<State>;
 
-impl<State, F: Send + Sync + 'static, Fut> Endpoint<State> for F
+impl<State, F: Send + Sync + 'static, Fut, Res> Endpoint<State> for F
 where
     F: Fn(Request<State>) -> Fut,
-    Fut: Future + Send + 'static,
-    Fut::Output: IntoResponse,
+    Fut: Future<Output = Result<Res>> + Send + 'static,
+    Res: IntoResponse,
 {
-    fn call<'a>(&'a self, req: Request<State>) -> BoxFuture<'a, Response> {
+    fn call<'a>(&'a self, req: Request<State>) -> BoxFuture<'a, Result<Response>> {
         let fut = (self)(req);
-        Box::pin(async move { fut.await.into_response() })
+        Box::pin(async move {
+            let res = fut.await?;
+            Ok(res.into_response())
+        })
     }
 }
 
@@ -107,7 +111,7 @@ impl<E, State: 'static> Endpoint<State> for MiddlewareEndpoint<E, State>
 where
     E: Endpoint<State>,
 {
-    fn call<'a>(&'a self, req: Request<State>) -> BoxFuture<'a, Response> {
+    fn call<'a>(&'a self, req: Request<State>) -> BoxFuture<'a, Result<Response>> {
         let next = Next {
             endpoint: &self.endpoint,
             next_middleware: &self.middleware,

src/error.rs

@@ -20,7 +20,7 @@
 //! # fn main() -> Result<(), std::io::Error> { block_on(async {
 //! #
 //! let mut app = tide::new();
-//! app.at("/").get(|_| async move { "Hello, world!" });
+//! app.at("/").get(|_| async move { Ok("Hello, world!") });
 //! app.listen("127.0.0.1:8080").await?;
 //! #
 //! # Ok(()) }) }
@@ -32,7 +32,7 @@
 //! # fn main() -> Result<(), std::io::Error> { block_on(async {
 //! #
 //! let mut app = tide::new();
-//! app.at("/").get(|req| async move { req });
+//! app.at("/").get(|req| async move { Ok(req) });
 //! app.listen("127.0.0.1:8080").await?;
 //! #
 //! # Ok(()) }) }
@@ -48,10 +48,10 @@
 //!
 //! let mut app = tide::new();
 //! app.at("/").get(|mut req: tide::Request<()>| async move {
-//!    let mut counter: Counter = req.body_json().await.unwrap();
+//!    let mut counter: Counter = req.body_json().await?;
 //!    println!("count is {}", counter.count);
 //!    counter.count += 1;
-//!    tide::Response::new(http_types::StatusCode::Ok).body_json(&counter).unwrap()
+//!    Ok(tide::Response::new(tide::http::StatusCode::Ok).body_json(&counter)?)
 //! });
 //! app.listen("127.0.0.1:8080").await?;
 //! #
@@ -150,7 +150,7 @@
 //! #[async_std::main]
 //! async fn main() -> Result<(), std::io::Error> {
 //!     let mut app = tide::new();
-//!     app.at("/").get(|req: Request<()>| async move { req.bark() });
+//!     app.at("/").get(|req: Request<()>| async move { Ok(req.bark()) });
 //!     app.listen("127.0.0.1:8080").await
 //! }
 //! ```
@@ -174,7 +174,6 @@
 #![doc(test(attr(allow(unused_extern_crates, unused_variables))))]
 
 mod endpoint;
-mod error;
 pub mod middleware;
 mod redirect;
 mod request;
@@ -186,18 +185,21 @@ pub mod prelude;
 pub mod server;
 
 pub use endpoint::Endpoint;
-pub use error::{Error, Result, ResultExt};
 pub use redirect::redirect;
 pub use request::Request;
 
+#[doc(inline)]
+pub use http_types::{Error, Result, Status};
+
 #[doc(inline)]
 pub use middleware::{Middleware, Next};
 #[doc(inline)]
 pub use response::{IntoResponse, Response};
 #[doc(inline)]
 pub use server::{Route, Server};
 
-pub use http_types;
+#[doc(inline)]
+pub use http_types as http;
 
 /// Create a new Tide server.
 ///
@@ -208,7 +210,7 @@ pub use http_types;
 /// # fn main() -> Result<(), std::io::Error> { block_on(async {
 /// #
 /// let mut app = tide::new();
-/// app.at("/").get(|_| async move { "Hello, world!" });
+/// app.at("/").get(|_| async move { Ok("Hello, world!") });
 /// app.listen("127.0.0.1:8080").await?;
 /// #
 /// # Ok(()) }) }
@@ -242,7 +244,7 @@ pub fn new() -> server::Server<()> {
 /// // Initialize the application with state.
 /// let mut app = tide::with_state(state);
 /// app.at("/").get(|req: Request<State>| async move {
-///     format!("Hello, {}!", &req.state().name)
+///     Ok(format!("Hello, {}!", &req.state().name))
 /// });
 /// app.listen("127.0.0.1:8080").await?;
 /// #