bu...

Author: Emilgardis

examples/get_user.rs

@@ -1,4 +1,7 @@
-use twitch_api::{helix::users::GetUsersRequest, HelixClient};
+use twitch_api::{
+    helix::users::{GetUsersRequest, User},
+    HelixClient,
+};
 use twitch_oauth2::{AccessToken, UserToken};
 
 fn main() {

src/helix/client.rs

@@ -101,17 +101,19 @@ impl<'a, C: crate::HttpClient<'a>> HelixClient<'a, C> {
     /// # }
     /// # // fn main() {run()}
     /// ```
-    pub async fn req_get<R, D, T>(
+    pub async fn req_get<'t, R, D, T>(
         &'a self,
         request: R,
-        token: &T,
+        token: &'t T,
     ) -> Result<
-        Response<R, yoke::Yoke<<R as Request>::Response<'static>, std::rc::Rc<[u8]>>>,
+        Response<R, yoke::Yoke<D, std::rc::Rc<[u8]>>>,
         ClientRequestError<<C as crate::HttpClient<'a>>::Error>,
     >
     where
-        R: Request<Response<'static> = D> + RequestGet,
-        D: for<'b> serde::de::Deserialize<'b> + for<'b> yoke::Yokeable<'b, Output = D> + PartialEq,
+        for<'r> R: Request + RequestGet<Response<'r> = D> + Request<Response<'r> = D>,
+        for<'b> yoke::trait_hack::YokeTraitHack<<D as yoke::Yokeable<'b>>::Output>:
+            serde::de::Deserialize<'b>,
+        for<'b> D: PartialEq + yoke::Yokeable<'b, Output = D>,
         T: TwitchToken + ?Sized,
         C: Send,
     {
@@ -132,18 +134,15 @@ impl<'a, C: crate::HttpClient<'a>> HelixClient<'a, C> {
         let mut other = None;
         let resp: yoke::Yoke<D, _> = yoke::Yoke::try_attach_to_cart(
             body,
-            |body| -> Result<
-                <D as yoke::Yokeable<'static>>::Output,
-                ClientRequestError<<C as crate::HttpClient<'a>>::Error>,
-            > {
+            |body| -> Result<_, ClientRequestError<<C as crate::HttpClient<'a>>::Error>> {
                 let response = http::Response::from_parts(parts, body);
-                let Response {
+                let Response::<_, <R as Request>::Response<'_>> {
                     data,
                     pagination: pagination_inner,
                     request: request_inner,
                     total: total_inner,
                     other: other_inner,
-                } = todo!();//<R>::parse_response(Some(request), &uri, &response)?;
+                } = <R as RequestGet>::parse_response(Some(request), &uri, &response)?;
                 pagination = pagination_inner;
                 request_opt = request_inner;
                 total = total_inner;

src/helix/endpoints/users/get_users.rs

@@ -59,7 +59,7 @@ pub struct GetUsersRequest {
 /// Return Values for [Get Users](super::get_users)
 ///
 /// [`get-users`](https://dev.twitch.tv/docs/api/reference#get-users)
-#[derive(PartialEq, Deserialize, Serialize, Debug, Clone)]
+#[derive(PartialEq, Deserialize, Serialize, Debug, Clone, yoke::Yokeable)]
 #[cfg_attr(feature = "deny_unknown_fields", serde(deny_unknown_fields))]
 #[non_exhaustive]
 pub struct User<'a> {
@@ -144,5 +144,12 @@ fn test_request() {
         "https://api.twitch.tv/helix/users?id=44322889"
     );
 
-    dbg!(GetUsersRequest::parse_response(Some(req), &uri, &http_response).unwrap());
+    {
+        let this = dbg!(GetUsersRequest::parse_response(Some(req), &uri, &http_response).unwrap());
+        let ref this = this.data.get(0).unwrap().created_at;
+        match *this {
+            Cow::Borrowed(_) => dbg!("borrow"),
+            Cow::Owned(_) => dbg!("owned"),
+        }
+    };
 }

src/helix/request.rs

@@ -18,7 +18,7 @@ pub trait Request: serde::Serialize {
     #[cfg(feature = "twitch_oauth2")]
     const OPT_SCOPE: &'static [twitch_oauth2::Scope] = &[];
     /// Response type. twitch's response will  deserialize to this.
-    type Response<'a>: serde::de::Deserialize<'a> + PartialEq + 'a;
+    type Response<'a>: for<'de> serde::de::Deserialize<'de> + PartialEq + 'a;
     /// Defines layout of the url parameters.
     fn query(&self) -> Result<String, errors::SerializeError> { ser::to_string(&self) }
     /// Returns full URI for the request, including query parameters.
@@ -396,12 +396,12 @@ pub trait RequestGet: Request {
         response: &'b http::Response<&'a [u8]>,
     ) -> Result<Response<Self, <Self as Request>::Response<'a>>, HelixRequestGetError>
     where
-        Self: Sized + 'a,
+        Self: Sized,
     {
         let text = std::str::from_utf8(response.body()).map_err(|e| {
             HelixRequestGetError::Utf8Error(response.body().to_vec(), e, uri.clone())
         })?;
-        //eprintln!("\n\nmessage is ------------ {} ------------", text);
+        //eprintln!("\n\nmessage is ----------- {} ------------", text);
         if let Ok(HelixRequestError {
             error,
             status,

src/helix/response.rs

@@ -3,8 +3,7 @@ use super::{Cursor, Request};
 
 /// Response retrieved from endpoint. Data is the type in [`Request::Response`]
 #[non_exhaustive]
-pub struct Response<R, D>
-where R: Request {
+pub struct Response<R, D> {
     /// Twitch's response field for `data`.
     pub data: D,
     /// A cursor value, to be used in a subsequent request to specify the starting point of the next set of results.