refactor(http)!: cleanup ApiError

http/src/error.rs

@@ -1,5 +1,6 @@
-use crate::{api_error::ApiError, json::JsonError, response::StatusCode};
+use crate::{json::JsonError, response::StatusCode};
 use hyper::{Body, Response};
+use serde::{Deserialize, Serialize};
 use std::{
     error::Error as StdError,
     fmt::{Debug, Display, Formatter, Result as FmtResult},
@@ -110,7 +111,7 @@ pub enum ErrorType {
     RequestTimedOut,
     Response {
         body: Vec<u8>,
-        error: ApiError,
+        ratelimit: Option<Ratelimit>,
         status: StatusCode,
     },
     /// API service is unavailable. Consider re-sending the request at a
@@ -126,3 +127,54 @@ pub enum ErrorType {
     /// or is revoked. Recreate the client to configure a new token.
     Unauthorized,
 }
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[non_exhaustive]
+pub struct Ratelimit {
+    /// Whether the ratelimit is global.
+    pub global: bool,
+    /// Amount of time to wait before retrying.
+    pub retry_after: f64,
+}
+
+impl Display for Ratelimit {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        if self.global {
+            f.write_str("globally ")?;
+        }
+
+        f.write_str("ratelimited for ")?;
+        Display::fmt(&self.retry_after, f)?;
+
+        f.write_str("s")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Ratelimit;
+    use serde_test::Token;
+
+    #[test]
+    fn test_ratelimited_api_error() {
+        let expected = Ratelimit {
+            global: true,
+            retry_after: 6.457,
+        };
+
+        serde_test::assert_ser_tokens(
+            &expected,
+            &[
+                Token::Struct {
+                    name: "Ratelimit",
+                    len: 2,
+                },
+                Token::Str("global"),
+                Token::Bool(true),
+                Token::Str("retry_after"),
+                Token::F64(6.457),
+                Token::StructEnd,
+            ],
+        );
+    }
+}

http/src/lib.rs

@@ -128,7 +128,6 @@
     clippy::unnecessary_wraps
 )]
 
-pub mod api_error;
 pub mod client;
 pub mod error;
 pub mod request;

http/src/response/future.rs

@@ -1,8 +1,5 @@
 use super::{Response, StatusCode};
-use crate::{
-    api_error::ApiError,
-    error::{Error, ErrorType},
-};
+use crate::error::{Error, ErrorType};
 use hyper::{client::ResponseFuture as HyperResponseFuture, StatusCode as HyperStatusCode};
 use std::{
     future::Future,
@@ -35,30 +32,18 @@ struct Chunking {
 
 impl Chunking {
     fn poll<T>(mut self, cx: &mut Context<'_>) -> InnerPoll<T> {
-        let bytes = match Pin::new(&mut self.future).poll(cx) {
-            Poll::Ready(Ok(bytes)) => bytes,
-            Poll::Ready(Err(source)) => return InnerPoll::Ready(Err(source)),
-            Poll::Pending => return InnerPoll::Pending(ResponseFutureStage::Chunking(self)),
-        };
-
-        let error = match crate::json::from_bytes::<ApiError>(&bytes) {
-            Ok(error) => error,
-            Err(source) => {
-                return InnerPoll::Ready(Err(Error {
-                    kind: ErrorType::Parsing { body: bytes },
-                    source: Some(Box::new(source)),
-                }));
-            }
-        };
-
-        InnerPoll::Ready(Err(Error {
-            kind: ErrorType::Response {
-                body: bytes,
-                error,
-                status: StatusCode::new(self.status.as_u16()),
-            },
-            source: None,
-        }))
+        match Pin::new(&mut self.future).poll(cx) {
+            Poll::Ready(Ok(bytes)) => InnerPoll::Ready(Err(Error {
+                kind: ErrorType::Response {
+                    ratelimit: crate::json::from_bytes(&bytes).ok(),
+                    body: bytes,
+                    status: StatusCode::new(self.status.as_u16()),
+                },
+                source: None,
+            })),
+            Poll::Ready(Err(source)) => InnerPoll::Ready(Err(source)),
+            Poll::Pending => InnerPoll::Pending(ResponseFutureStage::Chunking(self)),
+        }
     }
 }