Support Network API routes

.code-samples.meilisearch.yaml

@@ -1650,7 +1650,7 @@ get_experimental_features_1: |-
 update_experimental_features_1: |-
   let client = Client::new("http://localhost:7700", Some("apiKey"));
   let features = ExperimentalFeatures::new(&client);
-  // update the feature you want here
+  features.set_metrics(true)
   let res = features
     .update()
     .await
@@ -1770,3 +1770,23 @@ reset_localized_attribute_settings_1: |-
     .reset_localized_attributes()
     .await
     .unwrap();
+get_network_1: |-
+  let network: Network = client.get_network().await.unwrap();
+update_network_1: |-
+  client.update_network(
+      NetworkUpdate::new()
+           .with_self("ms-00")
+           .with_remotes(&[
+               Remote {
+                   name: "ms-00".to_string(),
+                   url: "http://INSTANCE_URL".to_string(),
+                   search_api_key: Some("INSTANCE_API_KEY".to_string()),
+               },
+               Remote {
+                   name: "ms-01".to_string(),
+                   url: "http://ANOTHER_INSTANCE_URL".to_string(),
+                   search_api_key: Some("ANOTHER_INSTANCE_API_KEY".to_string()),
+               },
+           ]),
+  )
+  .await.unwrap();

src/client.rs

@@ -8,6 +8,7 @@ use crate::{
     errors::*,
     indexes::*,
     key::{Key, KeyBuilder, KeyUpdater, KeysQuery, KeysResults},
+    network::{Network, NetworkUpdate},
     request::*,
     search::*,
     task_info::TaskInfo,
@@ -1076,6 +1077,76 @@ impl<Http: HttpClient> Client<Http> {
         Ok(tasks)
     }
 
+    /// Get the network configuration (sharding).
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, features::ExperimentalFeatures};
+    /// #
+    /// # let MEILISEARCH_URL = option_env!("MEILISEARCH_URL").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// #
+    /// # tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async {
+    /// # let client = Client::new(MEILISEARCH_URL, Some(MEILISEARCH_API_KEY)).unwrap();
+    /// # ExperimentalFeatures::new(&client).set_network(true).update().await.unwrap();
+    /// let network = client.get_network().await.unwrap();
+    /// # });
+    /// ```
+    pub async fn get_network(&self) -> Result<Network, Error> {
+        let network = self
+            .http_client
+            .request::<(), (), Network>(
+                &format!("{}/network", self.host),
+                Method::Get { query: () },
+                200,
+            )
+            .await?;
+
+        Ok(network)
+    }
+
+    /// Update the network configuration (sharding).
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use meilisearch_sdk::{client::*, features::ExperimentalFeatures, network::*};
+    /// #
+    /// # let MEILISEARCH_URL = option_env!("MEILISEARCH_URL").unwrap_or("http://localhost:7700");
+    /// # let MEILISEARCH_API_KEY = option_env!("MEILISEARCH_API_KEY").unwrap_or("masterKey");
+    /// #
+    /// # tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async {
+    /// # let client = Client::new(MEILISEARCH_URL, Some(MEILISEARCH_API_KEY)).unwrap();
+    /// # ExperimentalFeatures::new(&client).set_network(true).update().await.unwrap();
+    /// let network = client.update_network(
+    ///     NetworkUpdate::new()
+    ///          // .reset_self()
+    ///          // .reset_remotes()
+    ///          // .delete_remotes(&["ms-00"])
+    ///          .with_self("ms-00")
+    ///          .with_remotes(&[Remote {
+    ///              name: "ms-00".to_string(),
+    ///              url: "http://localhost:7700".to_string(),
+    ///              search_api_key: Some("secret".to_string()),
+    ///          }]),
+    /// )
+    /// .await.unwrap();
+    /// # });
+    /// ```
+    pub async fn update_network(&self, network_update: &NetworkUpdate) -> Result<Network, Error> {
+        self.http_client
+            .request::<(), &NetworkUpdate, Network>(
+                &format!("{}/network", self.host),
+                Method::Patch {
+                    body: network_update,
+                    query: (),
+                },
+                200,
+            )
+            .await
+    }
+
     /// Generates a new tenant token.
     ///
     /// # Example
@@ -1166,7 +1237,10 @@ mod tests {
 
     use meilisearch_test_macro::meilisearch_test;
 
-    use crate::{client::*, key::Action, reqwest::qualified_version};
+    use crate::{
+        client::*, features::ExperimentalFeatures, key::Action, network::Remote,
+        reqwest::qualified_version,
+    };
 
     #[derive(Debug, Serialize, Deserialize, PartialEq)]
     struct Document {
@@ -1316,6 +1390,80 @@ mod tests {
         assert_eq!(tasks.limit, 20);
     }
 
+    async fn enable_network(client: &Client) {
+        ExperimentalFeatures::new(client)
+            .set_network(true)
+            .update()
+            .await
+            .unwrap();
+    }
+
+    #[meilisearch_test]
+    async fn test_get_network(client: Client) {
+        enable_network(&client).await;
+
+        let network = client.get_network().await.unwrap();
+        assert!(matches!(
+            network,
+            Network {
+                self_: _,
+                remotes: _,
+            }
+        ))
+    }
+
+    #[meilisearch_test]
+    async fn test_update_network_self(client: Client) {
+        enable_network(&client).await;
+
+        client
+            .update_network(NetworkUpdate::new().reset_self())
+            .await
+            .unwrap();
+
+        let network = client
+            .update_network(NetworkUpdate::new().with_self("ms-00"))
+            .await
+            .unwrap();
+
+        assert_eq!(network.self_, Some("ms-00".to_string()));
+    }
+
+    #[meilisearch_test]
+    async fn test_update_network_remotes(client: Client) {
+        enable_network(&client).await;
+
+        client
+            .update_network(NetworkUpdate::new().reset_remotes())
+            .await
+            .unwrap();
+
+        let network = client
+            .update_network(NetworkUpdate::new().with_remotes(&[Remote {
+                name: "ms-00".to_string(),
+                url: "http://localhost:7700".to_string(),
+                search_api_key: Some("secret".to_string()),
+            }]))
+            .await
+            .unwrap();
+
+        assert_eq!(
+            network.remotes,
+            vec![Remote {
+                name: "ms-00".to_string(),
+                url: "http://localhost:7700".to_string(),
+                search_api_key: Some("secret".to_string()),
+            }]
+        );
+
+        let network = client
+            .update_network(NetworkUpdate::new().delete_remotes(&["ms-00"]))
+            .await
+            .unwrap();
+
+        assert_eq!(network.remotes, vec![]);
+    }
+
     #[meilisearch_test]
     async fn test_get_keys(client: Client) {
         let keys = client.get_keys().await.unwrap();

src/features.rs

@@ -8,7 +8,13 @@ use serde::{Deserialize, Serialize};
 /// Struct representing the experimental features result from the API.
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
-pub struct ExperimentalFeaturesResult {}
+pub struct ExperimentalFeaturesResult {
+    pub metrics: bool,
+    pub logs_route: bool,
+    pub contains_filter: bool,
+    pub network: bool,
+    pub edit_documents_by_function: bool,
+}
 
 /// Struct representing the experimental features request.
 ///
@@ -28,12 +34,30 @@ pub struct ExperimentalFeaturesResult {}
 pub struct ExperimentalFeatures<'a, Http: HttpClient> {
     #[serde(skip_serializing)]
     client: &'a Client<Http>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metrics: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub contains_filter: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub logs_route: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub network: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edit_documents_by_function: Option<bool>,
 }
 
 impl<'a, Http: HttpClient> ExperimentalFeatures<'a, Http> {
     #[must_use]
     pub fn new(client: &'a Client<Http>) -> Self {
-        ExperimentalFeatures { client }
+        ExperimentalFeatures {
+            client,
+            metrics: None,
+            logs_route: None,
+            network: None,
+            contains_filter: None,
+            edit_documents_by_function: None,
+        }
     }
 
     /// Get all the experimental features
@@ -88,6 +112,34 @@ impl<'a, Http: HttpClient> ExperimentalFeatures<'a, Http> {
             )
             .await
     }
+
+    pub fn set_metrics(&mut self, metrics: bool) -> &mut Self {
+        self.metrics = Some(metrics);
+        self
+    }
+
+    pub fn set_logs_route(&mut self, logs_route: bool) -> &mut Self {
+        self.logs_route = Some(logs_route);
+        self
+    }
+
+    pub fn set_contains_filter(&mut self, contains_filter: bool) -> &mut Self {
+        self.contains_filter = Some(contains_filter);
+        self
+    }
+
+    pub fn set_edit_documents_by_function(
+        &mut self,
+        edit_documents_by_function: bool,
+    ) -> &mut Self {
+        self.edit_documents_by_function = Some(edit_documents_by_function);
+        self
+    }
+
+    pub fn set_network(&mut self, network: bool) -> &mut Self {
+        self.network = Some(network);
+        self
+    }
 }
 
 #[cfg(test)]
@@ -96,12 +148,52 @@ mod tests {
     use meilisearch_test_macro::meilisearch_test;
 
     #[meilisearch_test]
-    async fn test_experimental_features_get(client: Client) {
-        let features = ExperimentalFeatures::new(&client);
-        // set feature here, once some exist again
+    async fn test_experimental_features_set_metrics(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_metrics(true);
+        let _ = features.update().await.unwrap();
+
+        let res = features.get().await.unwrap();
+        assert!(res.metrics)
+    }
+
+    #[meilisearch_test]
+    async fn test_experimental_features_set_logs_route(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_logs_route(true);
+        let _ = features.update().await.unwrap();
+
+        let res = features.get().await.unwrap();
+        assert!(res.logs_route)
+    }
+
+    #[meilisearch_test]
+    async fn test_experimental_features_set_contains_filter(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_contains_filter(true);
+        let _ = features.update().await.unwrap();
+
+        let res = features.get().await.unwrap();
+        assert!(res.contains_filter)
+    }
+
+    #[meilisearch_test]
+    async fn test_experimental_features_set_network(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_network(true);
+        let _ = features.update().await.unwrap();
+
+        let res = features.get().await.unwrap();
+        assert!(res.network)
+    }
+
+    #[meilisearch_test]
+    async fn test_experimental_features_set_edit_documents_by_function(client: Client) {
+        let mut features = ExperimentalFeatures::new(&client);
+        features.set_edit_documents_by_function(true);
         let _ = features.update().await.unwrap();
 
-        let _res = features.get().await.unwrap();
-        // assert that the feature has been set once they exist again
+        let res = features.get().await.unwrap();
+        assert!(res.edit_documents_by_function)
     }
 }

src/lib.rs

@@ -244,6 +244,8 @@ pub mod features;
 pub mod indexes;
 /// Module containing the [`Key`](key::Key) struct.
 pub mod key;
+// Module containing the [`Network`](network::Network) struct.
+pub mod network;
 pub mod request;
 /// Module related to search queries and results.
 pub mod search;