revert part of the typings for single requests

torn-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "torn-api"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2021"
 authors = ["Pyrit [2111649]"]
 license = "MIT"

torn-api/src/faction.rs

@@ -47,7 +47,7 @@ mod tests {
 
         let response = Client::default()
             .torn_api(key)
-            .faction(None, |b| b.selections(&[Selection::Basic]))
+            .faction(|b| b.selections(&[Selection::Basic]))
             .await
             .unwrap();
 

torn-api/src/lib.rs

@@ -180,18 +180,25 @@ where
     A: ApiCategoryResponse,
 {
     request: ApiRequest<A>,
+    id: Option<i64>,
+}
+
+impl<A> Default for ApiRequestBuilder<A>
+where
+    A: ApiCategoryResponse,
+{
+    fn default() -> Self {
+        Self {
+            request: Default::default(),
+            id: None,
+        }
+    }
 }
 
 impl<A> ApiRequestBuilder<A>
 where
     A: ApiCategoryResponse,
 {
-    pub(crate) fn new() -> Self {
-        Self {
-            request: ApiRequest::default(),
-        }
-    }
-
     #[must_use]
     pub fn selections(mut self, selections: &[A::Selection]) -> Self {
         self.request
@@ -217,6 +224,15 @@ where
         self.request.comment = Some(comment);
         self
     }
+
+    #[must_use]
+    pub fn id<I>(mut self, id: I) -> Self
+    where
+        I: num_traits::AsPrimitive<i64>,
+    {
+        self.id = Some(id.as_());
+        self
+    }
 }
 
 #[cfg(test)]
@@ -259,11 +275,7 @@ pub(crate) mod tests {
     async fn reqwest() {
         let key = setup();
 
-        Client::default()
+        Client::default().torn_api(key).user(|b| b).await.unwrap();
-            .torn_api(key)
-            .user(None, |b| b)
-            .await
-            .unwrap();
     }
 
     #[cfg(feature = "awc")]

torn-api/src/local.rs

@@ -7,54 +7,48 @@ use crate::{
     ApiResponse, DirectExecutor,
 };
 
-pub struct ApiProvider<'a, C, E, I = i32>
+pub struct ApiProvider<'a, C, E>
 where
     C: ApiClient,
     E: RequestExecutor<C>,
-    I: num_traits::AsPrimitive<i64>,
 {
     client: &'a C,
     executor: E,
-    _marker: std::marker::PhantomData<I>,
 }
 
-impl<'a, C, E, I> ApiProvider<'a, C, E, I>
+impl<'a, C, E> ApiProvider<'a, C, E>
 where
     C: ApiClient,
     E: RequestExecutor<C>,
-    I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
-    i64: num_traits::AsPrimitive<I>,
 {
-    pub fn new(client: &'a C, executor: E) -> ApiProvider<'a, C, E, I> {
+    pub fn new(client: &'a C, executor: E) -> ApiProvider<'a, C, E> {
-        Self {
+        Self { client, executor }
-            client,
-            executor,
-            _marker: Default::default(),
-        }
     }
 
-    pub async fn user<F>(&self, id: Option<I>, build: F) -> Result<user::Response, E::Error>
+    pub async fn user<F>(&self, build: F) -> Result<user::Response, E::Error>
     where
         F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
-            .execute(self.client, builder.request, id.map(|i| i.as_()))
+            .execute(self.client, builder.request, builder.id)
             .await
     }
 
-    pub async fn users<F, L>(
+    pub async fn users<F, L, I>(
         &self,
         ids: L,
         build: F,
     ) -> HashMap<I, Result<user::Response, E::Error>>
     where
         F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
+        I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
+        i64: num_traits::AsPrimitive<I>,
         L: IntoIterator<Item = I>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
@@ -69,28 +63,30 @@ where
             .collect()
     }
 
-    pub async fn faction<F>(&self, id: Option<I>, build: F) -> Result<faction::Response, E::Error>
+    pub async fn faction<F>(&self, build: F) -> Result<faction::Response, E::Error>
     where
         F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
-            .execute(self.client, builder.request, id.map(|i| i.as_()))
+            .execute(self.client, builder.request, builder.id)
             .await
     }
 
-    pub async fn factions<F, L>(
+    pub async fn factions<F, L, I>(
         &self,
         ids: L,
         build: F,
     ) -> HashMap<I, Result<faction::Response, E::Error>>
     where
         F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
+        I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
+        i64: num_traits::AsPrimitive<I>,
         L: IntoIterator<Item = I>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
@@ -105,28 +101,30 @@ where
             .collect()
     }
 
-    pub async fn torn<F>(&self, id: Option<I>, build: F) -> Result<torn::Response, E::Error>
+    pub async fn torn<F>(&self, build: F) -> Result<torn::Response, E::Error>
     where
         F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
-            .execute(self.client, builder.request, id.map(|i| i.as_()))
+            .execute(self.client, builder.request, builder.id)
             .await
     }
 
-    pub async fn torns<F, L>(
+    pub async fn torns<F, L, I>(
         &self,
         ids: L,
         build: F,
     ) -> HashMap<I, Result<torn::Response, E::Error>>
     where
         F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
+        I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
+        i64: num_traits::AsPrimitive<I>,
         L: IntoIterator<Item = I>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor

torn-api/src/send.rs

@@ -7,54 +7,48 @@ use crate::{
     ApiResponse, DirectExecutor,
 };
 
-pub struct ApiProvider<'a, C, E, I = i32>
+pub struct ApiProvider<'a, C, E>
 where
     C: ApiClient,
     E: RequestExecutor<C>,
-    I: num_traits::AsPrimitive<i64>,
 {
     client: &'a C,
     executor: E,
-    _marker: std::marker::PhantomData<I>,
 }
 
-impl<'a, C, E, I> ApiProvider<'a, C, E, I>
+impl<'a, C, E> ApiProvider<'a, C, E>
 where
     C: ApiClient,
     E: RequestExecutor<C>,
-    I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
-    i64: num_traits::AsPrimitive<I>,
 {
-    pub fn new(client: &'a C, executor: E) -> ApiProvider<'a, C, E, I> {
+    pub fn new(client: &'a C, executor: E) -> ApiProvider<'a, C, E> {
-        Self {
+        Self { client, executor }
-            client,
-            executor,
-            _marker: Default::default(),
-        }
     }
 
-    pub async fn user<F>(&self, id: Option<I>, build: F) -> Result<user::Response, E::Error>
+    pub async fn user<F>(&self, build: F) -> Result<user::Response, E::Error>
     where
         F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
-            .execute(self.client, builder.request, id.map(|i| i.as_()))
+            .execute(self.client, builder.request, builder.id)
             .await
     }
 
-    pub async fn users<F, L>(
+    pub async fn users<F, L, I>(
         &self,
         ids: L,
         build: F,
     ) -> HashMap<I, Result<user::Response, E::Error>>
     where
         F: FnOnce(ApiRequestBuilder<user::Response>) -> ApiRequestBuilder<user::Response>,
+        I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
+        i64: num_traits::AsPrimitive<I>,
         L: IntoIterator<Item = I>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
@@ -69,28 +63,30 @@ where
             .collect()
     }
 
-    pub async fn faction<F>(&self, id: Option<I>, build: F) -> Result<faction::Response, E::Error>
+    pub async fn faction<F>(&self, build: F) -> Result<faction::Response, E::Error>
     where
         F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
-            .execute(self.client, builder.request, id.map(|i| i.as_()))
+            .execute(self.client, builder.request, builder.id)
             .await
     }
 
-    pub async fn factions<F, L>(
+    pub async fn factions<F, L, I>(
         &self,
         ids: L,
         build: F,
     ) -> HashMap<I, Result<faction::Response, E::Error>>
     where
         F: FnOnce(ApiRequestBuilder<faction::Response>) -> ApiRequestBuilder<faction::Response>,
+        I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
+        i64: num_traits::AsPrimitive<I>,
         L: IntoIterator<Item = I>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
@@ -105,28 +101,30 @@ where
             .collect()
     }
 
-    pub async fn torn<F>(&self, id: Option<I>, build: F) -> Result<torn::Response, E::Error>
+    pub async fn torn<F>(&self, build: F) -> Result<torn::Response, E::Error>
     where
         F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor
-            .execute(self.client, builder.request, id.map(|i| i.as_()))
+            .execute(self.client, builder.request, builder.id)
             .await
     }
 
-    pub async fn torns<F, L>(
+    pub async fn torns<F, L, I>(
         &self,
         ids: L,
         build: F,
     ) -> HashMap<I, Result<torn::Response, E::Error>>
     where
         F: FnOnce(ApiRequestBuilder<torn::Response>) -> ApiRequestBuilder<torn::Response>,
+        I: num_traits::AsPrimitive<i64> + std::hash::Hash + std::cmp::Eq,
+        i64: num_traits::AsPrimitive<I>,
         L: IntoIterator<Item = I>,
     {
-        let mut builder = ApiRequestBuilder::new();
+        let mut builder = ApiRequestBuilder::default();
         builder = build(builder);
 
         self.executor

torn-api/src/torn.rs

@@ -91,7 +91,7 @@ mod tests {
 
         let response = Client::default()
             .torn_api(key)
-            .torn(None, |b| b.selections(&[Selection::Competition]))
+            .torn(|b| b.selections(&[Selection::Competition]))
             .await
             .unwrap();
 

torn-api/src/user.rs

@@ -399,7 +399,7 @@ mod tests {
 
         let response = Client::default()
             .torn_api(key)
-            .user(None, |b| {
+            .user(|b| {
                 b.selections(&[
                     Selection::Basic,
                     Selection::Discord,
@@ -424,7 +424,7 @@ mod tests {
 
         let response = Client::default()
             .torn_api(key)
-            .user(Some(28), |b| b.selections(&[Selection::Profile]))
+            .user(|b| b.id(28).selections(&[Selection::Profile]))
             .await
             .unwrap();
 
@@ -439,7 +439,7 @@ mod tests {
 
         let response = Client::default()
             .torn_api(key)
-            .user(None, |b| b.selections(&[Selection::Profile]))
+            .user(|b| b.selections(&[Selection::Profile]))
             .await
             .unwrap();
 
@@ -453,10 +453,27 @@ mod tests {
 
         let response = Client::default()
             .torn_api(key)
-            .users([1, 2111649], |b| b.selections(&[Selection::Basic]))
+            .users([1, 2111649, 374272176892674048i64], |b| {
+                b.selections(&[Selection::Basic])
+            })
             .await;
 
         response.get(&1).as_ref().unwrap().as_ref().unwrap();
         response.get(&2111649).as_ref().unwrap().as_ref().unwrap();
     }
+
+    #[async_test]
+    async fn discord() {
+        let key = setup();
+
+        let basic = Client::default()
+            .torn_api(key)
+            .user(|b| b.id(374272176892674048i64).selections(&[Selection::Basic]))
+            .await
+            .unwrap()
+            .basic()
+            .unwrap();
+
+        assert_eq!(basic.player_id, 2111649);
+    }
 }