feat(text-index): Added support for text indexes (#23)

Author: LucFauvel

src/index.rs

@@ -26,12 +26,50 @@ impl From<SortOrder> for Bson {
     }
 }
 
+#[derive(Clone, Debug)]
+enum IndexKey {
+    SortIndex(SortIndexKey),
+    TextIndex(TextIndexKey),
+}
+
+impl IndexKey {
+    fn get_key_name(&self) -> String {
+        match self {
+            IndexKey::SortIndex(s) => match s.direction {
+                SortOrder::Ascending => format!("{}_1", s.name),
+                SortOrder::Descending => format!("{}_-1", s.name),
+            },
+
+            IndexKey::TextIndex(t) => format!("{}_text", t.name),
+        }
+    }
+
+    fn get_name(&self) -> String {
+        match self {
+            IndexKey::SortIndex(s) => s.name.to_string(),
+            IndexKey::TextIndex(t) => t.name.to_string(),
+        }
+    }
+
+    fn get_value(&self) -> Bson {
+        match self {
+            IndexKey::SortIndex(s) => s.direction.into(),
+            IndexKey::TextIndex(_) => "text".into(),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
-struct IndexKey {
+struct SortIndexKey {
     name: Cow<'static, str>,
     direction: SortOrder,
 }
 
+#[derive(Debug, Clone)]
+struct TextIndexKey {
+    name: Cow<'static, str>,
+}
+
 /// Specify field to be used for indexing and options.
 ///
 /// [Mongo manual](https://docs.mongodb.com/manual/indexes/)
@@ -78,6 +116,15 @@ impl Index {
         index
     }
 
+    /// Make a new index for the given key with the text parameter.
+    ///
+    /// [Mongo manual](https://docs.mongodb.com/manual/core/index-single/)
+    pub fn new_with_text(key: impl Into<Cow<'static, str>>) -> Self {
+        let mut index = Self::default();
+        index.add_key_with_text(key);
+        index
+    }
+
     /// Make this index compound adding the given key with ascending direction.
     ///
     /// [Mongo manual](https://docs.mongodb.com/manual/core/index-compound/).
@@ -99,10 +146,18 @@ impl Index {
         key: impl Into<Cow<'static, str>>,
         direction: SortOrder,
     ) {
-        self.keys.push(IndexKey {
+        self.keys.push(IndexKey::SortIndex(SortIndexKey {
             name: key.into(),
             direction,
-        });
+        }));
+    }
+
+    /// Make this index compound adding the given key with text.
+    ///
+    /// [Mongo manual](https://docs.mongodb.com/manual/core/index-compound/).
+    pub fn add_key_with_text(&mut self, key: impl Into<Cow<'static, str>>) {
+        self.keys
+            .push(IndexKey::TextIndex(TextIndexKey { name: key.into() }));
     }
 
     /// Builder style method for `add_key_with_direction`.
@@ -140,13 +195,8 @@ impl Index {
         let mut names = Vec::with_capacity(self.keys.len());
         let mut keys_doc = Document::new();
         for key in self.keys {
-            let key_name = match key.direction {
-                SortOrder::Ascending => format!("{}_1", key.name),
-                SortOrder::Descending => format!("{}_-1", key.name),
-            };
-            names.push(key_name);
-
-            keys_doc.insert(key.name, key.direction);
+            names.push(key.get_key_name());
+            keys_doc.insert(key.get_name(), key.get_value());
         }
 
         let mut index_doc = doc! { "key": keys_doc };
@@ -232,6 +282,8 @@ pub enum IndexOption {
     StorageEngine(Document),
     /// Specifies the collation
     Collation(Document),
+    /// Specifies the weights for text indexes
+    Weights(Vec<(String, i32)>),
     /// Specify a custom index option. This is present to provide forwards compatibility.
     Custom { name: String, value: Bson },
 }
@@ -247,6 +299,7 @@ impl IndexOption {
             IndexOption::ExpireAfterSeconds(..) => "expireAfterSeconds",
             IndexOption::StorageEngine(..) => "storageEngine",
             IndexOption::Collation(..) => "collation",
+            IndexOption::Weights(..) => "weights",
             IndexOption::Custom { name, .. } => name.as_str(),
         }
     }
@@ -261,6 +314,13 @@ impl IndexOption {
             IndexOption::PartialFilterExpression(doc)
             | IndexOption::StorageEngine(doc)
             | IndexOption::Collation(doc) => Bson::Document(doc),
+            IndexOption::Weights(w) => {
+                let mut doc = Document::new();
+                w.into_iter().for_each(|(k, v)| {
+                    doc.insert(k, Bson::from(v));
+                });
+                Bson::Document(doc)
+            }
             IndexOption::Custom { value, .. } => value,
         }
     }

src/lib.rs

@@ -89,14 +89,16 @@
 #[cfg(test)]
 extern crate pretty_assertions;
 
-mod macros;
 mod index;
+mod macros;
 mod repository;
 
 pub mod operator;
 
 pub use index::{sync_indexes, Index, IndexOption, Indexes, SortOrder};
-pub use repository::{BulkUpdate, BulkUpdateResult, BulkUpdateUpsertResult, Repository, CollectionExt};
+pub use repository::{
+    BulkUpdate, BulkUpdateResult, BulkUpdateUpsertResult, CollectionExt, Repository,
+};
 
 // Re-export mongodb
 pub use mongodb as mongo;
@@ -223,9 +225,8 @@ pub mod prelude {
     #[doc(no_inline)]
     pub use crate::{
         f, field, operator::*, pipeline, sync_indexes, BulkUpdate, BulkUpdateResult,
-        BulkUpdateUpsertResult, CollectionConfig, Index, IndexOption, Indexes, Model, Repository,
-        SortOrder,
-        CollectionExt as _, ToRepository as _,
+        BulkUpdateUpsertResult, CollectionConfig, CollectionExt as _, Index, IndexOption, Indexes,
+        Model, Repository, SortOrder, ToRepository as _,
     };
     #[doc(no_inline)]
     pub use futures_util::future::{BoxFuture, FutureExt};

src/repository.rs

@@ -285,7 +285,6 @@ impl<M: Model> Repository<M> {
     }
 }
 
-
 /// MongODM-provided utilities functions on `mongodb::Collection<M>`.
 #[async_trait]
 pub trait CollectionExt {
@@ -329,15 +328,23 @@ pub trait CollectionExt {
     /// assert_eq!(bulk_update_res.nb_modified, 2);
     /// # }
     /// ```
-    async fn bulk_update<V, U>(&self, db: &mongodb::Database, updates: V) -> Result<BulkUpdateResult>
+    async fn bulk_update<V, U>(
+        &self,
+        db: &mongodb::Database,
+        updates: V,
+    ) -> Result<BulkUpdateResult>
     where
         V: 'async_trait + Send + Sync + Borrow<Vec<U>>,
         U: 'async_trait + Send + Sync + Borrow<BulkUpdate>;
 }
 
 #[async_trait]
 impl<M: Send + Sync> CollectionExt for mongodb::Collection<M> {
-    async fn bulk_update<V, U>(&self, db: &mongodb::Database, updates: V) -> Result<BulkUpdateResult>
+    async fn bulk_update<V, U>(
+        &self,
+        db: &mongodb::Database,
+        updates: V,
+    ) -> Result<BulkUpdateResult>
     where
         V: 'async_trait + Send + Sync + Borrow<Vec<U>>,
         U: 'async_trait + Send + Sync + Borrow<BulkUpdate>,
@@ -377,4 +384,4 @@ impl<M: Send + Sync> CollectionExt for mongodb::Collection<M> {
         let res = db.run_command(command, None).await?;
         Ok(from_document(res)?)
     }
-}
+}