eh

Author: Emilgardis

.vscode/settings.json

@@ -1,5 +1,4 @@
 {
-
     "rust-analyzer.checkOnSave.command": "clippy",
     "rust-analyzer.cargo.features": ["helix", "client"],
     "rust-analyzer.checkOnSave.enable": true,

Cargo.lock

@@ -58,6 +58,7 @@ aliri_braid = "0.3.1"
 futures = { version = "0.3.25", optional = true }
 hyper = { version = "0.14.23", optional = true }
 twitch_types = { version = "0.3.10", path = "./twitch_types" }
+yoke = { version = "0.6.2", features = ["derive"] }
 
 [features]
 default = ["deser_borrow"]
@@ -69,83 +70,29 @@ deny_unknown_fields = []
 trace_unknown_fields = ["dep:serde_ignored", "tracing"]
 
 serde_json = ["dep:serde_json", "dep:serde_path_to_error"]
-helix = [
-    "twitch_types/color",
-    "twitch_types/emote",
-    "twitch_types/goal",
-    "twitch_types/moderation",
-    "twitch_types/points",
-    "twitch_types/stream",
-    "twitch_types/timestamp",
-    "twitch_types/user",
-    "dep:async-trait",
-    "serde_json",
-    "dep:hyper",
-]
+helix = ["twitch_types/color", "twitch_types/emote", "twitch_types/goal", "twitch_types/moderation", "twitch_types/points", "twitch_types/stream", "twitch_types/timestamp", "twitch_types/user", "dep:async-trait", "serde_json", "dep:hyper"]
 
 deser_borrow = []
 
 tmi = ["serde_json", "dep:serde_path_to_error", "dep:hyper"]
 
-surf = [
-    "dep:surf",
-    "dep:http-types",
-    "client",
-    "twitch_oauth2/surf",
-    "hyper?/stream",
-]
+surf = ["dep:surf", "dep:http-types", "client", "twitch_oauth2/surf", "hyper?/stream"]
 
 ureq = ["dep:ureq", "client"]
 
 reqwest = ["dep:reqwest", "client", "twitch_oauth2/reqwest"]
 
-pubsub = [
-    "serde_json",
-    "twitch_types/emote",
-    "twitch_types/moderation",
-    "twitch_types/stream",
-    "twitch_types/timestamp",
-    "twitch_types/user",
-    "twitch_types/points",
-]
+pubsub = ["serde_json", "twitch_types/emote", "twitch_types/moderation", "twitch_types/stream", "twitch_types/timestamp", "twitch_types/user", "twitch_types/points"]
 
-eventsub = [
-    "serde_json",
-    "twitch_types/emote",
-    "twitch_types/eventsub",
-    "twitch_types/goal",
-    "twitch_types/points",
-    "twitch_types/stream",
-    "twitch_types/timestamp",
-    # insert when websockets are stable
-    # "serde_json/raw_value",
-]
+eventsub = ["serde_json", "twitch_types/emote", "twitch_types/eventsub", "twitch_types/goal", "twitch_types/points", "twitch_types/stream", "twitch_types/timestamp"]
 
 hmac = ["dep:crypto_hmac", "dep:sha2"]
 
 mock_api = []
 
-all = [
-    "tmi",
-    "helix",
-    "client",
-    "pubsub",
-    "eventsub",
-    "hmac",
-    "twitch_oauth2",
-    "tracing",
-    "twitch_types/time",
-]
+all = ["tmi", "helix", "client", "pubsub", "eventsub", "hmac", "twitch_oauth2", "tracing", "twitch_types/time"]
 
-_all = [
-    "all",
-    "typed-builder",
-    "surf",
-    "reqwest",
-    "ureq",
-    "twitch_oauth2/surf_client_curl",
-    "mock_api",
-]
+_all = ["all", "typed-builder", "surf", "reqwest", "ureq", "twitch_oauth2/surf_client_curl", "mock_api"]
 
 [dev-dependencies]
 tokio = { version = "1.22.0", features = ["rt-multi-thread", "macros"] }
@@ -169,6 +116,12 @@ name = "get_channel_status"
 path = "examples/get_channel_status.rs"
 required-features = ["reqwest", "helix"]
 
+[[example]]
+name = "get_users"
+path = "examples/get_users.rs"
+required-features = ["reqwest", "helix"]
+
+
 [[example]]
 name = "get_moderation"
 path = "examples/get_moderation.rs"

Cargo.toml

@@ -0,0 +1,35 @@
+use twitch_api::HelixClient;
+use twitch_oauth2::{AccessToken, UserToken};
+
+fn main() {
+    use std::error::Error;
+    if let Err(err) = run() {
+        println!("Error: {err}");
+        let mut e: &'_ dyn Error = err.as_ref();
+        while let Some(cause) = e.source() {
+            println!("Caused by: {cause}");
+            e = cause;
+        }
+    }
+}
+
+#[tokio::main]
+async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+    let _ = dotenvy::dotenv();
+    let mut args = std::env::args().skip(1);
+    let client: HelixClient<reqwest::Client> = HelixClient::default();
+    let token = std::env::var("TWITCH_TOKEN")
+        .ok()
+        .or_else(|| args.next())
+        .map(AccessToken::new)
+        .expect("Please set env: TWITCH_TOKEN or pass token as first argument");
+    let token = UserToken::from_existing(&client, token, None, None).await?;
+
+    let user = client
+        .get_user_from_id(&*args.next().unwrap(), &token)
+        .await?
+        .expect("no user found");
+
+    println!("User information:\n\t{:#?}", user.get());
+    Ok(())
+}

examples/get_users.rs

@@ -117,10 +117,13 @@ impl<'a, C: crate::HttpClient<'a>> HelixClient<'a, C> {
         &'a self,
         request: R,
         token: &T,
-    ) -> Result<Response<R, D>, ClientRequestError<<C as crate::HttpClient<'a>>::Error>>
+    ) -> Result<
+        Response<R, yoke::Yoke<D, std::rc::Rc<[u8]>>>,
+        ClientRequestError<<C as crate::HttpClient<'a>>::Error>,
+    >
     where
-        R: Request<Response = D> + Request + RequestGet,
-        D: serde::de::DeserializeOwned + PartialEq,
+        R: for <'y> Request<Response<'y> = D> + Request + RequestGet,
+        D: for<'b> serde::de::Deserialize<'b> + for<'b> yoke::Yokeable<'b, Output = D> + PartialEq,
         T: TwitchToken + ?Sized,
         C: Send,
     {
@@ -133,7 +136,42 @@ impl<'a, C: crate::HttpClient<'a>> HelixClient<'a, C> {
             .map_err(ClientRequestError::RequestError)?
             .into_response_vec()
             .await?;
-        <R>::parse_response(Some(request), &uri, response).map_err(Into::into)
+        let (parts, body) = response.into_parts();
+        let body: std::rc::Rc<[u8]> = body.into();
+        let mut pagination = None;
+        let mut request_opt = None;
+        let mut total = None;
+        let mut other = None;
+        let resp: yoke::Yoke<<R as Request>::Response<'static>, _> =
+            yoke::Yoke::try_attach_to_cart(
+                body,
+                |body| -> Result<
+                    <D as yoke::Yokeable<'_>>::Output,
+                    ClientRequestError<<C as crate::HttpClient<'a>>::Error>,
+                > {
+                    let response = http::Response::from_parts(parts, body);
+                    let Response {
+                        data,
+                        pagination: pagination_inner,
+                        request: request_inner,
+                        total: total_inner,
+                        other: other_inner,
+                    } = <R>::parse_response(Some(request), &uri, &response)?;
+                    pagination = pagination_inner;
+                    request_opt = request_inner;
+                    total = total_inner;
+                    other = other_inner;
+                    Ok(data)
+                },
+            )?;
+
+        Ok(Response {
+            data: resp,
+            pagination,
+            request: request_opt,
+            total,
+            other,
+        })
     }
 
     // /// Request on a valid [`RequestPost`] endpoint

src/helix/client.rs

@@ -28,19 +28,20 @@ impl<'client, C: crate::HttpClient<'client> + Sync> HelixClient<'client, C> {
     //     .map(|response| response.first())
     // }
 
-    // /// Get [User](helix::users::User) from user id
-    // pub async fn get_user_from_id<T>(
-    //     &'client self,
-    //     id: impl Into<&types::UserIdRef>,
-    //     token: &T,
-    // ) -> Result<Option<helix::users::User>, ClientError<'client, C>>
-    // where
-    //     T: TwitchToken + ?Sized,
-    // {
-    //     self.req_get(helix::users::GetUsersRequest::ids(&[id.into()][..]), token)
-    //         .await
-    //         .map(|response| response.first())
-    // }
+    /// Get [User](helix::users::User) from user id
+    pub async fn get_user_from_id<T>(
+        &'client self,
+        id: impl Into<&types::UserIdRef>,
+        token: &T,
+    ) -> Result<Option<yoke::Yoke<helix::users::User<'static>, std::rc::Rc<[u8]>>>, ClientError<'client, C>>
+    where
+        T: TwitchToken + ?Sized,
+    {
+        // self.req_get(helix::users::GetUsersRequest::ids(&[id.into()][..]), token)
+        //     .await
+        //     .map(|response| response.first_yoke())
+        todo!()
+    }
 
     // /// Get multiple [User](helix::users::User)s from user ids.
     // pub async fn get_users_from_ids<T>(

src/helix/client/client_ext.rs

@@ -106,30 +106,31 @@ impl<'a> GetUsersRequest<'a> {
 ///
 /// [`get-users`](https://dev.twitch.tv/docs/api/reference#get-users)
 #[derive(PartialEq, Eq, Deserialize, Serialize, Debug, Clone)]
+#[derive(yoke::Yokeable)]
 #[cfg_attr(feature = "deny_unknown_fields", serde(deny_unknown_fields))]
 #[non_exhaustive]
-pub struct User {
+pub struct User<'a> {
     /// User’s broadcaster type: "partner", "affiliate", or "".
     pub broadcaster_type: Option<types::BroadcasterType>,
     /// Date when the user was created.
-    pub created_at: types::Timestamp,
+    pub created_at: Cow<'a, types::Timestamp>,
     /// User’s channel description.
     pub description: Option<String>,
     /// User’s display name.
-    pub display_name: types::DisplayName,
+    pub display_name: Cow<'a, types::DisplayName>,
     /// User’s email address. Returned if the request includes the [`user:read:email` scope](twitch_oauth2::Scope::UserReadEmail).
     pub email: Option<String>,
     /// User’s ID.
-    pub id: types::UserId,
+    pub id: Cow<'a, types::UserId>,
     /// User’s login name.
-    pub login: types::UserName,
+    pub login: Cow<'a, types::UserName>,
     /// URL of the user’s offline image.
     pub offline_image_url: Option<String>,
     /// URL of the user’s profile image.
     pub profile_image_url: Option<String>,
     /// User’s type: "staff", "admin", "global_mod", or "".
     #[serde(rename = "type")]
-    pub type_: Option<types::UserType>,
+    pub type_: Option<Cow<'a, types::UserType>>,
     #[deprecated(
         since = "0.7.0",
         note = "removed, see https://discuss.dev.twitch.tv/t/get-users-api-endpoint-view-count-deprecation/37777"
@@ -140,7 +141,7 @@ pub struct User {
 }
 
 impl Request for GetUsersRequest<'_> {
-    type Response = Vec<User>;
+    type Response<'a> = Vec<User<'a>>;
 
     #[cfg(feature = "twitch_oauth2")]
     const OPT_SCOPE: &'static [twitch_oauth2::Scope] = &[twitch_oauth2::Scope::UserReadEmail];