refactor: Use (mostly) References in Requests

CHANGELOG.md

@@ -8,6 +8,10 @@
 
 ### Breaking changes
 
+- Requests for helix endpoints have been converted to take `Cow`s.
+  This change means the `builder()` methods are harder to use, consider using the new methods on
+  each request which provide the same functionality but with better ergonomics.
+  See the top-level documentation for a endpoint for more examples.
 - Crate name changed: `twitch_api2` -> `twitch_api`, also changed to new org `twitch-rs`
 - All (most) types are now living in their own crate `twitch_types`
 - Features for clients are now named after the client, e.g feature `reqwest_client` is now simply `reqwest`

Cargo.toml

@@ -57,7 +57,7 @@ crypto_hmac = { package = "hmac", version = "0.12.1", optional = true }
 aliri_braid = "0.2.4"
 futures = { version = "0.3.25", optional = true }
 hyper = { version = "0.14.20", optional = true }
-twitch_types = { version = "0.3.5", path = "./twitch_types" }
+twitch_types = { version = "0.3.6", path = "./twitch_types" }
 
 [features]
 default = []

examples/automod_check.rs

@@ -35,11 +35,11 @@ async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
 
     let req =
         twitch_api::helix::moderation::CheckAutoModStatusRequest::broadcaster_id(broadcaster_id);
-    let data =
-        twitch_api::helix::moderation::CheckAutoModStatusBody::new("123", args.collect::<String>());
+    let text = args.collect::<String>();
+    let data = twitch_api::helix::moderation::CheckAutoModStatusBody::new("123", &text);
     println!("data: {:?}", data);
-    let response = client.req_post(req, vec![data], &token).await?;
-    println!("{:?}", response.data);
+    let response = client.req_post(req, &[&data], &token).await?.data;
+    println!("{response:?}");
 
     Ok(())
 }

examples/channel_information.rs

@@ -26,12 +26,12 @@ async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
     let token = UserToken::from_existing(&client, token, None, None).await?;
 
     let user = client
-        .get_user_from_login(args.next().unwrap(), &token)
+        .get_user_from_login(&*args.next().unwrap(), &token)
         .await?
         .expect("no user found");
 
     let channel = client
-        .get_channel_from_id(user.id.clone(), &token)
+        .get_channel_from_id(&user.id, &token)
         .await?
         .expect("no channel found");
 

examples/channel_information_custom.rs

@@ -24,11 +24,10 @@ async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
         .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 id = token.user_id.clone();
 
     let resp = client
         .req_get_custom(
-            helix::channels::GetChannelInformationRequest::broadcaster_id(id),
+            helix::channels::GetChannelInformationRequest::broadcaster_id(&token.user_id),
             &token,
         )
         .await

examples/client.rs

@@ -1,4 +1,4 @@
-use twitch_api::{helix::streams::GetStreamsRequest, TwitchClient};
+use twitch_api::{helix::streams::GetStreamsRequest, types, TwitchClient};
 use twitch_oauth2::{AccessToken, UserToken};
 fn main() {
     use std::error::Error;
@@ -36,9 +36,20 @@ async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
     )
     .await?;
 
-    let req = GetStreamsRequest::user_login(args.next().expect("please provide an username"));
     foo_client.client.helix.clone_client();
-    let response = foo_client.client.helix.req_get(req, &token).await?;
-    println!("{:?}", response);
+    let response = foo_client
+        .client
+        .helix
+        .req_get(
+            GetStreamsRequest::user_logins(
+                &[types::UserNameRef::from_str(
+                    &args.next().expect("please provide an username"),
+                )][..],
+            ),
+            &token,
+        )
+        .await?
+        .data;
+    println!("{response:?}");
     Ok(())
 }

examples/eventsub/src/main.rs

@@ -74,7 +74,7 @@ pub async fn run(opts: &Opts) -> eyre::Result<()> {
     .await?;
 
     let broadcaster = client
-        .get_user_from_login(&*opts.broadcaster_login, &token)
+        .get_user_from_login(&opts.broadcaster_login, &token)
         .await?
         .ok_or_else(|| eyre::eyre!("broadcaster not found"))?;
 

examples/eventsub/src/twitch.rs

@@ -264,7 +264,9 @@ pub async fn is_live<'a>(
     tracing::info!("checking if live");
     if let Some(stream) = client
         .req_get(
-            helix::streams::get_streams::GetStreamsRequest::user_id(config.broadcaster.id.clone()),
+            helix::streams::get_streams::GetStreamsRequest::user_ids(
+                &[config.broadcaster.id.as_ref()][..],
+            ),
             token,
         )
         .await

examples/followed_streams.rs

@@ -37,7 +37,13 @@ async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
         .try_collect::<Vec<_>>()
         .await?;
     let games = client
-        .get_games_by_id(streams.iter().map(|s| s.game_id.clone()), &token)
+        .get_games_by_id(
+            &streams
+                .iter()
+                .map(|s| s.game_id.as_ref())
+                .collect::<Vec<_>>(),
+            &token,
+        )
         .await?;
 
     println!(

examples/get_channel_status.rs

@@ -1,4 +1,4 @@
-use twitch_api::{helix::streams::GetStreamsRequest, HelixClient};
+use twitch_api::{helix::streams::GetStreamsRequest, types, HelixClient};
 use twitch_oauth2::{AccessToken, UserToken};
 
 fn main() {
@@ -31,10 +31,17 @@ async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
     .await
     .unwrap();
 
-    let req = GetStreamsRequest::user_login(args.next().unwrap());
+    let response = client
+        .req_get(
+            GetStreamsRequest::user_logins(
+                &[types::UserNameRef::from_str(&args.next().unwrap())][..],
+            ),
+            &token,
+        )
+        .await
+        .unwrap()
+        .data;
 
-    let response = client.req_get(req, &token).await.unwrap();
-
-    println!("Stream information:\n\t{:?}", response.data);
+    println!("Stream information:\n\t{response:?}");
     Ok(())
 }

examples/mock_api.rs

@@ -59,16 +59,16 @@ async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
     .await?;
 
     let user = client
-        .get_user_from_id(&*user_id, &token)
+        .get_user_from_id(&user_id, &token)
         .await?
         .expect("no user found");
 
     let _channel = client
-        .get_channel_from_id(&*user_id, &token)
+        .get_channel_from_id(&user_id, &token)
         .await?
         .expect("no channel found");
     let _channel = client
-        .get_channel_from_id(user.id.clone(), &token)
+        .get_channel_from_id(&user.id, &token)
         .await?
         .expect("no channel found");
 
@@ -86,7 +86,7 @@ async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
         .await?;
     dbg!(search.get(0));
     let _total = client
-        .get_total_followers_from_id(search.get(0).unwrap().id.clone(), &token)
+        .get_total_followers_from_id(&search.get(0).unwrap().id, &token)
         .await?;
     dbg!(_total);
     let streams: Vec<_> = client.get_followed_streams(&token).try_collect().await?;

examples/modify_channel.rs

@@ -33,14 +33,14 @@ async fn run() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>>
     let broadcaster_id = token.validate_token(&client).await?.user_id.unwrap();
 
     let req = twitch_api::helix::channels::ModifyChannelInformationRequest::broadcaster_id(
-        broadcaster_id,
+        &broadcaster_id,
     );
 
-    let mut data = twitch_api::helix::channels::ModifyChannelInformationBody::new();
-    data.title("Hello World!");
+    let mut body = twitch_api::helix::channels::ModifyChannelInformationBody::new();
+    body.title("Hello World!");
 
     println!("scopes: {:?}", token.scopes());
-    let response = client.req_patch(req, data, &token).await?;
+    let response = client.req_patch(req, body, &token).await?;
     println!("{:?}", response);
 
     Ok(())