Update indexes for v0.28.0 (#315)

* Update task api v0.28.0

* Update tests to be relevant with the structures where they are ran

* Update types in code-samples

* Remove clearAll task type

* Add index_uid as an optional in the Tasks

* Add comments on best builder implementation

* Add execute function on get_tasks

* Update code samples

* Remove out of context comment

* Fix tests

* Fix pagination tests

* Update HTTP methods for v0.28.0

* Fix clippy

* Remove comment of task tests since the tests are now sucesful

* Fix doc tests

* Update keys for v0.28.0

* Fix get tasks inside index structure

* Make description and name optional in keys

* Fix none doc tests with new get_tasks api

* Add from and limit in tasks params

* Add warning on failing test

* Update keys design

* Update task API

* Remove useless comment

* Remove client as mandatory parameter for the keyUpdater

* Add doc and tests on doc

* Fix docs tests on keys in client

* Fix docs tests

* Remove dbg

* Add with_uid filter

* Add new actions on key creation

* Remove new line at the start of docs

* Fix clippy errors

* Rename type in Task structure

* Removed useless newlines

* Fix typo in comment

* Add missing semi-column

* Update indexes api for v0.28.0

* Improve doc comments

* Change indexes methods

* Add index query and index updater

* Add documentation and doc tests on indexes routes

* Add tests on get indexes with params

* Add test on index update

* Fix clippy

* Improve limit to avoid flacky test

* Update src/client.rs

Co-authored-by: Tamo <[email protected]>

* Update src/client.rs

Co-authored-by: Tamo <[email protected]>

* Remove useless newlines

* Rollback changes on keys api

* Fix duplicated closing bracket

* Fix failing tests

* Remove useless comment

Co-authored-by: Tamo <[email protected]>

Author: bidoubiwa

.code-samples.meilisearch.yaml

@@ -6,7 +6,7 @@
 get_one_index_1: |-
   let movies: Index = client.get_index("movies").await.unwrap();
 list_all_indexes_1: |-
-  let indexes: Vec<Index> = client.list_all_indexes().await.unwrap();
+  let indexes: IndexesResults = client.list_all_indexes().await.unwrap();
 create_an_index_1: |-
   client.create_index("movies", Some("id")).await.unwrap();
 update_an_index_1: |-

src/client.rs

@@ -41,7 +41,23 @@ impl Client {
         }
     }
 
-    /// List all [Index]es and returns values as instances of [Index].
+    fn parse_indexes_results_from_value(&self, value: Value) -> Result<IndexesResults, Error> {
+        let raw_indexes = value["results"].as_array().unwrap();
+
+        let indexes_results = IndexesResults {
+            limit: value["limit"].as_u64().unwrap() as u32,
+            offset: value["offset"].as_u64().unwrap() as u32,
+            total: value["total"].as_u64().unwrap() as u32,
+            results: raw_indexes
+                .iter()
+                .map(|raw_index| Index::from_value(raw_index.clone(), self.clone()))
+                .collect::<Result<_, _>>()?,
+        };
+
+        Ok(indexes_results)
+    }
+
+    /// List all [Index]es with query parameters and returns values as instances of [Index].
     ///
     /// # Example
     ///
@@ -55,16 +71,44 @@ impl Client {
     /// // create the client
     /// let client = Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
     ///
-    /// let indexes: Vec<Index> = client.list_all_indexes().await.unwrap();
+    /// let indexes: IndexesResults = client.list_all_indexes().await.unwrap();
     /// println!("{:?}", indexes);
     /// # });
     /// ```
-    pub async fn list_all_indexes(&self) -> Result<Vec<Index>, Error> {
-        self.list_all_indexes_raw()
-            .await?
-            .into_iter()
-            .map(|index| Index::from_value(index, self.clone()))
-            .collect()
+    pub async fn list_all_indexes(&self) -> Result<IndexesResults, Error> {
+        let value = self.list_all_indexes_raw().await?;
+        let indexes_results = self.parse_indexes_results_from_value(value)?;
+        Ok(indexes_results)
+    }
+
+    /// List all [Index]es and returns values as instances of [Index].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, indexes::*};
+    /// #
+    /// # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// #
+    /// # futures::executor::block_on(async move {
+    /// // create the client
+    /// let client = Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
+    /// let mut query = IndexesQuery::new(&client);
+    /// query.with_limit(1);
+    /// let indexes: IndexesResults = client.list_all_indexes_with(&query).await.unwrap();
+    ///
+    /// assert_eq!(indexes.limit, 1);
+    /// # });
+    /// ```
+    pub async fn list_all_indexes_with(
+        &self,
+        indexes_query: &IndexesQuery<'_>,
+    ) -> Result<IndexesResults, Error> {
+        let value = self.list_all_indexes_raw_with(indexes_query).await?;
+        let indexes_results = self.parse_indexes_results_from_value(value)?;
+
+        Ok(indexes_results)
     }
 
     /// List all [Index]es and returns as Json.
@@ -85,8 +129,8 @@ impl Client {
     /// println!("{:?}", json_indexes);
     /// # });
     /// ```
-    pub async fn list_all_indexes_raw(&self) -> Result<Vec<Value>, Error> {
-        let json_indexes = request::<(), Vec<Value>>(
+    pub async fn list_all_indexes_raw(&self) -> Result<Value, Error> {
+        let json_indexes = request::<(), Value>(
             &format!("{}/indexes", self.host),
             &self.api_key,
             Method::Get(()),
@@ -97,6 +141,42 @@ impl Client {
         Ok(json_indexes)
     }
 
+    /// List all [Index]es with query parameters and returns as Json.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, indexes::*};
+    /// #
+    /// # let MEILISEARCH_HOST = option_env!("MEILISEARCH_HOST").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// #
+    /// # futures::executor::block_on(async move {
+    /// // create the client
+    /// let client = Client::new(MEILISEARCH_HOST, MEILISEARCH_API_KEY);
+    ///
+    /// let mut query = IndexesQuery::new(&client);
+    /// query.with_limit(1);
+    /// let json_indexes = client.list_all_indexes_raw_with(&query).await.unwrap();
+    ///
+    /// println!("{:?}", json_indexes);
+    /// # });
+    /// ```
+    pub async fn list_all_indexes_raw_with(
+        &self,
+        indexes_query: &IndexesQuery<'_>,
+    ) -> Result<Value, Error> {
+        let json_indexes = request::<&IndexesQuery, Value>(
+            &format!("{}/indexes", self.host),
+            &self.api_key,
+            Method::Get(indexes_query),
+            200,
+        )
+        .await?;
+
+        Ok(json_indexes)
+    }
+
     /// Get an [Index], this index should already exist.
     ///
     /// # Example
@@ -158,13 +238,7 @@ impl Client {
 
     /// Create a corresponding object of an [Index] without any check or doing an HTTP call.
     pub fn index(&self, uid: impl Into<String>) -> Index {
-        Index {
-            uid: Arc::new(uid.into()),
-            client: self.clone(),
-            primary_key: None,
-            created_at: None,
-            updated_at: None,
-        }
+        Index::new(uid, self.clone())
     }
 
     /// Create an [Index].
@@ -225,15 +299,31 @@ impl Client {
     }
 
     /// Alias for [Client::list_all_indexes].
-    pub async fn get_indexes(&self) -> Result<Vec<Index>, Error> {
+    pub async fn get_indexes(&self) -> Result<IndexesResults, Error> {
         self.list_all_indexes().await
     }
 
+    /// Alias for [Client::list_all_indexes_with].
+    pub async fn get_indexes_with(
+        &self,
+        indexes_query: &IndexesQuery<'_>,
+    ) -> Result<IndexesResults, Error> {
+        self.list_all_indexes_with(indexes_query).await
+    }
+
     /// Alias for [Client::list_all_indexes_raw].
-    pub async fn get_indexes_raw(&self) -> Result<Vec<Value>, Error> {
+    pub async fn get_indexes_raw(&self) -> Result<Value, Error> {
         self.list_all_indexes_raw().await
     }
 
+    /// Alias for [Client::list_all_indexes_raw_with].
+    pub async fn get_indexes_raw_with(
+        &self,
+        indexes_query: &IndexesQuery<'_>,
+    ) -> Result<Value, Error> {
+        self.list_all_indexes_raw_with(indexes_query).await
+    }
+
     /// Get stats of all indexes.
     ///
     /// # Example
@@ -873,6 +963,7 @@ mod tests {
     }
 
     #[meilisearch_test]
+
     async fn test_error_delete_key(mut client: Client, name: String) {
         // ==> accessing a key that does not exist
         let error = client.delete_key("invalid_key").await.unwrap_err();
@@ -887,9 +978,9 @@ mod tests {
 
         // ==> executing the action without enough right
         let mut key = KeyBuilder::new();
+
         key.with_name(&name);
         let key = client.create_key(key).await.unwrap();
-
         let master_key = client.api_key.clone();
         // this key has no right
         client.api_key = Arc::new(key.key.clone());
@@ -1058,19 +1149,39 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_list_all_indexes(client: Client, index: Index) {
+    async fn test_list_all_indexes(client: Client) {
         let all_indexes = client.list_all_indexes().await.unwrap();
-        assert!(all_indexes.len() > 0);
-        assert!(all_indexes.iter().any(|idx| idx.uid == index.uid));
+
+        assert_eq!(all_indexes.limit, 20);
+        assert_eq!(all_indexes.offset, 0);
     }
 
     #[meilisearch_test]
-    async fn test_list_all_indexes_raw(client: Client, index: Index) {
+    async fn test_list_all_indexes_with_params(client: Client) {
+        let mut query = IndexesQuery::new(&client);
+        query.with_limit(1);
+        let all_indexes = client.list_all_indexes_with(&query).await.unwrap();
+
+        assert_eq!(all_indexes.limit, 1);
+        assert_eq!(all_indexes.offset, 0);
+    }
+
+    #[meilisearch_test]
+    async fn test_list_all_indexes_raw(client: Client) {
         let all_indexes_raw = client.list_all_indexes_raw().await.unwrap();
-        assert!(all_indexes_raw.len() > 0);
-        assert!(all_indexes_raw
-            .iter()
-            .any(|idx| idx["uid"] == json!(index.uid.to_string())));
+
+        assert_eq!(all_indexes_raw["limit"], json!(20));
+        assert_eq!(all_indexes_raw["offset"], json!(0));
+    }
+
+    #[meilisearch_test]
+    async fn test_list_all_indexes_raw_with_params(client: Client) {
+        let mut query = IndexesQuery::new(&client);
+        query.with_limit(1);
+        let all_indexes_raw = client.list_all_indexes_raw_with(&query).await.unwrap();
+
+        assert_eq!(all_indexes_raw["limit"], json!(1));
+        assert_eq!(all_indexes_raw["offset"], json!(0));
     }
 
     #[meilisearch_test]