Merge #132

132: Remove lifetimes r=curquiza a=ppamorim

In this large PR, I removed the requirement to use explicit lifetimes. This sorts the issue reported #127.

Please let me know if this PR removed any recent modifications in the code.

Co-authored-by: Pedro Paulo de Amorim <[email protected]>

Author: bors[bot]

.github/workflows/tests.yml

@@ -55,4 +55,4 @@ jobs:
     - name: Build
       run:  |
         rustup target add wasm32-unknown-unknown
-        cargo check --example web_app --target wasm32-unknown-unknown
+        cargo check --example web_app --target wasm32-unknown-unknown --features=sync

Cargo.toml

@@ -26,6 +26,7 @@ wasm-bindgen-futures = "0.4"
 [features]
 default = ["isahc-static-curl"]
 isahc-static-curl = ["isahc/static-curl"]
+sync = []
 
 [dev-dependencies]
 env_logger = "0.8"
@@ -36,10 +37,12 @@ futures = "0.3"
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 yew = "0.18"
+lazy_static = "1.4"
 web-sys = "0.3"
 console_error_panic_hook = "0.1"
 
 [[example]]
 name = "web_app"
 crate-type = ["cdylib", "rlib"]
+required-features = ["sync"]
 path = "examples/web_app/src/lib.rs"

README.md

@@ -60,6 +60,7 @@ serde = { version = "1.0", features = ["derive"] }
 ```
 
 This crate is `async` but you can choose to use an async runtime like [tokio](https://crates.io/crates/tokio) or just [block on futures](https://docs.rs/futures/latest/futures/executor/fn.block_on.html).
+You can enable the `sync` feature to make most structs `Sync`. It may be a bit slower.
 
 Using this crate is possible without [serde](https://crates.io/crates/serde), but a lot of features require serde.
 

examples/web_app/Cargo.toml

@@ -12,6 +12,7 @@ wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4.18"
 yew = "0.18"
 meilisearch-sdk = {path="../.."}
+lazy_static = "1.4"
 serde = {version="1.0", features=["derive"]}
 web-sys = "0.3"
 console_error_panic_hook = "0.1"

examples/web_app/src/document.rs

@@ -23,6 +23,7 @@ impl Document for Crate {
 }
 
 impl Crate {
+    
     pub fn get_readable_download_count(&self) -> String {
         if let Some(downloads) = self.downloads {
             if downloads < 1000 {

examples/web_app/src/lib.rs

@@ -8,19 +8,21 @@ use std::rc::Rc;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::spawn_local;
 use yew::prelude::*;
+use lazy_static::lazy_static;
 
 mod document;
 use crate::document::Crate;
 
-// We need a static client because yew's component trait does not allow lifetimes shorter than static
-pub static CLIENT: Client = Client::new(
-    "https://finding-demos.meilisearch.com",
-    "2b902cce4f868214987a9f3c7af51a69fa660d74a785bed258178b96e3480bb3",
-);
+lazy_static! {
+    static ref CLIENT: Client = Client::new(
+        "https://finding-demos.meilisearch.com",
+        "2b902cce4f868214987a9f3c7af51a69fa660d74a785bed258178b96e3480bb3",
+    );
+}
 
 struct Model {
     link: Rc<ComponentLink<Self>>,
-    index: Rc<Index<'static>>, // The lifetime of Index is the lifetime of the client
+    index: Rc<Index>,
     results: Vec<Crate>,
     processing_time_ms: usize,
 

src/client.rs

@@ -1,16 +1,16 @@
-use crate::{errors::*, indexes::*, request::*};
+use crate::{errors::*, indexes::*, request::*, Rc};
 use serde_json::{json, Value};
 use serde::{Deserialize};
 use std::collections::HashMap;
 
 /// The top-level struct of the SDK, representing a client containing [indexes](../indexes/struct.Index.html).
 #[derive(Debug)]
-pub struct Client<'a> {
-    pub(crate) host: &'a str,
-    pub(crate) apikey: &'a str,
+pub struct Client {
+    pub(crate) host: Rc<String>,
+    pub(crate) api_key: Rc<String>,
 }
 
-impl<'a> Client<'a> {
+impl Client {
     /// Create a client using the specified server.
     /// Don't put a '/' at the end of the host.
     /// In production mode, see [the documentation about authentication](https://docs.meilisearch.com/reference/features/authentication.html#authentication).
@@ -22,8 +22,11 @@ impl<'a> Client<'a> {
     /// // create the client
     /// let client = Client::new("http://localhost:7700", "masterKey");
     /// ```
-    pub const fn new(host: &'a str, apikey: &'a str) -> Client<'a> {
-        Client { host, apikey }
+    pub fn new(host: impl Into<String>, api_key: impl Into<String>) -> Client {
+        Client {
+            host: Rc::new(host.into()),
+            api_key: Rc::new(api_key.into())
+        }
     }
 
     /// List all [indexes](../indexes/struct.Index.html).
@@ -40,10 +43,10 @@ impl<'a> Client<'a> {
     /// println!("{:?}", indexes);
     /// # });
     /// ```
-    pub async fn list_all_indexes(&'a self) -> Result<Vec<Index<'a>>, Error> {
+    pub async fn list_all_indexes(&self) -> Result<Vec<Index>, Error> {
         let json_indexes = request::<(), Vec<JsonIndex>>(
             &format!("{}/indexes", self.host),
-            self.apikey,
+            &self.api_key,
             Method::Get,
             200,
         ).await?;
@@ -72,21 +75,22 @@ impl<'a> Client<'a> {
     /// let movies = client.get_index("movies").await.unwrap();
     /// # });
     /// ```
-    pub async fn get_index(&'a self, uid: &'a str) -> Result<Index<'a>, Error> {
+    pub async fn get_index(&self, uid: impl AsRef<str>) -> Result<Index, Error> {
         Ok(request::<(), JsonIndex>(
-            &format!("{}/indexes/{}", self.host, uid),
-            self.apikey,
+            &format!("{}/indexes/{}", self.host, uid.as_ref()),
+            &self.api_key,
             Method::Get,
             200,
         ).await?
         .into_index(self))
     }
 
     /// Assume that an [index](../indexes/struct.Index.html) exist and create a corresponding object without any check.
-    pub fn assume_index(&'a self, uid: &'a str) -> Index<'a> {
+    pub fn assume_index(&self, uid: impl Into<String>) -> Index {
         Index {
-            client: &self,
-            uid: uid.to_string()
+            uid: Rc::new(uid.into()),
+            host: Rc::clone(&self.host),
+            api_key: Rc::clone(&self.api_key)
         }
     }
 
@@ -109,15 +113,15 @@ impl<'a> Client<'a> {
     /// # });
     /// ```
     pub async fn create_index(
-        &'a self,
-        uid: &'a str,
+        &self,
+        uid: impl AsRef<str>,
         primary_key: Option<&str>,
-    ) -> Result<Index<'a>, Error> {
+    ) -> Result<Index, Error> {
         Ok(request::<Value, JsonIndex>(
             &format!("{}/indexes", self.host),
-            self.apikey,
+            &self.api_key,
             Method::Post(json!({
-                "uid": uid,
+                "uid": uid.as_ref(),
                 "primaryKey": primary_key,
             })),
             201,
@@ -142,26 +146,26 @@ impl<'a> Client<'a> {
 
     /// Delete an index from its UID.
     /// To delete an index from the [index object](../indexes/struct.Index.html), use [the delete method](../indexes/struct.Index.html#method.delete).
-    pub async fn delete_index(&self, uid: &str) -> Result<(), Error> {
+    pub async fn delete_index(&self, uid: impl AsRef<str>) -> Result<(), Error> {
         Ok(request::<(), ()>(
-            &format!("{}/indexes/{}", self.host, uid),
-            self.apikey,
+            &format!("{}/indexes/{}", self.host, uid.as_ref()),
+            &self.api_key,
             Method::Delete,
             204,
         ).await?)
     }
 
     /// This will try to get an index and create the index if it does not exist.
-    pub async fn get_or_create(&'a self, uid: &'a str) -> Result<Index<'a>, Error> {
-        if let Ok(index) = self.get_index(uid).await {
+    pub async fn get_or_create(&self, uid: impl AsRef<str>) -> Result<Index, Error> {
+        if let Ok(index) = self.get_index(uid.as_ref()).await {
             Ok(index)
         } else {
             self.create_index(uid, None).await
         }
     }
 
     /// Alias for [list_all_indexes](#method.list_all_indexes).
-    pub async fn get_indexes(&'a self) -> Result<Vec<Index<'a>>, Error> {
+    pub async fn get_indexes(&self) -> Result<Vec<Index>, Error> {
         self.list_all_indexes().await
     }
 
@@ -180,7 +184,7 @@ impl<'a> Client<'a> {
     pub async fn get_stats(&self) -> Result<ClientStats, Error> {
         request::<serde_json::Value, ClientStats>(
             &format!("{}/stats", self.host),
-            self.apikey,
+            &self.api_key,
             Method::Get,
             200,
         ).await
@@ -201,7 +205,7 @@ impl<'a> Client<'a> {
     pub async fn health(&self) -> Result<Health, Error> {
         request::<serde_json::Value, Health>(
             &format!("{}/health", self.host),
-            self.apikey,
+            &self.api_key,
             Method::Get,
             200,
         )
@@ -244,7 +248,7 @@ impl<'a> Client<'a> {
     pub async fn get_keys(&self) -> Result<Keys, Error> {
         request::<(), Keys>(
             &format!("{}/keys", self.host),
-            self.apikey,
+            &self.api_key,
             Method::Get,
             200,
         ).await
@@ -265,7 +269,7 @@ impl<'a> Client<'a> {
     pub async fn get_version(&self) -> Result<Version, Error> {
         request::<(), Version>(
             &format!("{}/version", self.host),
-            self.apikey,
+            &self.api_key,
             Method::Get,
             200,
         ).await

src/dumps.rs

@@ -63,7 +63,7 @@ pub struct DumpInfo {
 
 /// Dump related methods.\
 /// See the [dumps](crate::dumps) module.
-impl<'a> Client<'a> {
+impl Client {
     /// Triggers a dump creation process.
     /// Once the process is complete, a dump is created in the [dumps directory](https://docs.meilisearch.com/reference/features/configuration.html#dumps-destination).
     /// If the dumps directory does not exist yet, it will be created.
@@ -85,7 +85,7 @@ impl<'a> Client<'a> {
     pub async fn create_dump(&self) -> Result<DumpInfo, Error> {
         request::<(), DumpInfo>(
             &format!("{}/dumps", self.host),
-            self.apikey,
+            &self.api_key,
             Method::Post(()),
             202,
         )
@@ -109,10 +109,10 @@ impl<'a> Client<'a> {
     /// let dump_info = client.get_dump_status(&dump_info.uid).await.unwrap();
     /// # });
     /// ```
-    pub async fn get_dump_status(&self, dump_uid: &str) -> Result<DumpInfo, Error> {
+    pub async fn get_dump_status(&self, dump_uid: impl AsRef<str>) -> Result<DumpInfo, Error> {
         request::<(), DumpInfo>(
-            &format!("{}/dumps/{}/status", self.host, dump_uid),
-            self.apikey,
+            &format!("{}/dumps/{}/status", self.host, dump_uid.as_ref()),
+            &self.api_key,
             Method::Get,
             200,
         )
@@ -121,14 +121,14 @@ impl<'a> Client<'a> {
 }
 
 /// Alias for [create_dump](Client::create_dump).
-pub async fn create_dump<'a>(client: &'a Client<'a>) -> Result<DumpInfo, Error> {
+pub async fn create_dump(client: &Client) -> Result<DumpInfo, Error> {
     client.create_dump().await
 }
 
 /// Alias for [get_dump_status](Client::get_dump_status).
-pub async fn get_dump_status<'a>(
-    client: &'a Client<'a>,
-    dump_uid: &str,
+pub async fn get_dump_status(
+    client: &Client,
+    dump_uid: impl AsRef<str>,
 ) -> Result<DumpInfo, Error> {
     client.get_dump_status(dump_uid).await
 }