For engagements name filter, search each word individually

Since the search phrase could be represented over multiple nodes,
instead of each node containing the whole phase.

This would apply to user's name filter as well

Author: CarsonF

src/components/engagement/engagement.repository.ts

@@ -546,6 +546,11 @@ export const engagementFilters = filter.define(() => EngagementFilters, {
     // UI joins project & language/intern names with dash
     // Remove it from search if users type it
     normalizeInput: (v) => v.replaceAll(/ -/g, ''),
+    // Treat each word as a separate search term
+    // Each word could point to a different node
+    // i.e. "project - language"
+    separateQueryForEachWord: true,
+    minScore: 0.9,
   }),
   projectId: filter.pathExists((id) => [
     node('node'),

src/core/database/query/filters.ts

@@ -15,6 +15,7 @@ import { Comparator } from 'cypher-query-builder/dist/typings/clauses/where-comp
 import { identity, isFunction } from 'lodash';
 import { AbstractClass, ConditionalKeys } from 'type-fest';
 import { DateTimeFilter } from '~/common';
+import { variable } from '../query-augmentation/condition-variables';
 import { collect } from './cypher-functions';
 import { escapeLuceneSyntax, FullTextIndex } from './full-text';
 import { ACTIVE } from './matching';
@@ -240,13 +241,15 @@ export const fullText =
   ({
     index,
     normalizeInput,
+    separateQueryForEachWord,
     escapeLucene = true,
     toLucene,
     minScore = 0,
     matchToNode,
   }: {
     index: () => FullTextIndex;
     normalizeInput?: (input: string) => string;
+    separateQueryForEachWord?: boolean;
     escapeLucene?: boolean;
     toLucene?: (input: string) => string;
     minScore?: number;
@@ -261,16 +264,20 @@ export const fullText =
       return null;
     }
 
-    let input: string = value;
+    const normalized = normalizeInput
+      ? normalizeInput(value as string)
+      : (value as string);
 
-    input = normalizeInput ? normalizeInput(input) : input;
-    input = escapeLucene ? escapeLuceneSyntax(input) : input;
+    let input = separateQueryForEachWord
+      ? cleanSplit(normalized, ' ')
+      : [normalized];
 
-    const lucene =
-      toLucene?.(input) ??
+    input = escapeLucene ? input.map(escapeLuceneSyntax) : input;
+
+    toLucene ??= (query) =>
       // Default to each word being matched.
       // And for each word...
-      cleanSplit(input, ' ')
+      cleanSplit(query, ' ')
         .map((term) => {
           const adjusted = [
             // fuzzy (distance) search with boosted priority
@@ -285,16 +292,24 @@ export const fullText =
     query
       .subQuery((q) =>
         q
-          .call(
-            index()
-              .search(lucene, { limit: 100 })
-              .yield({ node: 'match', score: true }),
+          .unwind(input.map(toLucene!), 'query')
+          .subQuery('query', (qq) =>
+            qq
+              .call(
+                index()
+                  .search(variable('query'), { limit: 100 })
+                  .yield({ node: 'match', score: true }),
+              )
+              .where({ score: greaterThan(minScore) })
+              .apply(matchToNode)
+              .return(collect('distinct node').as(`${field}Matches`)),
           )
-          .where({ score: greaterThan(minScore) })
-          .apply(matchToNode)
-          .return(collect('distinct node').as(`${field}Matches`)),
+          .return(collect(`${field}Matches`).as(`${field}MatchSets`)),
       )
       .with('*');
 
-    return { node: inArray(`${field}Matches`, true) };
+    return {
+      node: () =>
+        `all(${`${field}Matches`} in ${`${field}MatchSets`} where node in ${`${field}Matches`})`,
+    };
   };

src/core/database/query/full-text.ts

@@ -3,6 +3,7 @@ import { Query } from 'cypher-query-builder';
 import { pickBy } from 'lodash';
 import { LiteralUnion } from 'type-fest';
 import { procedure } from '../query-augmentation/call';
+import { Variable } from '../query-augmentation/condition-variables';
 import { CypherExpression, exp, isExp } from './cypher-expression';
 import { db } from './cypher-functions';
 
@@ -63,7 +64,7 @@ export const FullTextIndex = (config: {
      * @see https://lucene.apache.org/core/2_9_4/queryparsersyntax.html
      */
     search: (
-      query: string,
+      query: string | Variable,
       options: {
         skip?: number;
         limit?: number;
@@ -72,7 +73,7 @@ export const FullTextIndex = (config: {
     ) => {
       // fallback to "" when no query is given, so that no results are
       // returned instead of the procedure failing
-      query = query.trim() || '""';
+      query = typeof query === 'string' ? query.trim() || '""' : query;
 
       return db.index.fulltext.queryNodes(indexName, query, options);
     },
@@ -85,8 +86,8 @@ export const escapeLuceneSyntax = (query: string) =>
     .replace(/\b(OR|AND|NOT)\b/g, (char) => `"${char}"`);
 
 export const IndexFullTextQueryNodes = (
-  indexName: string,
-  query: string,
+  indexName: string | Variable,
+  query: string | Variable,
   options?:
     | {
         skip?: number;