nidx-binding 6.3.4.post161__tar.gz → 6.3.4.post167__tar.gz

{nidx_binding-6.3.4.post161 → nidx_binding-6.3.4.post167}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.3.4.post161
+Version: 6.3.4.post167
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.3.4.post161 → nidx_binding-6.3.4.post167}/nidx_protos/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "nidx_protos"
-version = "6.3.4.post161"
+version = "6.3.4.post167"
 license = { text = "AGPL" }
 description = "Protobuf definitions for nucliadb/nidx"
 authors = [ { name = "Nuclia", email = "nucliadb@nuclia.com" }]

{nidx_binding-6.3.4.post161 → nidx_binding-6.3.4.post167}/nidx_relation/src/graph_query_parser.rs

@@ -19,10 +19,11 @@
 //
 use anyhow::anyhow;
 use nidx_protos::graph_query::FacetFilter;
+use nidx_protos::graph_query::node::MatchLocation;
 use nidx_protos::relation::RelationType;
 use nidx_protos::relation_node::NodeType;
 use nidx_types::query_language::{BooleanExpression, BooleanOperation, Operator};
-use tantivy::query::{AllQuery, BooleanQuery, FuzzyTermQuery, Occur, Query, TermQuery};
+use tantivy::query::{AllQuery, BooleanQuery, FuzzyTermQuery, Occur, Query, TermQuery, TermSetQuery};
 use tantivy::schema::{Facet, Field, IndexRecordOption};
 use tantivy::tokenizer::TokenizerManager;
 
@@ -41,7 +42,9 @@ pub struct FuzzyTerm {
 #[derive(Clone)]
 pub enum Term {
     Exact(String),
+    ExactWord(String),
     Fuzzy(FuzzyTerm),
+    FuzzyWord(FuzzyTerm),
 }
 
 #[derive(Default, Clone)]
@@ -467,8 +470,8 @@ impl<'a> GraphQueryParser<'a> {
 
     fn has_node_value(&self, value: &Term, exact_field: Field, tokenized_field: Field) -> Option<Box<dyn Query>> {
         let text_value = match value {
-            Term::Exact(value) => value,
-            Term::Fuzzy(fuzzy) => &fuzzy.value,
+            Term::Exact(value) | Term::ExactWord(value) => value,
+            Term::Fuzzy(fuzzy) | Term::FuzzyWord(fuzzy) => &fuzzy.value,
         };
         if text_value.is_empty() {
             return None;
@@ -482,42 +485,38 @@ impl<'a> GraphQueryParser<'a> {
             tokenized_terms.push(tantivy::Term::from_field_text(tokenized_field, &token.text));
         }
 
-        // TODO: Rethink this
-        // Current logic:
-        // - Exact match always match the search term against the full field
-        // - Fuzzy + prefix search works does a prefix fuzzy match of the whole entity name
-        // - Fuzzy search looks for entities containing all words in the term with a fuzzy match (tokenized)
-        //
-        // Questions:
-        // - Do we want exact match of a word in the entity? (kind of supported by setting fuzzy distance = 0)
         let query: Box<dyn Query> = match value {
             Term::Exact(_) => Box::new(TermQuery::new(exact_term, IndexRecordOption::Basic)),
-            Term::Fuzzy(fuzzy) => match fuzzy {
-                FuzzyTerm {
-                    fuzzy_distance,
-                    is_prefix: true,
-                    ..
-                } => Box::new(FuzzyTermQuery::new_prefix(exact_term, *fuzzy_distance, true)),
-
-                FuzzyTerm { fuzzy_distance, .. } => {
-                    if tokenized_terms.len() > 1 {
-                        Box::new(BooleanQuery::intersection(
-                            tokenized_terms
-                                .into_iter()
-                                .map(|term| -> Box<dyn Query> {
-                                    Box::new(FuzzyTermQuery::new(term, *fuzzy_distance, true))
-                                })
-                                .collect(),
-                        ))
-                    } else {
-                        Box::new(FuzzyTermQuery::new(
-                            tokenized_terms.into_iter().next().unwrap(),
-                            *fuzzy_distance,
-                            true,
-                        ))
-                    }
+
+            Term::ExactWord(_) => Box::new(TermSetQuery::new(tokenized_terms)),
+
+            Term::Fuzzy(fuzzy) => {
+                if fuzzy.is_prefix {
+                    Box::new(FuzzyTermQuery::new_prefix(exact_term, fuzzy.fuzzy_distance, true))
+                } else {
+                    Box::new(FuzzyTermQuery::new(exact_term, fuzzy.fuzzy_distance, true))
                 }
-            },
+            }
+
+            Term::FuzzyWord(fuzzy) => {
+                let query_builder = if fuzzy.is_prefix {
+                    FuzzyTermQuery::new_prefix
+                } else {
+                    FuzzyTermQuery::new
+                };
+
+                if tokenized_terms.len() == 1 {
+                    let tokenized_term = tokenized_terms.into_iter().next().unwrap();
+                    Box::new(query_builder(tokenized_term, fuzzy.fuzzy_distance, true))
+                } else {
+                    Box::new(BooleanQuery::intersection(
+                        tokenized_terms
+                            .into_iter()
+                            .map(|term| -> Box<dyn Query> { Box::new(query_builder(term, fuzzy.fuzzy_distance, true)) })
+                            .collect(),
+                    ))
+                }
+            }
         };
 
         Some(query)
@@ -704,13 +703,56 @@ impl TryFrom<&nidx_protos::graph_query::Node> for Node {
     type Error = anyhow::Error;
 
     fn try_from(node_pb: &nidx_protos::graph_query::Node) -> Result<Self, Self::Error> {
-        let value = node_pb.value.clone().map(|value| match node_pb.match_kind() {
-            nidx_protos::graph_query::node::MatchKind::Exact => Term::Exact(value),
-            nidx_protos::graph_query::node::MatchKind::Fuzzy => Term::Fuzzy(FuzzyTerm {
-                value,
-                fuzzy_distance: DEFAULT_NODE_VALUE_FUZZY_DISTANCE,
-                is_prefix: true,
-            }),
+        let value = node_pb.value.clone().map(|value| {
+            if let Some(match_kind) = node_pb.new_match_kind {
+                match match_kind {
+                    nidx_protos::graph_query::node::NewMatchKind::Exact(exact) => match exact.kind() {
+                        MatchLocation::Full => Term::Exact(value),
+                        MatchLocation::Prefix => Term::Fuzzy(FuzzyTerm {
+                            value,
+                            fuzzy_distance: 0,
+                            is_prefix: true,
+                        }),
+                        MatchLocation::Words => Term::ExactWord(value),
+                        MatchLocation::PrefixWords => Term::FuzzyWord(FuzzyTerm {
+                            value,
+                            fuzzy_distance: 0,
+                            is_prefix: true,
+                        }),
+                    },
+                    nidx_protos::graph_query::node::NewMatchKind::Fuzzy(fuzzy) => match fuzzy.kind() {
+                        MatchLocation::Full => Term::Fuzzy(FuzzyTerm {
+                            value,
+                            fuzzy_distance: fuzzy.distance as u8,
+                            is_prefix: false,
+                        }),
+                        MatchLocation::Prefix => Term::Fuzzy(FuzzyTerm {
+                            value,
+                            fuzzy_distance: fuzzy.distance as u8,
+                            is_prefix: true,
+                        }),
+                        MatchLocation::Words => Term::FuzzyWord(FuzzyTerm {
+                            value,
+                            fuzzy_distance: fuzzy.distance as u8,
+                            is_prefix: false,
+                        }),
+                        MatchLocation::PrefixWords => Term::FuzzyWord(FuzzyTerm {
+                            value,
+                            fuzzy_distance: fuzzy.distance as u8,
+                            is_prefix: true,
+                        }),
+                    },
+                }
+            } else {
+                match node_pb.match_kind() {
+                    nidx_protos::graph_query::node::MatchKind::DeprecatedExact => Term::Exact(value),
+                    nidx_protos::graph_query::node::MatchKind::DeprecatedFuzzy => Term::Fuzzy(FuzzyTerm {
+                        value,
+                        fuzzy_distance: DEFAULT_NODE_VALUE_FUZZY_DISTANCE,
+                        is_prefix: true,
+                    }),
+                }
+            }
         });
         let node_type = node_pb.node_type.map(NodeType::try_from).transpose()?;
         let node_subtype = node_pb.node_subtype.clone();

{nidx_binding-6.3.4.post161 → nidx_binding-6.3.4.post167}/nidx_relation/src/reader.rs

@@ -439,13 +439,13 @@ impl RelationsReaderService {
                 let words: Vec<_> = query.split_whitespace().collect();
                 for word in words {
                     prefix_nodes_q.push(Node {
-                        value: Some(Term::Fuzzy(FuzzyTerm {
+                        value: Some(Term::FuzzyWord(FuzzyTerm {
                             value: word.to_string(),
                             fuzzy_distance: FUZZY_DISTANCE,
                             is_prefix: false,
                         })),
                         ..Default::default()
-                    })
+                    });
                 }
 
                 // add fuzzy query for all prefixes

{nidx_binding-6.3.4.post161 → nidx_binding-6.3.4.post167}/nidx_relation/tests/test_graph_search.rs

@@ -21,7 +21,8 @@ mod common;
 
 use std::collections::{HashMap, HashSet};
 
-use nidx_protos::graph_query::node::MatchKind;
+use nidx_protos::graph_query::node::{ExactMatch, FuzzyMatch, NewMatchKind};
+use nidx_protos::graph_query::node::{MatchKind, MatchLocation};
 use nidx_protos::graph_query::path_query::Query;
 use nidx_protos::graph_query::{BoolQuery, FacetFilter, Node, Path, PathQuery, Relation};
 use nidx_protos::graph_search_request::QueryKind;
@@ -132,41 +133,36 @@ fn test_relation_search() -> anyhow::Result<()> {
 fn test_graph_node_query() -> anyhow::Result<()> {
     let reader = create_reader()?;
 
-    // (s)-[]->()
-    let result = search(&reader, Query::Path(Path::default()))?;
-    assert_eq!(result.graph.len(), 17);
-
-    // (:PERSON)-[]->()
+    // (:Anna)-[]->()
     let result = search(
         &reader,
         Query::Path(Path {
             source: Some(Node {
-                node_subtype: Some("PERSON".to_string()),
+                value: Some("Anna".to_string()),
                 ..Default::default()
             }),
             ..Default::default()
         }),
     )?;
-    assert_eq!(result.graph.len(), 12);
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 4);
+    assert!(relations.contains(&("Anna", "FOLLOW", "Erin")));
+    assert!(relations.contains(&("Anna", "LIVE_IN", "New York")));
+    assert!(relations.contains(&("Anna", "LOVE", "Cat")));
+    assert!(relations.contains(&("Anna", "WORK_IN", "New York")));
 
-    // (:Anna)-[]->()
+    // (:PERSON)-[]->()
     let result = search(
         &reader,
         Query::Path(Path {
             source: Some(Node {
                 node_subtype: Some("PERSON".to_string()),
-                value: Some("Anna".to_string()),
                 ..Default::default()
             }),
             ..Default::default()
         }),
     )?;
-    let relations = friendly_parse(&result);
-    assert_eq!(relations.len(), 4);
-    assert!(relations.contains(&("Anna", "FOLLOW", "Erin")));
-    assert!(relations.contains(&("Anna", "LIVE_IN", "New York")));
-    assert!(relations.contains(&("Anna", "LOVE", "Cat")));
-    assert!(relations.contains(&("Anna", "WORK_IN", "New York")));
+    assert_eq!(result.graph.len(), 12);
 
     // ()-[]->(:Anna)
     let result = search(
@@ -210,18 +206,136 @@ fn test_graph_node_query() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_graph_node_exact_matches() -> anyhow::Result<()> {
+    let reader = create_reader()?;
+
+    // Exact match (full)
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("Computer science".to_string()),
+                new_match_kind: Some(NewMatchKind::Exact(ExactMatch {
+                    kind: MatchLocation::Full.into(),
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    // Prefix
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("Computer sci".to_string()),
+                new_match_kind: Some(NewMatchKind::Exact(ExactMatch {
+                    kind: MatchLocation::Prefix.into(),
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("Compu".to_string()),
+                new_match_kind: Some(NewMatchKind::Exact(ExactMatch {
+                    kind: MatchLocation::Prefix.into(),
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    // Exact words
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("Computer".to_string()),
+                new_match_kind: Some(NewMatchKind::Exact(ExactMatch {
+                    kind: MatchLocation::Words.into(),
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("science".to_string()),
+                new_match_kind: Some(NewMatchKind::Exact(ExactMatch {
+                    kind: MatchLocation::Words.into(),
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    // Prefix words
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("sci".to_string()),
+                new_match_kind: Some(NewMatchKind::Exact(ExactMatch {
+                    kind: MatchLocation::PrefixWords.into(),
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    Ok(())
+}
+
 #[test]
 fn test_graph_fuzzy_node_query() -> anyhow::Result<()> {
     let reader = create_reader()?;
 
     // (:~Anastas)
+    #[allow(deprecated)]
     let result = search(
         &reader,
         Query::Path(Path {
             source: Some(Node {
                 node_subtype: Some("PERSON".to_string()),
                 value: Some("Anastas".to_string()),
-                match_kind: MatchKind::Fuzzy.into(),
+                match_kind: MatchKind::DeprecatedFuzzy.into(),
                 ..Default::default()
             }),
             ..Default::default()
@@ -232,13 +346,14 @@ fn test_graph_fuzzy_node_query() -> anyhow::Result<()> {
     assert!(relations.contains(&("Anastasia", "IS_FRIEND", "Anna")));
 
     // (:~AnXstXsia) with fuzzy=1
+    #[allow(deprecated)]
     let result = search(
         &reader,
         Query::Path(Path {
             source: Some(Node {
                 node_subtype: Some("PERSON".to_string()),
                 value: Some("AnXstXsia".to_string()),
-                match_kind: MatchKind::Fuzzy.into(),
+                match_kind: MatchKind::DeprecatedFuzzy.into(),
                 ..Default::default()
             }),
             ..Default::default()
@@ -248,13 +363,14 @@ fn test_graph_fuzzy_node_query() -> anyhow::Result<()> {
     assert_eq!(relations.len(), 0);
 
     // (:~AnXstasia) with fuzzy=1
+    #[allow(deprecated)]
     let result = search(
         &reader,
         Query::Path(Path {
             source: Some(Node {
                 node_subtype: Some("PERSON".to_string()),
                 value: Some("AnXstasia".to_string()),
-                match_kind: MatchKind::Fuzzy.into(),
+                match_kind: MatchKind::DeprecatedFuzzy.into(),
                 ..Default::default()
             }),
             ..Default::default()
@@ -265,13 +381,14 @@ fn test_graph_fuzzy_node_query() -> anyhow::Result<()> {
     assert!(relations.contains(&("Anastasia", "IS_FRIEND", "Anna")));
 
     // (:^~Ana) matches Anna & Anastasia
+    #[allow(deprecated)]
     let result = search(
         &reader,
         Query::Path(Path {
             source: Some(Node {
                 node_subtype: Some("PERSON".to_string()),
                 value: Some("Ana".to_string()),
-                match_kind: MatchKind::Fuzzy.into(),
+                match_kind: MatchKind::DeprecatedFuzzy.into(),
                 ..Default::default()
             }),
             ..Default::default()
@@ -288,6 +405,129 @@ fn test_graph_fuzzy_node_query() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_graph_node_fuzzy_matches() -> anyhow::Result<()> {
+    let reader = create_reader()?;
+
+    // Fuzzy (full)
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("Computer scXence".to_string()),
+                new_match_kind: Some(NewMatchKind::Fuzzy(FuzzyMatch {
+                    kind: MatchLocation::Full.into(),
+                    distance: 1,
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    // Fuzzy prefix
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("CompuXer sci".to_string()),
+                new_match_kind: Some(NewMatchKind::Fuzzy(FuzzyMatch {
+                    kind: MatchLocation::Prefix.into(),
+                    distance: 1,
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("CoXpu".to_string()),
+                new_match_kind: Some(NewMatchKind::Fuzzy(FuzzyMatch {
+                    kind: MatchLocation::Prefix.into(),
+                    distance: 1,
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    // Fuzzy words
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("ComXuter".to_string()),
+                new_match_kind: Some(NewMatchKind::Fuzzy(FuzzyMatch {
+                    kind: MatchLocation::Words.into(),
+                    distance: 1,
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("sciXnce".to_string()),
+                new_match_kind: Some(NewMatchKind::Fuzzy(FuzzyMatch {
+                    kind: MatchLocation::Words.into(),
+                    distance: 1,
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    // Fuzzy prefix words
+
+    let result = search(
+        &reader,
+        Query::Path(Path {
+            destination: Some(Node {
+                value: Some("scXen".to_string()),
+                new_match_kind: Some(NewMatchKind::Fuzzy(FuzzyMatch {
+                    kind: MatchLocation::PrefixWords.into(),
+                    distance: 1,
+                })),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }),
+    )?;
+    let relations = friendly_parse(&result);
+    assert_eq!(relations.len(), 1);
+    assert!(relations.contains(&("Margaret", "WORK_IN", "Computer science")));
+
+    Ok(())
+}
+
 #[test]
 fn test_graph_relation_query() -> anyhow::Result<()> {
     let reader = create_reader()?;
@@ -392,6 +632,10 @@ fn test_graph_relation_query() -> anyhow::Result<()> {
 fn test_graph_directed_path_query() -> anyhow::Result<()> {
     let reader = create_reader()?;
 
+    // ()-[]->()
+    let result = search(&reader, Query::Path(Path::default()))?;
+    assert_eq!(result.graph.len(), 17);
+
     // (:Erin)-[]->(:UK)
     let result = search(
         &reader,

{nidx_binding-6.3.4.post161 → nidx_binding-6.3.4.post167}/pyproject.toml

@@ -13,7 +13,7 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
-version = "6.3.4.post161"
+version = "6.3.4.post167"
 
 [project.urls]
 Homepage = "https://nuclia.com"

{nidx_binding-6.3.4.post161 → nidx_binding-6.3.4.post167}/tests/test_search_relations.rs

@@ -663,6 +663,7 @@ async fn test_graph_search__fuzzy_node_query(pool: PgPool) -> anyhow::Result<()>
     let shard_id = setup_knowledge_graph(&mut fixture).await?;
 
     // (:~Anastas)
+    #[allow(deprecated)]
     let response = fixture
         .searcher_client
         .graph_search(GraphSearchRequest {
@@ -672,7 +673,7 @@ async fn test_graph_search__fuzzy_node_query(pool: PgPool) -> anyhow::Result<()>
                     query: Some(path_query::Query::Path(graph_query::Path {
                         source: Some(graph_query::Node {
                             value: Some("Anastas".to_string()),
-                            match_kind: MatchKind::Fuzzy.into(),
+                            match_kind: MatchKind::DeprecatedFuzzy.into(),
                             ..Default::default()
                         }),
                         ..Default::default()
@@ -689,6 +690,7 @@ async fn test_graph_search__fuzzy_node_query(pool: PgPool) -> anyhow::Result<()>
     assert!(relations.contains(&("Anastasia", "IS_FRIEND", "Anna")));
 
     // (:~AnXstXsiX)
+    #[allow(deprecated)]
     let response = fixture
         .searcher_client
         .graph_search(GraphSearchRequest {
@@ -698,7 +700,7 @@ async fn test_graph_search__fuzzy_node_query(pool: PgPool) -> anyhow::Result<()>
                     query: Some(path_query::Query::Path(graph_query::Path {
                         source: Some(graph_query::Node {
                             value: Some("AnXstXsiX".to_string()),
-                            match_kind: MatchKind::Fuzzy.into(),
+                            match_kind: MatchKind::DeprecatedFuzzy.into(),
                             ..Default::default()
                         }),
                         ..Default::default()
@@ -714,6 +716,7 @@ async fn test_graph_search__fuzzy_node_query(pool: PgPool) -> anyhow::Result<()>
     assert_eq!(relations.len(), 0);
 
     // (:~Ansatasia)
+    #[allow(deprecated)]
     let response = fixture
         .searcher_client
         .graph_search(GraphSearchRequest {
@@ -723,7 +726,7 @@ async fn test_graph_search__fuzzy_node_query(pool: PgPool) -> anyhow::Result<()>
                     query: Some(path_query::Query::Path(graph_query::Path {
                         source: Some(graph_query::Node {
                             value: Some("Ansatasia".to_string()),
-                            match_kind: MatchKind::Fuzzy.into(),
+                            match_kind: MatchKind::DeprecatedFuzzy.into(),
                             ..Default::default()
                         }),
                         ..Default::default()