Rename: collection() requires trait Document

Author: RoDmitry

typesense/src/client/collection/document.rs

@@ -17,10 +17,10 @@ pub struct Document<'c, 'n, D = serde_json::Value>
 where
     D: DeserializeOwned + Serialize + Send + Sync,
 {
-    pub(super) client: &'c Client,
-    pub(super) collection_name: &'n str,
-    pub(super) document_id: String,
-    pub(super) _phantom: std::marker::PhantomData<D>,
+    client: &'c Client,
+    collection_name: &'n str,
+    document_id: String,
+    _phantom: std::marker::PhantomData<D>,
 }
 
 impl<'c, 'n, D> Document<'c, 'n, D>

typesense/src/client/collection/documents.rs

@@ -25,9 +25,9 @@ pub struct Documents<'c, 'n, D = serde_json::Value>
 where
     D: DeserializeOwned + Serialize + Send + Sync,
 {
-    pub(super) client: &'c Client,
-    pub(super) collection_name: &'n str,
-    pub(super) _phantom: std::marker::PhantomData<D>,
+    client: &'c Client,
+    collection_name: &'n str,
+    _phantom: std::marker::PhantomData<D>,
 }
 
 impl<'c, 'n, D> Documents<'c, 'n, D>

typesense/src/client/collection/mod.rs

@@ -16,9 +16,9 @@ pub struct Collection<'c, 'n, D = serde_json::Value>
 where
     D: DeserializeOwned + Serialize + Send + Sync,
 {
-    pub(super) client: &'c Client,
-    pub(super) collection_name: &'n str,
-    pub(super) _phantom: std::marker::PhantomData<D>,
+    client: &'c Client,
+    collection_name: &'n str,
+    _phantom: std::marker::PhantomData<D>,
 }
 
 impl<'c, 'n, D> Collection<'c, 'n, D>

typesense/src/client/mod.rs

@@ -112,7 +112,7 @@ mod key;
 mod keys;
 mod multi_search;
 
-use crate::Error;
+use crate::{Error, traits::Document};
 use collection::Collection;
 use collections::Collections;
 use key::Key;
@@ -392,7 +392,7 @@ impl Client {
     /// #    .build()
     /// #    .unwrap();
     /// // Get a typed handle to the "books" collection
-    /// let books_collection = client.collection_of::<Book>("books");
+    /// let books_collection = client.collection_named::<Book>("books");
     ///
     /// // Retrieve a single book, it returns `Result<Book, ...>`
     /// let book = books_collection.document("123").retrieve().await?;
@@ -403,13 +403,58 @@ impl Client {
     /// # }
     /// ```
     #[inline]
-    pub fn collection_of<'c, 'n, T>(&'c self, collection_name: &'n str) -> Collection<'c, 'n, T>
+    pub fn collection_named<'c, 'n, D>(&'c self, collection_name: &'n str) -> Collection<'c, 'n, D>
     where
-        T: DeserializeOwned + Serialize + Send + Sync,
+        D: DeserializeOwned + Serialize + Send + Sync,
     {
         Collection::new(self, collection_name)
     }
 
+    /// Provides access to API endpoints for a specific collection.
+    ///
+    /// This method returns a `Collection<T>` handle, which is generic over the type of document
+    /// stored in that collection.
+    ///
+    /// # Type Parameters
+    /// * `T` - The type of the documents in the collection. It must be of trait Document.
+    ///
+    /// # Example: Working with a strongly-typed collection
+    ///
+    /// When you want to retrieve or search for documents and have them automatically
+    /// deserialized into your own structs.
+    /// ```no_run
+    /// # #[cfg(not(target_family = "wasm"))]
+    /// # {
+    /// # use typesense::Client;
+    /// # use serde::{Serialize, Deserialize};
+    /// #
+    /// # #[derive(Serialize, Deserialize, Debug)]
+    /// # struct Book { id: String, title: String }
+    /// # async fn run() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let client = Client::builder()
+    /// #    .nodes(vec!["http://localhost:8108"])
+    /// #    .api_key("xyz")
+    /// #    .build()
+    /// #    .unwrap();
+    /// // Get a typed handle to the "books" collection
+    /// let books_collection = client.collection::<Book>;
+    ///
+    /// // Retrieve a single book, it returns `Result<Book, ...>`
+    /// let book = books_collection.document("123").retrieve().await?;
+    /// println!("Retrieved book: {:?}", book);
+    /// #
+    /// # Ok(())
+    /// # }
+    /// # }
+    /// ```
+    #[inline]
+    pub fn collection<'c, 'n, D>(&'c self) -> Collection<'c, 'n, D>
+    where
+        D: Document + Send + Sync,
+    {
+        Collection::new(self, D::COLLECTION_NAME)
+    }
+
     /// Provides access to API endpoints for a specific collection using schemaless `serde_json::Value` documents.
     ///
     /// This is the simplest way to interact with a collection when you do not need strong typing.
@@ -432,18 +477,18 @@ impl Client {
     /// #    .api_key("xyz")
     /// #    .build()
     /// #    .unwrap();
-    /// let products_collection = client.collection("products");
+    /// let products_collection = client.collection_schemaless("products");
     /// #
     /// # Ok(())
     /// # }
     /// # }
     /// ```
     #[inline]
-    pub fn collection<'c, 'n>(
+    pub fn collection_schemaless<'c, 'n>(
         &'c self,
         collection_name: &'n str,
     ) -> Collection<'c, 'n, serde_json::Value> {
-        self.collection_of(collection_name)
+        Collection::new(self, collection_name)
     }
 
     /// Provides access to endpoints for managing the collection of API keys.

typesense/src/traits/document.rs

@@ -9,6 +9,9 @@ use serde::{Serialize, de::DeserializeOwned};
 /// Trait that should implement every struct that wants to be represented as a Typesense
 /// Document
 pub trait Document: DeserializeOwned + Serialize {
+    /// Collection name
+    const COLLECTION_NAME: &'static str;
+
     /// Collection schema associated with the document.
     fn collection_schema() -> CollectionSchema;
 }

typesense/tests/client/client_test.rs

@@ -61,7 +61,7 @@ async fn test_success_on_first_node() {
 
     let client = get_client(vec![server1.uri()], None);
 
-    let result = client.collection("products").retrieve().await;
+    let result = client.collection_schemaless("products").retrieve().await;
 
     assert!(result.is_ok());
     assert_eq!(result.unwrap().name, "products");
@@ -78,7 +78,7 @@ async fn test_failover_to_second_node() {
 
     let client = get_client(vec![server1.uri(), server2.uri()], None);
 
-    let result = client.collection("products").retrieve().await;
+    let result = client.collection_schemaless("products").retrieve().await;
     assert!(result.is_ok());
 
     // The first server should have been tried and failed.
@@ -96,7 +96,7 @@ async fn test_nearest_node_is_prioritized() {
 
     let client = get_client(vec![regular_server.uri()], Some(nearest_server.uri()));
 
-    let result = client.collection("products").retrieve().await;
+    let result = client.collection_schemaless("products").retrieve().await;
     assert!(result.is_ok());
 
     // Only the nearest node should have received a request.
@@ -113,7 +113,7 @@ async fn test_failover_from_nearest_to_regular_node() {
 
     let client = get_client(vec![regular_server.uri()], Some(nearest_server.uri()));
 
-    let result = client.collection("products").retrieve().await;
+    let result = client.collection_schemaless("products").retrieve().await;
     assert!(result.is_ok());
 
     // Nearest node should have failed.
@@ -134,7 +134,13 @@ async fn test_round_robin_failover() {
     let client = get_client(vec![server1.uri(), server2.uri(), server3.uri()], None);
 
     // First request should fail over to the third node
-    assert!(client.collection("products").retrieve().await.is_ok());
+    assert!(
+        client
+            .collection_schemaless("products")
+            .retrieve()
+            .await
+            .is_ok()
+    );
 
     assert_eq!(server1.received_requests().await.unwrap().len(), 1);
     assert_eq!(server2.received_requests().await.unwrap().len(), 1);
@@ -151,7 +157,13 @@ async fn test_round_robin_failover() {
     server2.reset().await;
     setup_mock_server_ok(&server2, "products").await;
 
-    assert!(client.collection("products").retrieve().await.is_ok());
+    assert!(
+        client
+            .collection_schemaless("products")
+            .retrieve()
+            .await
+            .is_ok()
+    );
 
     // Server 3 was tried first and failed.
     assert_eq!(server3.received_requests().await.unwrap().len(), 1);
@@ -179,12 +191,24 @@ async fn test_health_check_and_node_recovery() {
         .expect("Failed to create client");
 
     // 1. First request fails over to server2, marking server1 as unhealthy.
-    assert!(client.collection("products").retrieve().await.is_ok());
+    assert!(
+        client
+            .collection_schemaless("products")
+            .retrieve()
+            .await
+            .is_ok()
+    );
     assert_eq!(server1.received_requests().await.unwrap().len(), 1);
     assert_eq!(server2.received_requests().await.unwrap().len(), 1);
 
     // 2. Immediate second request should go directly to server2.
-    assert!(client.collection("products").retrieve().await.is_ok());
+    assert!(
+        client
+            .collection_schemaless("products")
+            .retrieve()
+            .await
+            .is_ok()
+    );
     assert_eq!(server1.received_requests().await.unwrap().len(), 1); // No new request
     assert_eq!(server2.received_requests().await.unwrap().len(), 2); // Got another request
 
@@ -196,7 +220,13 @@ async fn test_health_check_and_node_recovery() {
     setup_mock_server_ok(&server1, "products").await;
 
     // 5. The next request should try server1 again (due to healthcheck expiry) and succeed.
-    assert!(client.collection("products").retrieve().await.is_ok());
+    assert!(
+        client
+            .collection_schemaless("products")
+            .retrieve()
+            .await
+            .is_ok()
+    );
     assert_eq!(server1.received_requests().await.unwrap().len(), 1); // Server 1 received its first successful req
     assert_eq!(server2.received_requests().await.unwrap().len(), 2); // No new request for server 2
 }
@@ -210,7 +240,7 @@ async fn test_all_nodes_fail() {
 
     let client = get_client(vec![server1.uri(), server2.uri()], None);
 
-    let result = client.collection("products").retrieve().await;
+    let result = client.collection_schemaless("products").retrieve().await;
     assert!(result.is_err());
 
     match result.err().unwrap() {
@@ -233,7 +263,7 @@ async fn test_fail_fast_on_non_retriable_error() {
 
     let client = get_client(vec![server1.uri(), server2.uri()], None);
 
-    let result = client.collection("products").retrieve().await;
+    let result = client.collection_schemaless("products").retrieve().await;
     assert!(result.is_err());
 
     // Check that the error is the non-retriable API error.
@@ -264,9 +294,9 @@ async fn test_load_balancing_with_healthy_nodes() {
     let client = get_client(vec![server1.uri(), server2.uri(), server3.uri()], None);
 
     // 3. Make three consecutive requests
-    let result1 = client.collection("products").retrieve().await;
-    let result2 = client.collection("products").retrieve().await;
-    let result3 = client.collection("products").retrieve().await;
+    let result1 = client.collection_schemaless("products").retrieve().await;
+    let result2 = client.collection_schemaless("products").retrieve().await;
+    let result3 = client.collection_schemaless("products").retrieve().await;
 
     // 4. Assert all requests were successful
     assert!(result1.is_ok());

typesense/tests/client/collections_test.rs

@@ -32,7 +32,10 @@ async fn logic_test_collections_and_collection_lifecycle() {
     assert_eq!(created_collection.name, collection_name);
 
     // --- 2. Retrieve the specific Collection (via `collection`) ---
-    let retrieve_one_result = client.collection(&collection_name).retrieve().await;
+    let retrieve_one_result = client
+        .collection_schemaless(&collection_name)
+        .retrieve()
+        .await;
     assert!(
         retrieve_one_result.is_ok(),
         "Failed to retrieve the newly created collection."
@@ -80,7 +83,7 @@ async fn logic_test_collections_and_collection_lifecycle() {
     };
 
     let update_result = client
-        .collection(&collection_name)
+        .collection_schemaless(&collection_name)
         .update(update_schema)
         .await;
     assert!(update_result.is_ok(), "Failed to update collection");
@@ -94,7 +97,10 @@ async fn logic_test_collections_and_collection_lifecycle() {
     );
 
     // --- 6. Verify the update by retrieving the full schema again ---
-    let retrieve_after_update_result = client.collection(&collection_name).retrieve().await;
+    let retrieve_after_update_result = client
+        .collection_schemaless(&collection_name)
+        .retrieve()
+        .await;
     let retrieved_after_update = retrieve_after_update_result.unwrap();
 
     // Initial fields: name, price. Update: +description, -price. Final fields: name, description.
@@ -126,11 +132,17 @@ async fn logic_test_collections_and_collection_lifecycle() {
     );
 
     // --- 7. Delete the Collection (via `collection`) ---
-    let delete_result = client.collection(&collection_name).delete().await;
+    let delete_result = client
+        .collection_schemaless(&collection_name)
+        .delete()
+        .await;
     assert!(delete_result.is_ok(), "Failed to delete collection");
 
     // --- 8. Verify Deletion ---
-    let get_after_delete_result = client.collection(&collection_name).retrieve().await;
+    let get_after_delete_result = client
+        .collection_schemaless(&collection_name)
+        .retrieve()
+        .await;
     assert!(
         get_after_delete_result.is_err(),
         "Collection should not exist after deletion"