Rename uid, status and types filters to plural

Author: bidoubiwa

src/indexes.rs

@@ -903,7 +903,7 @@ impl Index {
     /// ```
     pub async fn get_tasks(&self) -> Result<TasksResults, Error> {
         let mut query = TasksQuery::new(&self.client);
-        query.with_index_uid([self.uid.as_str()]);
+        query.with_index_uids([self.uid.as_str()]);
 
         self.client.get_tasks_with(&query).await
     }
@@ -924,7 +924,7 @@ impl Index {
     /// # let index = client.create_index("get_tasks_with", None).await.unwrap().wait_for_completion(&client, None, None).await.unwrap().try_make_index(&client).unwrap();
     ///
     /// let mut query = TasksQuery::new(&client);
-    /// query.with_index_uid(["none_existant"]);
+    /// query.with_index_uids(["none_existant"]);
     /// let tasks = index.get_tasks_with(&query).await.unwrap();
     ///
     /// assert!(tasks.results.len() > 0);
@@ -936,7 +936,7 @@ impl Index {
         tasks_query: &TasksQuery<'_>,
     ) -> Result<TasksResults, Error> {
         let mut query = tasks_query.clone();
-        query.with_index_uid([self.uid.as_str()]);
+        query.with_index_uids([self.uid.as_str()]);
 
         self.client.get_tasks_with(&query).await
     }

src/tasks.rs

@@ -406,16 +406,16 @@ pub struct TasksQuery<'a> {
     pub client: &'a Client,
     // Index uids array to only retrieve the tasks of the indexes.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub index_uid: Option<Vec<&'a str>>,
+    pub index_uids: Option<Vec<&'a str>>,
     // Statuses array to only retrieve the tasks with these statuses.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub status: Option<Vec<&'a str>>,
+    pub statuses: Option<Vec<&'a str>>,
     // Types array to only retrieve the tasks with these [TaskType].
-    #[serde(skip_serializing_if = "Option::is_none", rename = "type")]
-    pub task_type: Option<Vec<&'a str>>,
+    #[serde(skip_serializing_if = "Option::is_none", rename = "types")]
+    pub task_types: Option<Vec<&'a str>>,
     // Uids of the tasks to retrieve
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub uid: Option<Vec<&'a u32>>,
+    pub uids: Option<Vec<&'a u32>>,
     // Date to retrieve all tasks that were enqueued before it.
     #[serde(
         skip_serializing_if = "Option::is_none",
@@ -465,12 +465,12 @@ impl<'a> TasksQuery<'a> {
     pub fn new(client: &'a Client) -> TasksQuery<'a> {
         TasksQuery {
             client,
-            index_uid: None,
-            status: None,
-            task_type: None,
+            index_uids: None,
+            statuses: None,
+            task_types: None,
             limit: None,
             from: None,
-            uid: None,
+            uids: None,
             before_enqueued_at: None,
             after_enqueued_at: None,
             before_started_at: None,
@@ -479,32 +479,32 @@ impl<'a> TasksQuery<'a> {
             after_finished_at: None,
         }
     }
-    pub fn with_index_uid<'b>(
+    pub fn with_index_uids<'b>(
         &'b mut self,
-        index_uid: impl IntoIterator<Item = &'a str>,
+        index_uids: impl IntoIterator<Item = &'a str>,
     ) -> &'b mut TasksQuery<'a> {
-        self.index_uid = Some(index_uid.into_iter().collect());
+        self.index_uids = Some(index_uids.into_iter().collect());
         self
     }
-    pub fn with_status<'b>(
+    pub fn with_statuses<'b>(
         &'b mut self,
-        status: impl IntoIterator<Item = &'a str>,
+        statuses: impl IntoIterator<Item = &'a str>,
     ) -> &'b mut TasksQuery<'a> {
-        self.status = Some(status.into_iter().collect());
+        self.statuses = Some(statuses.into_iter().collect());
         self
     }
-    pub fn with_type<'b>(
+    pub fn with_types<'b>(
         &'b mut self,
-        task_type: impl IntoIterator<Item = &'a str>,
+        task_types: impl IntoIterator<Item = &'a str>,
     ) -> &'b mut TasksQuery<'a> {
-        self.task_type = Some(task_type.into_iter().collect());
+        self.task_types = Some(task_types.into_iter().collect());
         self
     }
-    pub fn with_uid<'b>(
+    pub fn with_uids<'b>(
         &'b mut self,
-        index_uid: impl IntoIterator<Item = &'a u32>,
+        uids: impl IntoIterator<Item = &'a u32>,
     ) -> &'b mut TasksQuery<'a> {
-        self.uid = Some(index_uid.into_iter().collect());
+        self.uids = Some(uids.into_iter().collect());
         self
     }
     pub fn with_before_enqueued_at<'b>(
@@ -735,18 +735,18 @@ mod test {
         let mock_server_url = &mockito::server_url();
         let client = Client::new(mock_server_url, "masterKey");
         let path =
-            "/tasks?indexUid=movies,test&status=equeued&type=documentDeletion&uid=1&limit=0&from=1";
+            "/tasks?indexUids=movies,test&statuses=equeued&types=documentDeletion&uids=1&limit=0&from=1";
 
         let mock_res = mock("GET", path).with_status(200).create();
 
         let mut query = TasksQuery::new(&client);
         query
-            .with_index_uid(["movies", "test"])
-            .with_status(["equeued"])
-            .with_type(["documentDeletion"])
+            .with_index_uids(["movies", "test"])
+            .with_statuses(["equeued"])
+            .with_types(["documentDeletion"])
             .with_from(1)
             .with_limit(0)
-            .with_uid([&1]);
+            .with_uids([&1]);
 
         let _ = client.get_tasks_with(&query).await;
 
@@ -821,15 +821,15 @@ mod test {
     async fn test_get_tasks_on_struct_with_params() -> Result<(), Error> {
         let mock_server_url = &mockito::server_url();
         let client = Client::new(mock_server_url, "masterKey");
-        let path = "/tasks?indexUid=movies,test&status=equeued&type=documentDeletion";
+        let path = "/tasks?indexUids=movies,test&statuses=equeued&types=documentDeletion";
 
         let mock_res = mock("GET", path).with_status(200).create();
 
         let mut query = TasksQuery::new(&client);
         let _ = query
-            .with_index_uid(["movies", "test"])
-            .with_status(["equeued"])
-            .with_type(["documentDeletion"])
+            .with_index_uids(["movies", "test"])
+            .with_statuses(["equeued"])
+            .with_types(["documentDeletion"])
             .execute()
             .await;
 
@@ -839,9 +839,9 @@ mod test {
     }
 
     #[meilisearch_test]
-    async fn test_get_tasks_with_none_existant_index_uid(client: Client) -> Result<(), Error> {
+    async fn test_get_tasks_with_none_existant_index_uids(client: Client) -> Result<(), Error> {
         let mut query = TasksQuery::new(&client);
-        query.with_index_uid(["no_name"]);
+        query.with_index_uids(["no_name"]);
         let tasks = client.get_tasks_with(&query).await.unwrap();
 
         assert_eq!(tasks.results.len(), 0);
@@ -851,7 +851,7 @@ mod test {
     #[meilisearch_test]
     async fn test_get_tasks_with_execute(client: Client) -> Result<(), Error> {
         let tasks = TasksQuery::new(&client)
-            .with_index_uid(["no_name"])
+            .with_index_uids(["no_name"])
             .execute()
             .await
             .unwrap();