Use structs from generated code for collectionSchema and Fields

Author: morenol

typesense/src/collection/schema.rs

@@ -4,38 +4,8 @@
 //! is roughly equivalent to a table in a relational database.
 //!
 use crate::field::Field;
-use serde::{Deserialize, Serialize};
+pub use typesense_codegen::models::CollectionSchema;
 
-/// Schema used to create collections in the [Typesense API](https://typesense.org/docs/0.19.0/api/collections.html#create-a-collection).
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-pub struct CollectionSchema {
-    /// Name of the collection you wish to create.
-    name: String,
-    /// A list of fields that you wish to index for querying, filtering and faceting.
-    fields: Vec<Field>,
-    /// Optional: The name of an int32 / float field that determines the order in which the search
-    /// results are ranked when a sort_by clause is not provided during searching.
-    /// When not present, text match score and insertion order are used
-    #[serde(skip_serializing_if = "Option::is_none")]
-    default_sorting_field: Option<String>,
-}
-
-impl CollectionSchema {
-    /// Reference to the name of the Collection
-    pub fn name(&self) -> &String {
-        &self.name
-    }
-
-    /// Reference to the fields of the Collection
-    pub fn fields(&self) -> &Vec<Field> {
-        &self.fields
-    }
-
-    /// Reference to the default_sorting_field of the Collection
-    pub fn default_sorting_field(&self) -> &Option<String> {
-        &self.default_sorting_field
-    }
-}
 /// Builder for the [CollectionSchema] struct.
 #[derive(Debug, Default)]
 pub struct CollectionSchemaBuilder {
@@ -84,6 +54,8 @@ impl CollectionSchemaBuilder {
             name: self.name.ok_or("name is not set")?,
             fields: self.fields.ok_or("typesense_type is not set")?,
             default_sorting_field: self.default_sorting_field,
+            symbols_to_index: None,
+            token_separators: None,
         })
     }
 }
@@ -97,15 +69,15 @@ mod test {
     #[test]
     fn collection_schema_serializes_as_expected() {
         let fields = [
-            ("company_name", FieldType::String, None),
-            ("num_employees", FieldType::Int32, None),
-            ("country", FieldType::String, Some(true)),
+            ("company_name", "string", None),
+            ("num_employees", "int32", None),
+            ("country", "string", Some(true)),
         ]
         .iter()
         .map(|(name, typesense_type, facet)| {
             FieldBuilder::new()
                 .name(name.to_string())
-                .typesense_type(*typesense_type)
+                .typesense_type(typesense_type.to_string())
                 .facet(*facet)
                 .build()
                 .unwrap()

typesense/src/field/field_type.rs

@@ -1,67 +1,37 @@
-use serde::{Deserialize, Serialize};
-
-/// Types that are supported by [Typesense](https://github.com/typesense/typesense/blob/v0.19.0/include/field.h#L8).
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Copy)]
-#[serde(rename_all = "lowercase")]
-pub enum FieldType {
-    /// string
-    String,
-    /// int32
-    Int32,
-    /// int64
-    Int64,
-    /// float
-    Float,
-    /// bool
-    Bool,
-    /// string[]
-    #[serde(rename = "string[]")]
-    StringArray,
-    /// int32[]
-    #[serde(rename = "int32[]")]
-    Int32Array,
-    /// int64[]
-    #[serde(rename = "int64[]")]
-    Int64Array,
-    /// float[]
-    #[serde(rename = "float[]")]
-    FloatArray,
-    /// bool[]
-    #[serde(rename = "bool[]")]
-    BoolArray,
-}
+/// Type for a field. Currently it is a wrapping to a `String` but it could be extended to a enum
+pub type FieldType = String;
 
 /// Trait that should implement each type of a document, in order to properly serialize the
 /// Collection Schema according to the Typesense reference.
 pub trait ToTypesenseField {
     /// Static function that should implement the types of the typesense documents.
-    fn to_typesense_type() -> FieldType;
+    fn to_typesense_type() -> &'static str;
 }
 
 /// macro used internally to add implementations of ToTypesenseField for several rust types.
 #[macro_export]
 macro_rules! impl_to_typesense_field (
     ($from:ty, $typesense_variant:expr) => {
         impl ToTypesenseField for $from {
-            fn to_typesense_type() -> FieldType {
+            fn to_typesense_type() -> &'static str {
                 $typesense_variant
             }
         }
     };
 );
 
-impl_to_typesense_field!(String, FieldType::String);
-impl_to_typesense_field!(u8, FieldType::Int32);
-impl_to_typesense_field!(i32, FieldType::Int32);
-impl_to_typesense_field!(i64, FieldType::Int64);
-impl_to_typesense_field!(u32, FieldType::Int64);
-impl_to_typesense_field!(usize, FieldType::Int64);
-impl_to_typesense_field!(f32, FieldType::Float);
-impl_to_typesense_field!(f64, FieldType::Float);
-impl_to_typesense_field!(bool, FieldType::Bool);
-impl_to_typesense_field!(Vec<String>, FieldType::StringArray);
-impl_to_typesense_field!(Vec<i32>, FieldType::Int32Array);
-impl_to_typesense_field!(Vec<i64>, FieldType::Int64Array);
-impl_to_typesense_field!(Vec<f32>, FieldType::FloatArray);
-impl_to_typesense_field!(Vec<f64>, FieldType::FloatArray);
-impl_to_typesense_field!(Vec<bool>, FieldType::BoolArray);
+impl_to_typesense_field!(String, "string");
+impl_to_typesense_field!(u8, "int32");
+impl_to_typesense_field!(i32, "int32");
+impl_to_typesense_field!(i64, "int64");
+impl_to_typesense_field!(u32, "int64");
+impl_to_typesense_field!(usize, "int64");
+impl_to_typesense_field!(f32, "float");
+impl_to_typesense_field!(f64, "float");
+impl_to_typesense_field!(bool, "bool");
+impl_to_typesense_field!(Vec<String>, "string[]");
+impl_to_typesense_field!(Vec<i32>, "int32[]");
+impl_to_typesense_field!(Vec<i64>, "int64[]");
+impl_to_typesense_field!(Vec<f32>, "float[]");
+impl_to_typesense_field!(Vec<f64>, "float[]");
+impl_to_typesense_field!(Vec<bool>, "bool[]");

typesense/src/field/mod.rs

@@ -2,28 +2,9 @@
 //! [fields](https://github.com/typesense/typesense/blob/v0.19.0/include/field.)
 //! available in Typesense.
 
-use serde::{Deserialize, Serialize};
-
 mod field_type;
 pub use field_type::*;
-
-/// Struct used to represent a [field](https://github.com/typesense/typesense/blob/v0.19.0/include/field.) in Typesense.
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-pub struct Field {
-    /// Required. The name of the field.
-    name: String,
-    /// Required. The `FieldType` of the field.
-    #[serde(rename = "type")]
-    typesense_type: FieldType,
-    /// Optional parameter. Indicates if the field is optional or not.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    optional: Option<bool>,
-    /// Optional parameter. Faceted fields are indexed verbatim without
-    /// any tokenization or preprocessing. For example, if you are building
-    /// a product search, color and brand could be defined as facet fields.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    facet: Option<bool>,
-}
+pub use typesense_codegen::models::Field;
 
 /// Builder for the `Field` struct.
 #[derive(Debug, Default)]
@@ -32,6 +13,11 @@ pub struct FieldBuilder {
     typesense_type: Option<FieldType>,
     optional: Option<bool>,
     facet: Option<bool>,
+    index: Option<bool>,
+    locale: Option<String>,
+    sort: Option<bool>,
+    drop: Option<bool>,
+    infix: Option<bool>,
 }
 
 impl FieldBuilder {
@@ -64,14 +50,49 @@ impl FieldBuilder {
         self
     }
 
+    /// Set if field is index.
+    pub fn index(mut self, index: Option<bool>) -> Self {
+        self.index = index;
+        self
+    }
+
+    /// Set field locale.
+    pub fn locale(mut self, locale: Option<String>) -> Self {
+        self.locale = locale;
+        self
+    }
+
+    /// Set sort attribute from field
+    pub fn sort(mut self, sort: Option<bool>) -> Self {
+        self.sort = sort;
+        self
+    }
+
+    /// Set drop attribute from field
+    pub fn drop(mut self, drop: Option<bool>) -> Self {
+        self.drop = drop;
+        self
+    }
+
+    /// Set infix attribute from field
+    pub fn infix(mut self, infix: Option<bool>) -> Self {
+        self.infix = infix;
+        self
+    }
+
     /// Create a `Field` with the current values of the builder,
     /// It can fail if the name or the typesense_type are not defined.
     pub fn build(self) -> Result<Field, Box<dyn std::error::Error>> {
         Ok(Field {
             name: self.name.ok_or("name is not set")?,
-            typesense_type: self.typesense_type.ok_or("typesense_type is not set")?,
+            _type: self.typesense_type.ok_or("typesense_type is not set")?,
             optional: self.optional,
             facet: self.facet,
+            index: self.index,
+            sort: self.sort,
+            drop: self.drop,
+            locale: self.locale,
+            infix: self.infix,
         })
     }
 }

typesense/tests/collection_client.rs

@@ -1,11 +1,12 @@
 use serde::{Deserialize, Serialize};
-use typesense::document::Document as DocumentTrait;
-use typesense::ClientBuilder;
 use typesense::Document;
 
 #[cfg(all(test, feature = "tokio-rt", not(target_arch = "wasm32")))]
 mod hyper_tests {
     use super::*;
+    use typesense::document::Document as DocumentTrait;
+    use typesense::ClientBuilder;
+
     #[tokio::test]
     async fn collection_create() {
         let host = "http://localhost:5000";

typesense_derive/src/lib.rs

@@ -385,7 +385,7 @@ fn to_typesense_field_type(field: &Field) -> syn::Result<proc_macro2::TokenStrea
         (&field.ty, quote!(None))
     };
     let typesense_field_type = quote!(
-            <#ty as typesense::field::ToTypesenseField>::to_typesense_type()
+            <#ty as typesense::field::ToTypesenseField>::to_typesense_type().to_string()
     );
     Ok(quote! {
         typesense::field::FieldBuilder::new()