Replace struct Query with SearchQuery

Author: vishalsodani

.code-samples.meilisearch.yaml

@@ -820,9 +820,9 @@ getting_started_add_documents_md: |-
 
   [About this SDK](https://github.com/meilisearch/meilisearch-rust/)
 getting_started_search_md: |-
-  You can build a `Query` and execute it later:
+  You can build a `SearchQuery` and execute it later:
   ```rust
-  let query: Query = Query::new(&movies)
+  let query: SearchQuery = SearchQuery::new(&movies)
     .with_query("botman")
     .build();
 
@@ -833,9 +833,9 @@ getting_started_search_md: |-
     .unwrap();
   ```
 
-  You can build a `Query` and execute it directly:
+  You can build a `SearchQuery` and execute it directly:
   ```rust
-  let results: SearchResults<Movie> = Query::new(&movies)
+  let results: SearchResults<Movie> = SearchQuery::new(&movies)
     .with_query("botman")
     .execute()
     .await

src/indexes.rs

@@ -211,17 +211,17 @@ impl Index {
     /// // add some documents
     /// # movies.add_or_replace(&[Movie{name:String::from("Interstellar"), description:String::from("Interstellar chronicles the adventures of a group of explorers who make use of a newly discovered wormhole to surpass the limitations on human space travel and conquer the vast distances involved in an interstellar voyage.")},Movie{name:String::from("Unknown"), description:String::from("Unknown")}], Some("name")).await.unwrap().wait_for_completion(&client, None, None).await.unwrap();
     ///
-    /// let query = Query::new(&movies).with_query("Interstellar").with_limit(5).build();
+    /// let query = SearchQuery::new(&movies).with_query("Interstellar").with_limit(5).build();
     /// let results = movies.execute_query::<Movie>(&query).await.unwrap();
     /// assert!(results.hits.len()>0);
     /// # movies.delete().await.unwrap().wait_for_completion(&client, None, None).await.unwrap();
     /// # });
     /// ```
     pub async fn execute_query<T: 'static + DeserializeOwned>(
         &self,
-        query: &Query<'_>,
+        query: &SearchQuery<'_>,
     ) -> Result<SearchResults<T>, Error> {
-        request::<&Query, SearchResults<T>>(
+        request::<&SearchQuery, SearchResults<T>>(
             &format!("{}/indexes/{}/search", self.client.host, self.uid),
             &self.client.api_key,
             Method::Post(query),
@@ -267,8 +267,8 @@ impl Index {
     /// # movies.delete().await.unwrap().wait_for_completion(&client, None, None).await.unwrap();
     /// # });
     /// ```
-    pub fn search(&self) -> Query {
-        Query::new(self)
+    pub fn search(&self) -> SearchQuery {
+        SearchQuery::new(self)
     }
 
     /// Get one [Document] using its unique id.

src/lib.rs

@@ -248,3 +248,5 @@ pub mod tasks;
 mod tenant_tokens;
 /// Module containing utilies functions.
 mod utils;
+
+pub use client::*;

src/search.rs

@@ -78,7 +78,7 @@ fn serialize_attributes_to_crop_with_wildcard<S: Serializer>(
     }
 }
 
-/// Some list fields in a `Query` can be set to a wildcard value.
+/// Some list fields in a `SearchQuery` can be set to a wildcard value.
 /// This structure allows you to choose between the wildcard value and an exhaustive list of selectors.
 #[derive(Debug, Clone)]
 pub enum Selectors<T> {
@@ -98,7 +98,7 @@ type AttributeToCrop<'a> = (&'a str, Option<usize>);
 ///
 /// ```
 /// use serde::{Serialize, Deserialize};
-/// # use meilisearch_sdk::{client::Client, search::Query, indexes::Index};
+/// # use meilisearch_sdk::{client::Client, search::SearchQuery, indexes::Index};
 /// #
 /// # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
 /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
@@ -120,7 +120,7 @@ type AttributeToCrop<'a> = (&'a str, Option<usize>);
 /// #  .try_make_index(&client)
 /// #  .unwrap();
 ///
-/// let mut res = Query::new(&index)
+/// let mut res = SearchQuery::new(&index)
 ///     .with_query("space")
 ///     .with_offset(42)
 ///     .with_limit(21)
@@ -134,7 +134,7 @@ type AttributeToCrop<'a> = (&'a str, Option<usize>);
 /// ```
 ///
 /// ```
-/// # use meilisearch_sdk::{client::Client, search::Query, indexes::Index};
+/// # use meilisearch_sdk::{client::Client, search::SearchQuery, indexes::Index};
 /// #
 /// # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
 /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
@@ -149,7 +149,7 @@ type AttributeToCrop<'a> = (&'a str, Option<usize>);
 /// ```
 #[derive(Debug, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
-pub struct Query<'a> {
+pub struct SearchQuery<'a> {
     #[serde(skip_serializing)]
     index: &'a Index,
     /// The text that will be searched for among the documents.
@@ -237,9 +237,9 @@ pub struct Query<'a> {
 }
 
 #[allow(missing_docs)]
-impl<'a> Query<'a> {
-    pub fn new(index: &'a Index) -> Query<'a> {
-        Query {
+impl<'a> SearchQuery<'a> {
+    pub fn new(index: &'a Index) -> SearchQuery<'a> {
+        SearchQuery {
             index,
             query: None,
             offset: None,
@@ -257,82 +257,82 @@ impl<'a> Query<'a> {
             show_matches_position: None,
         }
     }
-    pub fn with_query<'b>(&'b mut self, query: &'a str) -> &'b mut Query<'a> {
+    pub fn with_query<'b>(&'b mut self, query: &'a str) -> &'b mut SearchQuery<'a> {
         self.query = Some(query);
         self
     }
 
-    pub fn with_offset<'b>(&'b mut self, offset: usize) -> &'b mut Query<'a> {
+    pub fn with_offset<'b>(&'b mut self, offset: usize) -> &'b mut SearchQuery<'a> {
         self.offset = Some(offset);
         self
     }
-    pub fn with_limit<'b>(&'b mut self, limit: usize) -> &'b mut Query<'a> {
+    pub fn with_limit<'b>(&'b mut self, limit: usize) -> &'b mut SearchQuery<'a> {
         self.limit = Some(limit);
         self
     }
-    pub fn with_filter<'b>(&'b mut self, filter: &'a str) -> &'b mut Query<'a> {
+    pub fn with_filter<'b>(&'b mut self, filter: &'a str) -> &'b mut SearchQuery<'a> {
         self.filter = Some(filter);
         self
     }
-    pub fn with_facets<'b>(&'b mut self, facets: Selectors<&'a [&'a str]>) -> &'b mut Query<'a> {
+    pub fn with_facets<'b>(&'b mut self, facets: Selectors<&'a [&'a str]>) -> &'b mut SearchQuery<'a> {
         self.facets = Some(facets);
         self
     }
-    pub fn with_sort<'b>(&'b mut self, sort: &'a [&'a str]) -> &'b mut Query<'a> {
+    pub fn with_sort<'b>(&'b mut self, sort: &'a [&'a str]) -> &'b mut SearchQuery<'a> {
         self.sort = Some(sort);
         self
     }
     pub fn with_attributes_to_retrieve<'b>(
         &'b mut self,
         attributes_to_retrieve: Selectors<&'a [&'a str]>,
-    ) -> &'b mut Query<'a> {
+    ) -> &'b mut SearchQuery<'a> {
         self.attributes_to_retrieve = Some(attributes_to_retrieve);
         self
     }
     pub fn with_attributes_to_crop<'b>(
         &'b mut self,
         attributes_to_crop: Selectors<&'a [(&'a str, Option<usize>)]>,
-    ) -> &'b mut Query<'a> {
+    ) -> &'b mut SearchQuery<'a> {
         self.attributes_to_crop = Some(attributes_to_crop);
         self
     }
-    pub fn with_crop_length<'b>(&'b mut self, crop_length: usize) -> &'b mut Query<'a> {
+    pub fn with_crop_length<'b>(&'b mut self, crop_length: usize) -> &'b mut SearchQuery<'a> {
         self.crop_length = Some(crop_length);
         self
     }
-    pub fn with_crop_marker<'b>(&'b mut self, crop_marker: &'a str) -> &'b mut Query<'a> {
+    pub fn with_crop_marker<'b>(&'b mut self, crop_marker: &'a str) -> &'b mut SearchQuery<'a> {
         self.crop_marker = Some(crop_marker);
         self
     }
     pub fn with_attributes_to_highlight<'b>(
         &'b mut self,
         attributes_to_highlight: Selectors<&'a [&'a str]>,
-    ) -> &'b mut Query<'a> {
+    ) -> &'b mut SearchQuery<'a> {
         self.attributes_to_highlight = Some(attributes_to_highlight);
         self
     }
     pub fn with_highlight_pre_tag<'b>(
         &'b mut self,
         highlight_pre_tag: &'a str,
-    ) -> &'b mut Query<'a> {
+    ) -> &'b mut SearchQuery<'a> {
         self.highlight_pre_tag = Some(highlight_pre_tag);
         self
     }
     pub fn with_highlight_post_tag<'b>(
         &'b mut self,
         highlight_post_tag: &'a str,
-    ) -> &'b mut Query<'a> {
+    ) -> &'b mut SearchQuery<'a> {
         self.highlight_post_tag = Some(highlight_post_tag);
         self
     }
     pub fn with_show_matches_position<'b>(
         &'b mut self,
         show_matches_position: bool,
-    ) -> &'b mut Query<'a> {
+    ) -> &'b mut SearchQuery<'a> {
         self.show_matches_position = Some(show_matches_position);
         self
     }
-    pub fn build(&mut self) -> Query<'a> {
+    pub fn build(&mut self) -> SearchQuery<'a> {
         self.clone()
     }
 
@@ -397,7 +397,7 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_query_builder(_client: Client, index: Index) -> Result<(), Error> {
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("space").with_offset(42).with_limit(21);
 
         let res = query.execute::<Document>().await.unwrap();
@@ -481,7 +481,7 @@ mod tests {
     async fn test_query_facet_distribution(client: Client, index: Index) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_facets(Selectors::All);
         let results: SearchResults<Document> = index.execute_query(&query).await?;
         assert_eq!(
@@ -495,7 +495,7 @@ mod tests {
             &8
         );
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_facets(Selectors::Some(&["kind"]));
         let results: SearchResults<Document> = index.execute_query(&query).await?;
         assert_eq!(
@@ -533,7 +533,7 @@ mod tests {
             .await?;
         assert_eq!(results.hits.len(), 10);
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_attributes_to_retrieve(Selectors::Some(&["kind", "id"])); // omit the "value" field
         assert!(index.execute_query::<Document>(&query).await.is_err()); // error: missing "value" field
         Ok(())
@@ -543,7 +543,7 @@ mod tests {
     async fn test_query_sort(client: Client, index: Index) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("harry potter");
         query.with_sort(&["title:desc"]);
         let results: SearchResults<Document> = index.execute_query(&query).await?;
@@ -555,7 +555,7 @@ mod tests {
     async fn test_query_attributes_to_crop(client: Client, index: Index) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("lorem ipsum");
         query.with_attributes_to_crop(Selectors::All);
         let results: SearchResults<Document> = index.execute_query(&query).await?;
@@ -572,7 +572,7 @@ mod tests {
             results.hits[0].formatted_result.as_ref().unwrap()
         );
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("lorem ipsum");
         query.with_attributes_to_crop(Selectors::Some(&[("value", Some(5)), ("kind", None)]));
         let results: SearchResults<Document> = index.execute_query(&query).await?;
@@ -594,7 +594,7 @@ mod tests {
     async fn test_query_crop_length(client: Client, index: Index) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("lorem ipsum");
         query.with_attributes_to_crop(Selectors::All);
         query.with_crop_length(200);
@@ -607,7 +607,7 @@ mod tests {
         },
         results.hits[0].formatted_result.as_ref().unwrap());
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("lorem ipsum");
         query.with_attributes_to_crop(Selectors::All);
         query.with_crop_length(5);
@@ -630,7 +630,7 @@ mod tests {
     async fn test_query_customized_crop_marker(client: Client, index: Index) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("sed do eiusmod");
         query.with_attributes_to_crop(Selectors::All);
         query.with_crop_length(6);
@@ -659,7 +659,7 @@ mod tests {
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("Social");
         query.with_attributes_to_highlight(Selectors::All);
         query.with_highlight_pre_tag("(⊃｡•́‿•̀｡)⊃ ");
@@ -685,7 +685,7 @@ mod tests {
     async fn test_query_attributes_to_highlight(client: Client, index: Index) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("dolor text");
         query.with_attributes_to_highlight(Selectors::All);
         let results: SearchResults<Document> = index.execute_query(&query).await?;
@@ -701,7 +701,7 @@ mod tests {
             results.hits[0].formatted_result.as_ref().unwrap(),
         );
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("dolor text");
         query.with_attributes_to_highlight(Selectors::Some(&["value"]));
         let results: SearchResults<Document> = index.execute_query(&query).await?;
@@ -723,7 +723,7 @@ mod tests {
     async fn test_query_show_matches_position(client: Client, index: Index) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("dolor text");
         query.with_show_matches_position(true);
         let results: SearchResults<Document> = index.execute_query(&query).await?;
@@ -747,7 +747,7 @@ mod tests {
     async fn test_phrase_search(client: Client, index: Index) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
-        let mut query = Query::new(&index);
+        let mut query = SearchQuery::new(&index);
         query.with_query("harry \"of Fire\"");
         let results: SearchResults<Document> = index.execute_query(&query).await?;