merge with main

Author: irevoire

src/client.rs

@@ -4,14 +4,19 @@ use std::{collections::HashMap, time::Duration};
 use time::OffsetDateTime;
 
 use crate::{
-    errors::*, indexes::*, request::*, search::*, utils::async_sleep, Key, KeyBuilder, KeyUpdater,
-    KeysQuery, KeysResults, Task, TaskInfo, TasksCancelQuery, TasksDeleteQuery, TasksResults,
-    TasksSearchQuery,
+    errors::*,
+    indexes::*,
+    key::{Key, KeyBuilder, KeyUpdater, KeysQuery, KeysResults},
+    request::*,
+    search::*,
+    task_info::TaskInfo,
+    tasks::{Task, TasksCancelQuery, TasksDeleteQuery, TasksResults, TasksSearchQuery},
+    utils::async_sleep,
 };
 
 /// The top-level struct of the SDK, representing a client containing [indexes](../indexes/struct.Index.html).
 #[derive(Debug, Clone)]
-pub struct Client<Http: HttpClient> {
+pub struct Client<Http: HttpClient = IsahcClient> {
     pub(crate) host: String,
     pub(crate) api_key: Option<String>,
     pub http_client: Http,
@@ -44,7 +49,8 @@ impl Client<IsahcClient> {
     pub fn new(host: impl Into<String>, api_key: Option<impl Into<String>>) -> Client<IsahcClient> {
         Client {
             host: host.into(),
-
+            api_key: api_key.map(|api_key| api_key.into()),
+            http_client: IsahcClient,
         }
     }
 }
@@ -1197,7 +1203,7 @@ mod tests {
 
     use meilisearch_test_macro::meilisearch_test;
 
-    use crate::{client::*, Action, KeyBuilder, TasksSearchQuery};
+    use crate::{client::*, key::Action};
 
     #[derive(Debug, Serialize, Deserialize, PartialEq)]
     struct Document {

src/documents.rs

@@ -1,4 +1,3 @@
-use crate::TaskInfo;
 use async_trait::async_trait;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
@@ -52,6 +51,7 @@ pub use meilisearch_index_setting_macro::IndexConfig;
 use crate::client::Client;
 use crate::request::HttpClient;
 use crate::settings::Settings;
+use crate::task_info::TaskInfo;
 use crate::tasks::Task;
 use crate::{errors::Error, indexes::Index};
 

src/dumps.rs

@@ -38,7 +38,7 @@
 //! # });
 //! ```
 
-use crate::{request::*, Client, Error, TaskInfo};
+use crate::{client::Client, errors::Error, request::*, task_info::TaskInfo};
 
 /// Dump related methods.
 /// See the [dumps](crate::dumps) module.

src/features.rs

@@ -1,6 +1,7 @@
 use crate::{
-    request::{request, Method},
-    Client, Error,
+    client::Client,
+    errors::Error,
+    request::{HttpClient, Method},
 };
 use serde::{Deserialize, Serialize};
 
@@ -27,16 +28,16 @@ pub struct ExperimentalFeaturesResult {
 /// ```
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ExperimentalFeatures<'a> {
+pub struct ExperimentalFeatures<'a, Http: HttpClient> {
     #[serde(skip_serializing)]
-    client: &'a Client,
+    client: &'a Client<Http>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub vector_store: Option<bool>,
 }
 
-impl<'a> ExperimentalFeatures<'a> {
+impl<'a, Http: HttpClient> ExperimentalFeatures<'a, Http> {
     #[must_use]
-    pub fn new(client: &'a Client) -> Self {
+    pub fn new(client: &'a Client<Http>) -> Self {
         ExperimentalFeatures {
             client,
             vector_store: None,
@@ -63,13 +64,16 @@ impl<'a> ExperimentalFeatures<'a> {
     /// });
     /// ```
     pub async fn get(&self) -> Result<ExperimentalFeaturesResult, Error> {
-        request::<(), (), ExperimentalFeaturesResult>(
-            &format!("{}/experimental-features", self.client.host),
-            self.client.get_api_key(),
-            Method::Get { query: () },
-            200,
-        )
-        .await
+        self.client
+            .http_client
+            .clone()
+            .request::<(), (), ExperimentalFeaturesResult>(
+                &format!("{}/experimental-features", self.client.host),
+                self.client.get_api_key(),
+                Method::Get { query: () },
+                200,
+            )
+            .await
     }
 
     /// Update the experimental features
@@ -88,16 +92,19 @@ impl<'a> ExperimentalFeatures<'a> {
     /// });
     /// ```
     pub async fn update(&self) -> Result<ExperimentalFeaturesResult, Error> {
-        request::<(), &Self, ExperimentalFeaturesResult>(
-            &format!("{}/experimental-features", self.client.host),
-            self.client.get_api_key(),
-            Method::Patch {
-                query: (),
-                body: self,
-            },
-            200,
-        )
-        .await
+        self.client
+            .http_client
+            .clone()
+            .request::<(), &Self, ExperimentalFeaturesResult>(
+                &format!("{}/experimental-features", self.client.host),
+                self.client.get_api_key(),
+                Method::Patch {
+                    query: (),
+                    body: self,
+                },
+                200,
+            )
+            .await
     }
 }
 

src/indexes.rs

@@ -1,7 +1,11 @@
 use crate::{
-    request::*, search::*, tasks::*, Client, DocumentDeletionQuery, DocumentQuery, DocumentsQuery,
-    DocumentsResults, Error, MeilisearchCommunicationError, MeilisearchError, TaskInfo,
-    MEILISEARCH_VERSION_HINT,
+    client::Client,
+    documents::{DocumentDeletionQuery, DocumentQuery, DocumentsQuery, DocumentsResults},
+    errors::{Error, MeilisearchCommunicationError, MeilisearchError, MEILISEARCH_VERSION_HINT},
+    request::*,
+    search::*,
+    task_info::TaskInfo,
+    tasks::*,
 };
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::{collections::HashMap, fmt::Display, time::Duration};
@@ -60,7 +64,7 @@ use time::OffsetDateTime;
 /// ```
 #[derive(Debug, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
-pub struct Index<Http: HttpClient> {
+pub struct Index<Http: HttpClient = IsahcClient> {
     #[serde(skip_serializing)]
     pub client: Client<Http>,
     pub uid: String,
@@ -2102,11 +2106,6 @@ mod tests {
         assert_eq!(res.offset, 2);
     }
 
-    #[meilisearch_test]
-    async fn test_get_one_task(
-        client: Client<IsahcClient>,
-        index: Index<IsahcClient>,
-    ) -> Result<(), Error> {
     async fn test_add_documents_ndjson(client: Client, index: Index) -> Result<(), Error> {
         let ndjson = r#"{ "id": 1, "body": "doggo" }{ "id": 2, "body": "catto" }"#.as_bytes();
 
@@ -2212,9 +2211,12 @@ mod tests {
 
         Ok(())
     }
-
     #[meilisearch_test]
-    async fn test_get_one_task(client: Client, index: Index) -> Result<(), Error> {
+
+    async fn test_get_one_task(
+        client: Client<IsahcClient>,
+        index: Index<IsahcClient>,
+    ) -> Result<(), Error> {
         let task = index
             .delete_all_documents()
             .await?

src/request.rs

@@ -1,8 +1,10 @@
-
+use async_trait::async_trait;
 use log::{error, trace, warn};
 use serde::{de::DeserializeOwned, Serialize};
 use serde_json::from_str;
 
+use crate::errors::{Error, MeilisearchCommunicationError, MeilisearchError};
+
 #[derive(Debug)]
 pub enum Method<Q, B> {
     Get { query: Q },

src/search.rs

@@ -456,10 +456,11 @@ impl<'a, Http: HttpClient> SearchQuery<'a, Http> {
         self.sort = Some(sort);
         self
     }
+
     pub fn with_attributes_to_search_on<'b>(
         &'b mut self,
         attributes_to_search_on: &'a [&'a str],
-    ) -> &'b mut SearchQuery<'a> {
+    ) -> &'b mut SearchQuery<'a, Http> {
         self.attributes_to_search_on = Some(attributes_to_search_on);
         self
     }
@@ -516,10 +517,11 @@ impl<'a, Http: HttpClient> SearchQuery<'a, Http> {
         self.show_matches_position = Some(show_matches_position);
         self
     }
+
     pub fn with_show_ranking_score<'b>(
         &'b mut self,
         show_ranking_score: bool,
-    ) -> &'b mut SearchQuery<'a> {
+    ) -> &'b mut SearchQuery<'a, Http> {
         self.show_ranking_score = Some(show_ranking_score);
         self
     }
@@ -585,7 +587,12 @@ pub struct MultiSearchResponse<T> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{client::*, request::IsahcClient, search::*};
+    use crate::{
+        client::*,
+        key::{Action, KeyBuilder},
+        request::IsahcClient,
+        search::*,
+    };
     use big_s::S;
     use meilisearch_test_macro::meilisearch_test;
     use serde::{Deserialize, Serialize};
@@ -1183,8 +1190,6 @@ mod tests {
         client: Client<IsahcClient>,
         index: Index<IsahcClient>,
     ) -> Result<(), Error> {
-        use crate::{Action, KeyBuilder};
-
         setup_test_index(&client, &index).await?;
 
         let meilisearch_url = option_env!("MEILISEARCH_URL").unwrap_or("http://localhost:7700");