Add support for new functions

Author: shimatar0

examples/cli-app-with-reqwest/src/main.rs

@@ -113,7 +113,8 @@ impl HttpClient for ReqwestClient {
             body = "null".to_string();
         }
 
-        parse_response(status, expected_status_code, body)
+        parse_response(status, expected_status_code, &body, url.to_string())
+        // parse_response(status, expected_status_code, body)
     }
 
     async fn stream_request<

src/documents.rs

@@ -275,7 +275,7 @@ impl<'a, Http: HttpClient> DocumentsQuery<'a, Http> {
         self
     }
 
-    pub fn with_filter<'b>(&'b mut self, filter: &'a str) -> &'b mut DocumentsQuery<'a> {
+    pub fn with_filter<'b>(&'b mut self, filter: &'a str) -> &'b mut DocumentsQuery<'a, Http> {
         self.filter = Some(filter);
         self
     }
@@ -318,25 +318,28 @@ impl<'a, Http: HttpClient> DocumentsQuery<'a, Http> {
 }
 
 #[derive(Debug, Clone, Serialize)]
-pub struct DocumentDeletionQuery<'a> {
+pub struct DocumentDeletionQuery<'a, Http: HttpClient> {
     #[serde(skip_serializing)]
-    pub index: &'a Index,
+    pub index: &'a Index<Http>,
 
     /// Filters to apply.
     ///
     /// Read the [dedicated guide](https://docs.meilisearch.com/reference/features/filtering.html) to learn the syntax.
     pub filter: Option<&'a str>,
 }
 
-impl<'a> DocumentDeletionQuery<'a> {
-    pub fn new(index: &Index) -> DocumentDeletionQuery {
+impl<'a, Http: HttpClient> DocumentDeletionQuery<'a, Http> {
+    pub fn new(index: &Index<Http>) -> DocumentDeletionQuery<Http> {
         DocumentDeletionQuery {
             index,
             filter: None,
         }
     }
 
-    pub fn with_filter<'b>(&'b mut self, filter: &'a str) -> &'b mut DocumentDeletionQuery<'a> {
+    pub fn with_filter<'b>(
+        &'b mut self,
+        filter: &'a str,
+    ) -> &'b mut DocumentDeletionQuery<'a, Http> {
         self.filter = Some(filter);
         self
     }
@@ -349,9 +352,7 @@ impl<'a> DocumentDeletionQuery<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        client::Client, errors::Client, indexes::*, request::IsahcClient, request::IsahcClient,
-    };
+    use crate::{client::Client, errors::*, indexes::*, request::IsahcClient};
     use meilisearch_test_macro::meilisearch_test;
     use serde::{Deserialize, Serialize};
 
@@ -445,7 +446,10 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_delete_documents_with(client: Client, index: Index) -> Result<(), Error> {
+    async fn test_delete_documents_with(
+        client: Client<IsahcClient>,
+        index: Index<IsahcClient>,
+    ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
         index
             .set_filterable_attributes(["id"])
@@ -477,8 +481,8 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_delete_documents_with_filter_not_filterable(
-        client: Client,
-        index: Index,
+        client: Client<IsahcClient>,
+        index: Index<IsahcClient>,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
@@ -506,8 +510,8 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_get_documents_with_only_one_param(
-        client: Client,
-        index: Index,
+        client: Client<IsahcClient>,
+        index: Index<IsahcClient>,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
         // let documents = index.get_documents(None, None, None).await.unwrap();
@@ -525,7 +529,10 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_get_documents_with_filter(client: Client, index: Index) -> Result<(), Error> {
+    async fn test_get_documents_with_filter(
+        client: Client<IsahcClient>,
+        index: Index<IsahcClient>,
+    ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
         index
@@ -579,8 +586,8 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_get_documents_with_error_hint_meilisearch_api_error(
-        index: Index,
-        client: Client,
+        index: Index<IsahcClient>,
+        client: Client<IsahcClient>,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
@@ -610,8 +617,8 @@ Hint: It might not be working because you're not up to date with the Meilisearch
 
     #[meilisearch_test]
     async fn test_get_documents_with_invalid_filter(
-        client: Client,
-        index: Index,
+        client: Client<IsahcClient>,
+        index: Index<IsahcClient>,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
@@ -635,7 +642,10 @@ Hint: It might not be working because you're not up to date with the Meilisearch
     }
 
     #[meilisearch_test]
-    async fn test_settings_generated_by_macro(client: Client, index: Index) -> Result<(), Error> {
+    async fn test_settings_generated_by_macro(
+        client: Client<IsahcClient>,
+        index: Index<IsahcClient>,
+    ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
         let movie_settings: Settings = MovieClips::generate_settings();

src/indexes.rs

@@ -483,35 +483,39 @@ impl<Http: HttpClient> Index<Http> {
     ) -> Result<DocumentsResults<T>, Error> {
         if documents_query.filter.is_some() {
             let url = format!("{}/indexes/{}/documents/fetch", self.client.host, self.uid);
-            return request::<(), &DocumentsQuery, DocumentsResults<T>>(
-                &url,
-                self.client.get_api_key(),
-                Method::Post {
-                    body: documents_query,
-                    query: (),
-                },
-                200,
-            )
-            .await
-            .map_err(|err| match err {
-                Error::MeilisearchCommunication(error) => {
-                    Error::MeilisearchCommunication(MeilisearchCommunicationError {
-                        status_code: error.status_code,
-                        url: error.url,
-                        message: Some(format!("{}.", MEILISEARCH_VERSION_HINT)),
-                    })
-                }
-                Error::Meilisearch(error) => Error::Meilisearch(MeilisearchError {
-                    error_code: error.error_code,
-                    error_link: error.error_link,
-                    error_type: error.error_type,
-                    error_message: format!(
-                        "{}\n{}.",
-                        error.error_message, MEILISEARCH_VERSION_HINT
-                    ),
-                }),
-                _ => err,
-            });
+            return self
+                .client
+                .http_client
+                .clone()
+                .request::<(), &DocumentsQuery<Http>, DocumentsResults<T>>(
+                    &url,
+                    self.client.get_api_key(),
+                    Method::Post {
+                        body: documents_query,
+                        query: (),
+                    },
+                    200,
+                )
+                .await
+                .map_err(|err| match err {
+                    Error::MeilisearchCommunication(error) => {
+                        Error::MeilisearchCommunication(MeilisearchCommunicationError {
+                            status_code: error.status_code,
+                            url: error.url,
+                            message: Some(format!("{}.", MEILISEARCH_VERSION_HINT)),
+                        })
+                    }
+                    Error::Meilisearch(error) => Error::Meilisearch(MeilisearchError {
+                        error_code: error.error_code,
+                        error_link: error.error_link,
+                        error_type: error.error_type,
+                        error_message: format!(
+                            "{}\n{}.",
+                            error.error_message, MEILISEARCH_VERSION_HINT
+                        ),
+                    }),
+                    _ => err,
+                });
         }
 
         let url = format!("{}/indexes/{}/documents", self.client.host, self.uid);
@@ -1036,18 +1040,21 @@ impl<Http: HttpClient> Index<Http> {
     /// ```
     pub async fn delete_documents_with(
         &self,
-        query: &DocumentDeletionQuery<'_>,
+        query: &DocumentDeletionQuery<'_, Http>,
     ) -> Result<TaskInfo, Error> {
-        request::<(), &DocumentDeletionQuery, TaskInfo>(
-            &format!("{}/indexes/{}/documents/delete", self.client.host, self.uid),
-            self.client.get_api_key(),
-            Method::Post {
-                query: (),
-                body: query,
-            },
-            202,
-        )
-        .await
+        self.client
+            .http_client
+            .clone()
+            .request::<(), &DocumentDeletionQuery<Http>, TaskInfo>(
+                &format!("{}/indexes/{}/documents/delete", self.client.host, self.uid),
+                self.client.get_api_key(),
+                Method::Post {
+                    query: (),
+                    body: query,
+                },
+                202,
+            )
+            .await
     }
 
     /// Alias for the [`Index::update`] method.
@@ -1571,7 +1578,10 @@ impl<'a, Http: HttpClient> IndexUpdater<'a, Http> {
     /// # index.delete().await.unwrap().wait_for_completion(&client, None, None).await.unwrap();
     /// # });
     /// ```
-    pub fn with_primary_key(&mut self, primary_key: impl AsRef<str>) -> &mut IndexUpdater<'a> {
+    pub fn with_primary_key(
+        &mut self,
+        primary_key: impl AsRef<str>,
+    ) -> &mut IndexUpdater<'a, Http> {
         self.primary_key = Some(primary_key.as_ref().to_string());
         self
     }

src/request.rs

@@ -164,7 +164,8 @@ impl HttpClient for IsahcClient {
             body = "null".to_string();
         }
 
-        parse_response(status, expected_status_code, body)
+        parse_response(status, expected_status_code, &body, url.to_string())
+        // parse_response(status, expected_status_code, body)
     }
 
     async fn stream_request<
@@ -262,7 +263,8 @@ impl HttpClient for IsahcClient {
             body = "null".to_string();
         }
 
-        parse_response(status, expected_status_code, body)
+        parse_response(status, expected_status_code, &body, url.to_string())
+        // parse_response(status, expected_status_code, body)
     }
 }
 
@@ -363,9 +365,9 @@ impl HttpClient for WebSysClient {
 
         if let Some(t) = text.as_string() {
             if t.is_empty() {
-                parse_response(status, expected_status_code, String::from("null"))
+                parse_response(status, expected_status_code, "null", url.to_string())
             } else {
-                parse_response(status, expected_status_code, t)
+                parse_response(status, expected_status_code, &t, url.to_string())
             }
         } else {
             error!("Invalid response");