Rename: collection() requires trait Document

Author: RoDmitry

typesense/src/client/collection/document.rs

@@ -2,30 +2,31 @@
 //!
 //! An instance of `Document` is scoped to a specific document and is created
 //! via a parent `Collection` struct, for example:
-//! `client.collection::<Book>("books").document("123")`
+//! `client.collection::<Book>().document("123")`
 
 use crate::{Client, Error, execute_wrapper};
 use serde::{Serialize, de::DeserializeOwned};
 use typesense_codegen::apis::documents_api;
 
 /// Provides methods for interacting with a single document within a specific Typesense collection.
 ///
-/// This struct is created by calling a method like `client.collection("collection_name").document("document_id")` or `client.collection_of::<MyType>("collection_name").document("document_id")`.
-/// The generic `T` represents the shape of the document and must implement `Serialize` and `DeserializeOwned`.
-/// If `T` is not specified, it defaults to `serde_json::Value` for schemaless interactions.
+/// This struct is created by calling a method like `client.collection_schemaless("collection_name").document("document_id")`
+/// or `client.collection::<MyType>().document("document_id")`.
+/// The generic `D` represents the shape of the document and must implement `Serialize` and `DeserializeOwned`.
+/// If `D` is not specified, it defaults to `serde_json::Value` for schemaless interactions.
 pub struct Document<'c, 'n, D = serde_json::Value>
 where
-    D: DeserializeOwned + Serialize + Send + Sync,
+    D: DeserializeOwned + Serialize,
 {
-    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>
 where
-    D: DeserializeOwned + Serialize + Send + Sync,
+    D: DeserializeOwned + Serialize,
 {
     /// Creates a new `Document` instance for a specific document ID.
     #[inline]
@@ -38,10 +39,10 @@ where
         }
     }
 
-    /// Fetches this individual document from the collection and deserializes it into `T`.
+    /// Fetches this individual document from the collection and deserializes it into `D`.
     ///
     /// # Returns
-    /// A `Result` containing the strongly-typed document `T` if successful.
+    /// A `Result` containing the strongly-typed document `D` if successful.
     pub async fn retrieve(&self) -> Result<D, Error<documents_api::GetDocumentError>> {
         let params = documents_api::GetDocumentParams {
             collection_name: self.collection_name.to_owned(),
@@ -62,7 +63,7 @@ where
     /// * `params` - An optional `DocumentIndexParameters` struct to specify additional parameters, such as `dirty_values` which determines what Typesense should do when the type of a particular field being indexed does not match the previously inferred type for that field, or the one defined in the collection's schema.
     ///
     /// # Returns
-    /// A `Result` containing the full, updated document deserialized into `T`.
+    /// A `Result` containing the full, updated document deserialized into `D`.
     ///
     /// # Example
     /// ```no_run
@@ -81,15 +82,15 @@ where
     /// let book_update = serde_json::json!({ "pages": 654 });
     ///
     /// // Simple update
-    /// let updated_book = client.collection_of::<Book>("books").document("123")
+    /// let updated_book = client.collection_named::<Book>("books").document("123")
     ///     .update(&book_update, None)
     ///     .await?;
     ///
     /// // Update with additional parameters
     /// let params = models::DocumentIndexParameters {
     ///     dirty_values: Some(models::DirtyValues::CoerceOrReject),
     /// };
-    /// let updated_book_with_params = client.collection_of::<Book>("books").document("124")
+    /// let updated_book_with_params = client.collection_named::<Book>("books").document("124")
     ///     .update(&book_update, Some(params))
     ///     .await?;
     /// #
@@ -118,7 +119,7 @@ where
     /// The deleted document is returned.
     ///
     /// # Returns
-    /// A `Result` containing the deleted document deserialized into `T`.
+    /// A `Result` containing the deleted document deserialized into `D`.
     pub async fn delete(&self) -> Result<D, Error<documents_api::DeleteDocumentError>> {
         let params = documents_api::DeleteDocumentParams {
             collection_name: self.collection_name.to_owned(),

typesense/src/client/collection/documents.rs

@@ -1,8 +1,8 @@
 //! Provides access to the document, search, and override-related API endpoints.
 //!
 //! An instance of `Documents` is scoped to a specific collection and is created
-//! via the main `client.collection("collection_name").documents()` method or
-//! `client.collection_of::<T>("...").documents()`.
+//! via the main `client.collection_schemaless("collection_name").documents()` method or
+//! `client.collection_named::<T>("...").documents()`.
 
 use crate::{
     Client, Error, execute_wrapper,
@@ -18,21 +18,21 @@ use typesense_codegen::{
 };
 /// Provides methods for interacting with documents within a specific Typesense collection.
 ///
-/// This struct is generic over the document type `T`. If created via `client.collection(...)`,
-/// `T` defaults to `serde_json::Value`. If created via `client.collection_of::<MyType>(...)`,
-/// `T` will be `MyType`.
+/// This struct is generic over the document type `D`. If created via `client.collection_schemaless(...)`,
+/// `D` defaults to `serde_json::Value`. If created via `client.collection_named::<MyType>(...)`,
+/// `D` will be `MyType`.
 pub struct Documents<'c, 'n, D = serde_json::Value>
 where
-    D: DeserializeOwned + Serialize + Send + Sync,
+    D: DeserializeOwned + Serialize,
 {
-    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>
 where
-    D: DeserializeOwned + Serialize + Send + Sync,
+    D: DeserializeOwned + Serialize,
 {
     /// Creates a new `Documents` instance.
     #[inline]
@@ -85,7 +85,7 @@ where
     /// Creates a new document or updates an existing one if an ID match is found.
     ///
     /// This method requires the full document to be sent. For partial updates, use
-    /// `collection("...").document("...").update()`. The indexed document is returned.
+    /// `collection().document("...").update()`. The indexed document is returned.
     ///
     /// # Arguments
     /// * `document` - A serializable struct or a `serde_json::Value` representing the document to upsert.
@@ -184,7 +184,7 @@ where
     }
 
     /// Searches for documents in the collection that match the given criteria.
-    /// The search results will have their `document` field deserialized into type `T`.
+    /// The search results will have their `document` field deserialized into type `D`.
     ///
     /// # Arguments
     /// * `params` - A `SearchParameters` struct containing all search parameters.

typesense/src/client/collection/mod.rs

@@ -11,19 +11,19 @@ use typesense_codegen::{apis::collections_api, models};
 
 /// Provides methods for interacting with a Typesense collection.
 ///
-/// This struct is created by calling `client.collection("collection_name")`.
+/// This struct is created by calling `client.collection()`.
 pub struct Collection<'c, 'n, D = serde_json::Value>
 where
-    D: DeserializeOwned + Serialize + Send + Sync,
+    D: DeserializeOwned + Serialize,
 {
-    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>
 where
-    D: DeserializeOwned + Serialize + Send + Sync,
+    D: DeserializeOwned + Serialize,
 {
     /// Creates a new `Collection` instance.
     #[inline]

typesense/src/client/mod.rs

@@ -33,7 +33,7 @@
 //!         .unwrap();
 //!
 //!     // Retrieve details for a collection
-//!     let collection = client.collection("products").retrieve().await?;
+//!     let collection = client.collection_schemaless("products").retrieve().await?;
 //!     println!("Collection Name: {}", collection.name);
 //!
 //!     // Search for a document
@@ -44,7 +44,7 @@
 //!     };
 //!
 //!     let search_results = client
-//!         .collection("products")
+//!         .collection_schemaless("products")
 //!         .documents()
 //!         .search(search_params)
 //!         .await?;
@@ -84,7 +84,7 @@
 //!             .unwrap();
 //!
 //!         // Retrieve details for a collection
-//!         match client.collection("products").retrieve().await {
+//!         match client.collection_schemaless("products").retrieve().await {
 //!             Ok(collection) => println!("Collection Name: {}", collection.name),
 //!             Err(e) => eprintln!("Error retrieving collection: {}", e),
 //!         }
@@ -96,7 +96,7 @@
 //!             ..Default::default()
 //!         };
 //!
-//!         match client.collection("products").documents().search(search_params).await {
+//!         match client.collection_schemaless("products").documents().search(search_params).await {
 //!             Ok(search_results) => {
 //!                 println!("Found {} hits.", search_results.found.unwrap_or(0));
 //!             }
@@ -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;
@@ -368,7 +368,7 @@ impl Client {
     /// stored in that collection.
     ///
     /// # Type Parameters
-    /// * `T` - The type of the documents in the collection. It must be serializable and deserializable.
+    /// * `D` - The type of the documents in the collection. It must be serializable and deserializable.
     ///
     /// # Arguments
     /// * `collection_name` - The name of the collection to interact with.
@@ -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,17 +403,62 @@ 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,
     {
         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
+    /// * `D` - 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, Typesense};
+    /// # use serde::{Serialize, Deserialize};
+    /// #
+    /// # #[derive(Typesense, 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,
+    {
+        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.
-    /// It is a convenient shorthand for `client.collection_of::<serde_json::Value>("...")`.
+    /// It is a convenient shorthand for `client.collection_named::<serde_json::Value>("...")`.
     ///
     /// The returned handle can be used for both document operations (which will return `serde_json::Value`)
     /// and collection-level operations (like `.delete()` or `.retrieve()`).
@@ -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/src/traits/multi_search_ext.rs

@@ -12,11 +12,11 @@ pub trait MultiSearchResultExt {
     /// * `index` - The zero-based index of the search result to parse.
     ///
     /// # Type Parameters
-    /// * `T` - The concrete document type to deserialize the hits into.
-    fn parse_at<T: DeserializeOwned>(
+    /// * `D` - The concrete document type to deserialize the hits into.
+    fn parse_at<D: DeserializeOwned>(
         &self,
         index: usize,
-    ) -> Result<SearchResult<T>, MultiSearchParseError>;
+    ) -> Result<SearchResult<D>, MultiSearchParseError>;
 }
 
 /// Small helpers to convert documents stored as `serde_json::Value` into a concrete `D`.