feat: multi-node client

Author: haydenhoang

typesense-go-unwrapped-api-spec.yaml renamed to openapi.yml

@@ -26,12 +26,15 @@ sha2 = "0.10"
 typesense_derive = { version = "0.1.0", path = "../typesense_derive", optional = true }
 typesense_codegen = { version = "0.25.0", path = "../typesense_codegen" }
 reqwest-retry = "0.7.0"
-reqwest = { version = "0.11", features = ["json"] }
-reqwest-middleware = { version = "0.3", features = ["json"] }
+reqwest = { version = "0.12", features = ["json"] }
+reqwest-middleware = { version = "0.4.2", features = ["json"] }
+thiserror = "1.0"
 
 [dev-dependencies]
 dotenvy = "0.15"
 trybuild = "1.0.42"
+tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
+wiremock = "0.5"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
 tokio = { version = "1.5", features = ["macros", "rt", "rt-multi-thread"] }
@@ -50,3 +53,6 @@ required-features = ["derive"]
 name = "api_tests"
 path = "tests/api/lib.rs"
 
+[[test]]
+name = "client"
+path = "tests/client/mod.rs"

preprocessed_openapi.yml

@@ -0,0 +1,46 @@
+//! Provides access to the API endpoint for posting analytics events.
+//!
+//! An `Events` instance is created via the `Client::analytics().events()` method.
+
+use super::{Client, Error};
+use std::sync::Arc;
+use typesense_codegen::{
+    apis::{analytics_api, configuration},
+    models,
+};
+
+/// Provides methods for interacting with analytics events.
+///
+/// This struct is created by calling `client.analytics().events()`.
+pub struct Events<'a> {
+    pub(super) client: &'a Client,
+}
+
+impl<'a> Events<'a> {
+    /// Creates a new `Events` instance.
+    pub(super) fn new(client: &'a Client) -> Self {
+        Self { client }
+    }
+
+    /// Posts an analytics event for tracking user behavior.
+    ///
+    /// This is useful for features like "search result ranking based on popularity."
+    ///
+    /// # Arguments
+    /// * `schema` - An `AnalyticsEventCreateSchema` object representing the event.
+    pub async fn create(
+        &self,
+        schema: models::AnalyticsEventCreateSchema,
+    ) -> Result<models::AnalyticsEventCreateResponse, Error<analytics_api::CreateAnalyticsEventError>>
+    {
+        let params = analytics_api::CreateAnalyticsEventParams {
+            analytics_event_create_schema: schema,
+        };
+        self.client
+            .execute(|config: Arc<configuration::Configuration>| {
+                let params_for_move = params.clone();
+                async move { analytics_api::create_analytics_event(&config, params_for_move).await }
+            })
+            .await
+    }
+}

typesense/Cargo.toml

@@ -0,0 +1,44 @@
+//! Provides access to the analytics API endpoints for managing rules and posting events.
+//!
+//! An `Analytics` instance is created via the main `Client::analytics()` method.
+pub mod events;
+pub mod rule;
+pub mod rules;
+use super::{Client, Error};
+pub use events::Events;
+pub use rule::Rule;
+pub use rules::Rules;
+
+/// Provides methods for interacting with Typesense analytics rules and events.
+///
+/// This struct is created by calling `client.analytics()`.
+pub struct Analytics<'a> {
+    pub(super) client: &'a Client,
+}
+
+impl<'a> Analytics<'a> {
+    /// Creates a new `Analytics` instance.
+    pub(super) fn new(client: &'a Client) -> Self {
+        Self { client }
+    }
+
+    /// Provides access to endpoints for managing a collection of analytics rules.
+    pub fn rules(&self) -> Rules<'a> {
+        Rules::new(self.client)
+    }
+
+    /// Provides access to endpoints for managing a single analytics rule.
+    ///
+    /// # Arguments
+    /// * `rule_name` - The name of the analytics rule to manage.
+    pub fn rule(&self, rule_name: &'a str) -> Rule<'a> {
+        Rule::new(self.client, rule_name)
+    }
+
+    /// Provides access to the endpoint for creating analytics events.
+    ///
+    /// Example: `client.analytics().events().create(...).await`
+    pub fn events(&self) -> Events<'a> {
+        Events::new(self.client)
+    }
+}

typesense/src/client/analytics/events.rs

@@ -0,0 +1,56 @@
+//! Provides access to the API endpoints for managing a single analytics rule.
+//!
+//! An `Rule` instance is created via the `Client::analytics().rule("rule_name")` method.
+
+use super::{Client, Error};
+use std::sync::Arc;
+use typesense_codegen::{
+    apis::{analytics_api, configuration},
+    models,
+};
+
+/// Provides methods for interacting with a specific analytics rule.
+///
+/// This struct is created by calling `analytics.rule("rule_name")`.
+pub struct Rule<'a> {
+    pub(super) client: &'a Client,
+    pub(super) rule_name: &'a str,
+}
+
+impl<'a> Rule<'a> {
+    /// Creates a new `Rule` instance for a specific rule name.
+    pub(super) fn new(client: &'a Client, rule_name: &'a str) -> Self {
+        Self { client, rule_name }
+    }
+
+    /// Retrieves the details of this specific analytics rule.
+    pub async fn retrieve(
+        &self,
+    ) -> Result<models::AnalyticsRuleSchema, Error<analytics_api::RetrieveAnalyticsRuleError>> {
+        let params = analytics_api::RetrieveAnalyticsRuleParams {
+            rule_name: self.rule_name.to_string(),
+        };
+        self.client
+            .execute(|config: Arc<configuration::Configuration>| {
+                let params_for_move = params.clone();
+                async move { analytics_api::retrieve_analytics_rule(&config, params_for_move).await }
+            })
+            .await
+    }
+
+    /// Permanently deletes this specific analytics rule.
+    pub async fn delete(
+        &self,
+    ) -> Result<models::AnalyticsRuleDeleteResponse, Error<analytics_api::DeleteAnalyticsRuleError>>
+    {
+        let params = analytics_api::DeleteAnalyticsRuleParams {
+            rule_name: self.rule_name.to_string(),
+        };
+        self.client
+            .execute(|config: Arc<configuration::Configuration>| {
+                let params_for_move = params.clone();
+                async move { analytics_api::delete_analytics_rule(&config, params_for_move).await }
+            })
+            .await
+    }
+}

typesense/src/client/analytics/mod.rs

@@ -0,0 +1,79 @@
+//! Provides access to the API endpoints for managing analytics rules.
+//!
+//! An `Rules` instance is created via the `Client::analytics().rules()` method.
+
+use super::{Client, Error};
+use std::sync::Arc;
+use typesense_codegen::{
+    apis::{analytics_api, configuration},
+    models,
+};
+
+/// Provides methods for interacting with a collection of analytics rules.
+///
+/// This struct is created by calling `client.analytics().rules()`.
+pub struct Rules<'a> {
+    pub(super) client: &'a Client,
+}
+
+impl<'a> Rules<'a> {
+    /// Creates a new `Rules` instance.
+    pub(super) fn new(client: &'a Client) -> Self {
+        Self { client }
+    }
+
+    /// Creates a new analytics rule.
+    ///
+    /// # Arguments
+    /// * `schema` - An `AnalyticsRuleSchema` object describing the rule to be created.
+    pub async fn create(
+        &self,
+        schema: models::AnalyticsRuleSchema,
+    ) -> Result<models::AnalyticsRuleSchema, Error<analytics_api::CreateAnalyticsRuleError>> {
+        let params = analytics_api::CreateAnalyticsRuleParams {
+            analytics_rule_schema: schema,
+        };
+        self.client
+            .execute(|config: Arc<configuration::Configuration>| {
+                let params_for_move = params.clone();
+                async move { analytics_api::create_analytics_rule(&config, params_for_move).await }
+            })
+            .await
+    }
+
+    /// Creates or updates an analytics rule with the given name.
+    ///
+    /// # Arguments
+    /// * `rule_name` - The name of the analytics rule to create or update.
+    /// * `schema` - An `AnalyticsRuleUpsertSchema` object with the rule's parameters.
+    pub async fn upsert(
+        &self,
+        rule_name: &str,
+        schema: models::AnalyticsRuleUpsertSchema,
+    ) -> Result<models::AnalyticsRuleSchema, Error<analytics_api::UpsertAnalyticsRuleError>> {
+        let params = analytics_api::UpsertAnalyticsRuleParams {
+            rule_name: rule_name.to_string(),
+            analytics_rule_upsert_schema: schema,
+        };
+        self.client
+            .execute(|config: Arc<configuration::Configuration>| {
+                let params_for_move = params.clone();
+                async move { analytics_api::upsert_analytics_rule(&config, params_for_move).await }
+            })
+            .await
+    }
+
+    /// Retrieves the details of all analytics rules.
+    pub async fn retrieve(
+        &self,
+    ) -> Result<
+        models::AnalyticsRulesRetrieveSchema,
+        Error<analytics_api::RetrieveAnalyticsRulesError>,
+    > {
+        self.client
+            .execute(|config: Arc<configuration::Configuration>| async move {
+                analytics_api::retrieve_analytics_rules(&config).await
+            })
+            .await
+    }
+}

typesense/src/client/analytics/rule.rs

@@ -0,0 +1,83 @@
+//! Provides access to API endpoints for a single document within a Typesense collection.
+//!
+//! An instance of `Document` is scoped to a specific document and is created
+//! via a parent `Collection` struct, for example:
+//! `client.collection("collection_name").document("document_id")`
+
+use super::{Client, Error};
+use std::sync::Arc;
+use typesense_codegen::apis::{configuration, documents_api};
+
+/// Provides methods for interacting with a single document within a specific Typesense collection.
+///
+/// This struct is created by calling a method like `collection.document("document_id")`.
+pub struct Document<'a> {
+    pub(super) client: &'a Client,
+    pub(super) collection_name: &'a str,
+    pub(super) document_id: &'a str,
+}
+
+impl<'a> Document<'a> {
+    /// Creates a new `Document` instance for a specific document ID.
+    /// This is intended for internal use by the parent `Documents` struct.
+    pub(super) fn new(client: &'a Client, collection_name: &'a str, document_id: &'a str) -> Self {
+        Self {
+            client,
+            collection_name,
+            document_id,
+        }
+    }
+
+    /// Fetches this individual document from the collection.
+    pub async fn get(&self) -> Result<serde_json::Value, Error<documents_api::GetDocumentError>> {
+        let params = documents_api::GetDocumentParams {
+            collection_name: self.collection_name.to_string(),
+            document_id: self.document_id.to_string(),
+        };
+
+        self.client
+            .execute(|config: Arc<configuration::Configuration>| {
+                let params_for_move = params.clone();
+                async move { documents_api::get_document(&config, params_for_move).await }
+            })
+            .await
+    }
+
+    /// Updates this individual document. The update can be partial.
+    ///
+    /// # Arguments
+    /// * `document` - A `serde_json::Value` containing the fields to update.
+    pub async fn update(
+        &self,
+        document: serde_json::Value,
+    ) -> Result<serde_json::Value, Error<documents_api::UpdateDocumentError>> {
+        let params = documents_api::UpdateDocumentParams {
+            collection_name: self.collection_name.to_string(),
+            document_id: self.document_id.to_string(),
+            body: document,
+            dirty_values: None,
+        };
+        self.client
+            .execute(|config: Arc<configuration::Configuration>| {
+                let params_for_move = params.clone();
+                async move { documents_api::update_document(&config, params_for_move).await }
+            })
+            .await
+    }
+
+    /// Deletes this individual document from the collection.
+    pub async fn delete(
+        &self,
+    ) -> Result<serde_json::Value, Error<documents_api::DeleteDocumentError>> {
+        let params = documents_api::DeleteDocumentParams {
+            collection_name: self.collection_name.to_string(),
+            document_id: self.document_id.to_string(),
+        };
+        self.client
+            .execute(|config: Arc<configuration::Configuration>| {
+                let params_for_move = params.clone();
+                async move { documents_api::delete_document(&config, params_for_move).await }
+            })
+            .await
+    }
+}