feat: create Client and ClientBuilder structs (#11)

* feat: create Client and ClientBuilder structs

* refactor: associate HttpLowLevel with struct from the http crate

* use bytes::Bytes instead of Vec<u8>

Co-authored-by: Luis Moreno <morenol@users.noreply.github.com>

Author: morenol

Cargo.toml

@@ -13,6 +13,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 async-trait = "0.1.50"
+bytes = "1.0.1"
 http = "0.2.4"
 thiserror = "1.0.24"
 

mocks/get_api_key_header.yaml

@@ -0,0 +1,14 @@
+when:
+  method: GET
+  path: /test_api_key
+  header:
+    - name: X-TYPESENSE-API-KEY
+      value: VerySecretKey
+then:
+  status: 200
+  header:
+    - name: content-type
+      value: text/html
+    - name: Access-Control-Allow-Origin
+      value: \*
+  body: "Test with api key successful"

mocks/post_api_key.yaml

@@ -0,0 +1,13 @@
+when:
+  method: POST
+  path: /test_api_key
+  header:
+    - name: X-TYPESENSE-API-KEY
+      value: VerySecretKey
+  body: "Test with api key successful"
+then:
+  status: 200
+  header:
+    - name: content-type
+      value: text/html
+  body: "Test with api key successful"

src/client/builder.rs

@@ -0,0 +1,91 @@
+use super::Client;
+use crate::transport::Transport;
+
+#[cfg(target_arch = "wasm32")]
+use crate::transport::WasmClient;
+
+use crate::{Result, TypesenseError};
+/// Builder for the Typesense [`Client`]
+pub struct ClientBuilder<'a, T> {
+    transport: Option<Transport<T>>,
+    host: Option<&'a str>,
+    api_key: Option<&'a str>,
+}
+
+impl<'a, T> ClientBuilder<'a, T> {
+    /// build [`Client`] with the current configurations. Return [`typesense::TypesenseError::ConfigError`]
+    /// if a configuration is missing.
+    pub fn build(self) -> Result<Client<'a, T>> {
+        Ok(Client {
+            transport: self.transport.ok_or_else(|| {
+                TypesenseError::ConfigError("missing client transport".to_string())
+            })?,
+            host: self
+                .host
+                .ok_or_else(|| TypesenseError::ConfigError("missing client host".to_string()))?,
+            api_key: self
+                .api_key
+                .ok_or_else(|| TypesenseError::ConfigError("missing client api key".to_string()))?,
+        })
+    }
+
+    /// Set host
+    pub fn host(mut self, host: &'a str) -> Self {
+        self.host = Some(host);
+        self
+    }
+
+    /// Set api key
+    pub fn api_key(mut self, api_key: &'a str) -> Self {
+        self.api_key = Some(api_key);
+        self
+    }
+
+    /// Set transport
+    pub fn transport(mut self, transport: Transport<T>) -> Self {
+        self.transport = Some(transport);
+        self
+    }
+}
+
+impl<'a, T> Default for ClientBuilder<'a, T> {
+    fn default() -> Self {
+        Self {
+            transport: None,
+            host: None,
+            api_key: None,
+        }
+    }
+}
+
+#[cfg(all(feature = "tokio-rt", not(target_arch = "wasm32")))]
+#[cfg_attr(
+    docsrs,
+    doc(cfg(all(feature = "tokio-rt", not(target_arch = "wasm32"))))
+)]
+impl<'a> ClientBuilder<'a, crate::transport::HyperHttpsClient> {
+    /// Create client builder with a [`hyper`](https://docs.rs/hyper) client.
+    /// The connector used is [`HttpsConnector`](hyper_tls::HttpsConnector).
+    pub fn new_hyper() -> Self {
+        let transport = Some(crate::transport::TransportBuilder::new_hyper().build());
+        Self {
+            transport,
+            host: None,
+            api_key: None,
+        }
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+#[cfg_attr(docsrs, doc(cfg(target_arch = "wasm32")))]
+impl<'a> ClientBuilder<'a, WasmClient> {
+    /// Create client builder using default wasm client
+    pub fn new_wasm() -> Self {
+        let transport = Some(crate::transport::TransportBuilder::new_wasm().build());
+        Self {
+            transport,
+            host: None,
+            api_key: None,
+        }
+    }
+}

src/client/mod.rs

@@ -0,0 +1,142 @@
+use bytes::Bytes;
+
+use crate::transport::HttpLowLevel;
+use crate::transport::Transport;
+use crate::Result;
+
+mod builder;
+pub use builder::ClientBuilder;
+
+#[allow(dead_code)]
+pub const TYPESENSE_API_KEY_HEADER_NAME: &str = "X-TYPESENSE-API-KEY";
+
+/// Root client for top level APIs
+pub struct Client<'a, T> {
+    transport: Transport<T>,
+    host: &'a str,
+    api_key: &'a str,
+}
+
+impl<'a, T> Client<'a, T> {
+    /// Gets the transport of the client
+    pub fn transport(&self) -> &Transport<T> {
+        &self.transport
+    }
+}
+
+#[allow(dead_code)]
+impl<'a, C> Client<'a, C>
+where
+    C: HttpLowLevel,
+{
+    pub(crate) async fn send(
+        &self,
+        method: http::Method,
+        path: &str,
+        body: Bytes,
+    ) -> Result<C::Response> {
+        let uri = format!("{}{}", self.host, path);
+        let mut headers = http::HeaderMap::default();
+        headers.insert(TYPESENSE_API_KEY_HEADER_NAME, self.api_key.parse().unwrap());
+        self.transport.send(method, &uri, headers, body).await
+    }
+
+    pub(crate) async fn get(&self, path: &str) -> Result<C::Response> {
+        self.send(http::Method::GET, path, Bytes::new()).await
+    }
+
+    pub(crate) async fn post(&self, path: &str, body: Bytes) -> Result<C::Response> {
+        self.send(http::Method::POST, path, body).await
+    }
+}
+
+#[cfg(all(test, feature = "tokio-rt", not(target_arch = "wasm32")))]
+mod hyper_tests {
+    use http::StatusCode;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn hyper() -> crate::Result<()> {
+        let body = String::from("Test with api key successful");
+        let host = "http://localhost:5000";
+        let api_key = "VerySecretKey";
+
+        let client = ClientBuilder::new_hyper()
+            .host(host)
+            .api_key(api_key)
+            .build()
+            .unwrap();
+
+        let response = client.get("/test_api_key").await?;
+
+        assert_eq!(response.status(), StatusCode::OK);
+        let bytes = hyper::body::to_bytes(response).await?;
+        assert_eq!(bytes, body.as_bytes());
+
+        let response = client.post("/test_api_key", body.clone().into()).await?;
+
+        assert_eq!(response.status(), StatusCode::OK);
+        let bytes = hyper::body::to_bytes(response).await?;
+        assert_eq!(bytes, body.as_bytes());
+
+        Ok(())
+    }
+}
+
+#[cfg(all(test, target_arch = "wasm32"))]
+mod wasm_test {
+    wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
+
+    use http::StatusCode;
+    use wasm_bindgen::prelude::*;
+    use wasm_bindgen_test::wasm_bindgen_test;
+
+    use super::*;
+
+    #[wasm_bindgen]
+    extern "C" {
+        #[wasm_bindgen(js_namespace = console)]
+        fn log(s: &str);
+    }
+
+    macro_rules! console_log {
+        ($($t:tt)*) => (log(&format_args!($($t)*).to_string()))
+    }
+
+    #[wasm_bindgen_test]
+    async fn wasm() {
+        console_error_panic_hook::set_once();
+
+        console_log!("Test Started.");
+        match try_wasm().await {
+            Ok(_) => console_log!("Test Successful."),
+            Err(e) => console_log!("Test failed: {:?}", e),
+        }
+    }
+
+    async fn try_wasm() -> crate::Result<()> {
+        let body = String::from("Test with api key successful");
+
+        let host = "http://localhost:5000";
+        let api_key = "VerySecretKey";
+
+        let client = ClientBuilder::new_wasm()
+            .host(host)
+            .api_key(api_key)
+            .build()
+            .unwrap();
+
+        let response = client.get("/test_api_key").await?;
+
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(response.body(), body.as_bytes());
+
+        let response = client.post("/test_api_key", body.clone().into()).await?;
+
+        assert_eq!(response.status(), StatusCode::OK);
+        assert_eq!(response.body(), body.as_bytes());
+
+        Ok(())
+    }
+}

src/error.rs

@@ -6,15 +6,16 @@ use thiserror::Error;
 pub type Result<T> = std::result::Result<T, TypesenseError>;
 
 /// Represents an error that can occur while using the library.
+#[non_exhaustive]
 #[derive(Error, Debug)]
 pub enum TypesenseError {
     /// TypesenseClientError
     #[error("typesense client error")]
     TypesenseClientError,
 
     /// Config error.
-    #[error("config error")]
-    ConfigError,
+    #[error("config error: {0}")]
+    ConfigError(String),
 
     /// Timeout.
     #[error("timeout")]

src/lib.rs

@@ -5,7 +5,9 @@
 //!
 //! Welcome to typesense, the rust library for the Typesense API.
 
+mod client;
 mod error;
 pub mod transport;
 
+pub use client::{Client, ClientBuilder};
 pub use error::{Result, TypesenseError};

src/transport/http_low_level.rs

@@ -1,4 +1,5 @@
 use async_trait::async_trait;
+use bytes::Bytes;
 
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) type HyperClient<C> = hyper::Client<C, hyper::Body>;
@@ -14,26 +15,17 @@ pub(crate) struct WasmClient;
 
 /// A low level HTTP trait.
 #[async_trait(?Send)]
-pub trait HttpLowLevel {
-    /// HTTP Method type.
-    type Method;
-
-    /// HTTP Header map type.
-    type HeaderMap;
-
-    /// HTTP Body type.
-    type Body;
-
+pub trait HttpLowLevel<M = http::Method, H = http::HeaderMap> {
     /// HTTP Response type.
     type Response;
 
     /// Send a request and receive a response.
     async fn send(
         &self,
-        method: Self::Method,
+        method: M,
         uri: &str,
-        headers: Self::HeaderMap,
-        body: Self::Body,
+        headers: H,
+        body: Bytes,
     ) -> crate::Result<Self::Response>;
 }
 
@@ -43,17 +35,14 @@ impl<C> HttpLowLevel for HyperClient<C>
 where
     C: hyper::client::connect::Connect + Clone + Send + Sync + 'static,
 {
-    type Method = http::Method;
-    type HeaderMap = http::HeaderMap;
-    type Body = Vec<u8>;
     type Response = http::Response<hyper::Body>;
 
     async fn send(
         &self,
-        method: Self::Method,
+        method: http::Method,
         uri: &str,
-        headers: Self::HeaderMap,
-        body: Self::Body,
+        headers: http::HeaderMap,
+        body: Bytes,
     ) -> crate::Result<Self::Response> {
         // Making a builder
         let mut builder = http::Request::builder().method(method).uri(uri);
@@ -78,17 +67,14 @@ where
 #[cfg(target_arch = "wasm32")]
 #[async_trait(?Send)]
 impl HttpLowLevel for WasmClient {
-    type Method = http::Method;
-    type HeaderMap = http::HeaderMap;
-    type Body = Vec<u8>;
-    type Response = http::Response<Self::Body>;
+    type Response = http::Response<Vec<u8>>;
 
     async fn send(
         &self,
-        method: Self::Method,
+        method: http::Method,
         uri: &str,
-        headers: Self::HeaderMap,
-        body: Self::Body,
+        headers: http::HeaderMap,
+        body: Bytes,
     ) -> crate::Result<Self::Response> {
         use js_sys::{Array, ArrayBuffer, Reflect, Uint8Array};
         use wasm_bindgen::JsCast;