feat(fts): bind per-collection analyzers

Retain a collection → analyzer name map on FtsCollectionManager and add
a `TextOp::SetAnalyzer` handler so indexes created after DDL binds an
analyzer inherit it.

Author: farhan-syah

nodedb-lite/src/engine/fts/analyzer.rs

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Apache-2.0
+
+//! Per-collection analyzer binding for Lite's FTS indexes.
+//!
+//! Mirrors Origin's `TextOp::SetAnalyzer`: the analyzer name is persisted into
+//! each index's backend metadata via `FtsIndex::set_collection_analyzer`, so
+//! `analyze_for_collection` resolves it for every later tokenization of that
+//! collection's text — indexing and query-time scoring alike.
+//!
+//! Lite shards one collection across several `FtsIndex` instances — a
+//! whole-document index keyed `"{collection}:_doc"` plus one per indexed field
+//! keyed `"{collection}:{field}"` — and passes that composite key as the
+//! `collection` argument to nodedb-fts. The analyzer therefore has to be bound
+//! on every one of a collection's indexes under its own key, including indexes
+//! that do not exist yet: DDL normally sets the analyzer before any document is
+//! written, so the name is also retained in `collection_analyzers` and applied
+//! to each index at creation time.
+
+use super::manager::FtsCollectionManager;
+use crate::engine::fts::{LiteFtsIndex, MemoryBackend};
+use nodedb_fts::FtsIndex;
+
+impl FtsCollectionManager {
+    /// Bind `analyzer_name` to every index belonging to `collection`, and
+    /// retain it so indexes created later inherit the same analyzer.
+    ///
+    /// Unrecognized names fall back to the standard analyzer inside
+    /// nodedb-fts at resolve time, matching Origin's behavior.
+    pub fn set_collection_analyzer(&mut self, collection: &str, analyzer_name: &str) {
+        self.collection_analyzers
+            .insert(collection.to_string(), analyzer_name.to_string());
+
+        let prefix = format!("{collection}:");
+        for (key, idx) in self.indices.iter_mut() {
+            if key.starts_with(&prefix) {
+                let _ = idx.set_collection_analyzer(0, 0, key, analyzer_name);
+            }
+        }
+    }
+
+    /// Analyzer bound to the collection owning `key`, if any.
+    ///
+    /// `key` is the composite `"{collection}:{field}"` index key; the
+    /// collection is the portion before the last `:`, so field names
+    /// containing `:` do not split incorrectly.
+    pub(crate) fn analyzer_for_key(&self, key: &str) -> Option<&str> {
+        let collection = key.rsplit_once(':').map(|(c, _)| c)?;
+        self.collection_analyzers
+            .get(collection)
+            .map(String::as_str)
+    }
+
+    /// Create an index for `key`, applying the collection's bound analyzer.
+    ///
+    /// Used at every index-creation site so an analyzer bound before the first
+    /// write is not silently lost for indexes materialized afterwards.
+    pub(crate) fn new_index_for(&self, key: &str) -> LiteFtsIndex {
+        let idx = FtsIndex::new(MemoryBackend::new());
+        if let Some(name) = self.analyzer_for_key(key) {
+            let _ = idx.set_collection_analyzer(0, 0, key, name);
+        }
+        idx
+    }
+}

nodedb-lite/src/engine/fts/manager.rs

@@ -35,7 +35,7 @@ pub struct FtsResult {
 pub struct FtsCollectionManager {
     /// Key: `"{collection}:{field}"` → FTS index.
     /// Whole-document index uses key `"{collection}:_doc"`.
-    indices: HashMap<String, FtsIndex<MemoryBackend>>,
+    pub(super) indices: HashMap<String, FtsIndex<MemoryBackend>>,
     /// Forward map: original string doc_id → dense u32 surrogate.
     ///
     /// Surrogates **must** be dense (0, 1, 2, …) because `nodedb_fts::Memtable`
@@ -55,6 +55,13 @@ pub struct FtsCollectionManager {
     /// Needed by `FtsDeleteDoc` to translate the Origin surrogate back to the
     /// Lite string doc_id without dropping the whole collection.
     origin_surrogate_to_doc_id: HashMap<u32, String>,
+    /// Collection name → bound analyzer name, from `TextOp::SetAnalyzer`.
+    ///
+    /// Retained so indexes created after the analyzer was bound inherit it —
+    /// DDL normally binds the analyzer before the first document is written,
+    /// when none of the collection's indexes exist yet. See
+    /// `super::analyzer` for the binding logic.
+    pub(super) collection_analyzers: HashMap<String, String>,
 }
 
 impl FtsCollectionManager {
@@ -67,6 +74,7 @@ impl FtsCollectionManager {
             // rejected by FtsIndex::index_document with SurrogateOutOfRange.
             next_surrogate: 1,
             origin_surrogate_to_doc_id: HashMap::new(),
+            collection_analyzers: HashMap::new(),
         }
     }
 
@@ -111,10 +119,8 @@ impl FtsCollectionManager {
         }
         let surrogate = self.surrogate_for(doc_id);
         let key = format!("{collection}:_doc");
-        let idx = self
-            .indices
-            .entry(key.clone())
-            .or_insert_with(|| FtsIndex::new(MemoryBackend::new()));
+        let fresh = self.new_index_for(&key);
+        let idx = self.indices.entry(key.clone()).or_insert(fresh);
         // Remove old entry first (upsert semantics).
         let _ = idx.remove_document(0, 0, &key, surrogate);
         let _ = idx.index_document(0, 0, &key, surrogate, text);
@@ -415,10 +421,8 @@ impl FtsCollectionManager {
         }
         let surrogate = self.surrogate_for(doc_id);
         let key = format!("{collection}:{field}");
-        let idx = self
-            .indices
-            .entry(key.clone())
-            .or_insert_with(|| FtsIndex::new(MemoryBackend::new()));
+        let fresh = self.new_index_for(&key);
+        let idx = self.indices.entry(key.clone()).or_insert(fresh);
         let _ = idx.remove_document(0, 0, &key, surrogate);
         let _ = idx.index_document(0, 0, &key, surrogate, text);
     }

nodedb-lite/src/engine/fts/mod.rs

@@ -1,3 +1,4 @@
+pub mod analyzer;
 pub mod checkpoint;
 pub mod manager;
 pub mod search;

nodedb-lite/src/query/physical_visitor/text_op.rs

@@ -471,5 +471,26 @@ pub(super) fn execute_text_op<'a, S: StorageEngine + 'a>(
                 })
             }))
         }
+
+        TextOp::SetAnalyzer {
+            collection,
+            analyzer_name,
+        } => {
+            let collection = collection.clone();
+            let analyzer_name = analyzer_name.clone();
+            let fts_state = Arc::clone(&engine.fts_state);
+            Ok(Box::pin(async move {
+                let mut mgr = fts_state
+                    .manager
+                    .lock()
+                    .map_err(|_| LiteError::LockPoisoned)?;
+                mgr.set_collection_analyzer(&collection, &analyzer_name);
+                Ok(QueryResult {
+                    columns: vec![],
+                    rows: vec![],
+                    rows_affected: 0,
+                })
+            }))
+        }
     }
 }