Merge pull request #3250 from SeedCompany/neo4j/full-text

Author: CarsonF

src/components/file/media/media.repository.ts

@@ -114,9 +114,10 @@ export class MediaRepository extends CommonRepository {
       // Update the labels if typename is given, and maybe changed.
       .apply((q) =>
         res
-          ? q.raw(
-              'CALL apoc.create.setLabels(node, $newLabels) yield node as labelsAdded',
-              { newLabels: res.dbLabels },
+          ? q.call(
+              apoc.create
+                .setLabels('node', res.dbLabels)
+                .yield({ node: 'labelsAdded' }),
             )
           : q,
       )

src/components/product/product.repository.ts

@@ -27,7 +27,7 @@ import {
   deactivateProperty,
   escapeLuceneSyntax,
   filter,
-  fullTextQuery,
+  FullTextIndex,
   matchProps,
   matchPropsAndProjectSensAndScopedRoles,
   merge,
@@ -552,7 +552,9 @@ export class ProductRepository extends CommonRepository {
       .query()
       .apply((q) =>
         query
-          ? q.apply(fullTextQuery('ProductCompletionDescription', query))
+          ? q.call(
+              ProductCompletionDescriptionIndex.search(query).yield('node'),
+            )
           : q.matchNode('node', 'ProductCompletionDescription'),
       )
       .apply((q) =>
@@ -569,18 +571,21 @@ export class ProductRepository extends CommonRepository {
 
   @OnIndex('schema')
   private async createCompletionDescriptionIndex() {
-    await this.db.createFullTextIndex(
-      'ProductCompletionDescription',
-      ['ProductCompletionDescription'],
-      ['value'],
-      {
-        analyzer: 'standard-folding',
-      },
-    );
+    await this.db
+      .query()
+      .apply(ProductCompletionDescriptionIndex.create())
+      .run();
   }
 
   @OnIndex()
   private createResourceIndexes() {
     return this.getConstraintsFor(Product);
   }
 }
+
+const ProductCompletionDescriptionIndex = FullTextIndex({
+  indexName: 'ProductCompletionDescription',
+  labels: 'ProductCompletionDescription',
+  properties: 'value',
+  analyzer: 'standard-folding',
+});

src/components/search/search.repository.ts

@@ -4,7 +4,7 @@ import { CommonRepository, OnIndex, OnIndexParams } from '~/core/database';
 import {
   ACTIVE,
   escapeLuceneSyntax,
-  fullTextQuery,
+  FullTextIndex,
 } from '~/core/database/query';
 import { BaseNode } from '~/core/database/results';
 import { SearchInput } from './dto';
@@ -13,9 +13,7 @@ import { SearchInput } from './dto';
 export class SearchRepository extends CommonRepository {
   @OnIndex('schema')
   protected async applyIndexes({ db }: OnIndexParams) {
-    await db.createFullTextIndex('propValue', ['Property'], ['value'], {
-      analyzer: 'standard-folding',
-    });
+    await db.query().apply(GlobalIndex.create()).run();
   }
 
   /**
@@ -36,8 +34,7 @@ export class SearchRepository extends CommonRepository {
 
           .union()
 
-          .raw('', { query: lucene })
-          .apply(fullTextQuery('propValue', '$query', ['node as property']))
+          .call(GlobalIndex.search(lucene).yield({ node: 'property' }))
           .match([node('node'), relation('out', 'r', ACTIVE), node('property')])
           .return(['node', 'collect(type(r)) as matchedProps'])
           // The input.count is going to be applied once the results are 'filtered'
@@ -62,3 +59,10 @@ export class SearchRepository extends CommonRepository {
     return await query.run();
   }
 }
+
+const GlobalIndex = FullTextIndex({
+  indexName: 'propValue',
+  labels: 'Property',
+  properties: 'value',
+  analyzer: 'standard-folding',
+});

src/core/database/query-augmentation/SubClauseCollection.ts

@@ -1,6 +1,23 @@
-import { ClauseCollection, Query } from 'cypher-query-builder';
+import { Clause, ClauseCollection, Query } from 'cypher-query-builder';
+import type { ParameterBag } from 'cypher-query-builder/dist/typings/parameter-bag';
 
 export class SubClauseCollection extends ClauseCollection {
+  useParameterBag(newBag: ParameterBag) {
+    super.useParameterBag(newBag);
+    this.assignBagRecursive(this, newBag);
+  }
+
+  private assignBagRecursive(clause: Clause, newBag: ParameterBag) {
+    // @ts-expect-error protected, but we want it to reference the outer one
+    // without having to import the parameters.
+    clause.parameterBag = newBag;
+    if (clause instanceof ClauseCollection) {
+      for (const sub of clause.getClauses()) {
+        this.assignBagRecursive(sub, newBag);
+      }
+    }
+  }
+
   build() {
     return this.clauses
       .flatMap((clause) => {

src/core/database/query-augmentation/call.ts

@@ -1,28 +1,77 @@
-import { Query } from 'cypher-query-builder';
+import { entries } from '@seedcompany/common';
+import { Clause, Query } from 'cypher-query-builder';
+import { Parameter } from 'cypher-query-builder/dist/typings/parameter-bag';
+import { isExp, variable } from '../query';
+import type { YieldTerms } from './yield';
 
 declare module 'cypher-query-builder/dist/typings/query' {
   interface Query {
     /**
-     * Apply custom query modifications while maintaining the fluent chain.
+     * Call a procedure.
      *
-     * @deprecated Use {@link apply}() instead.
-     *
-     * In the future this could be changed to utilize native neo4j call logic.
+     * Args can be an array of positional args, or an object of named args.
+     * Objects are still converted to positional args, so the order matters.
+     * Objects allow the query parameters to be named for better readability.
      */
-    call<A extends any[], R extends this | Query<any> | void>(
-      fn: (query: this, ...args: A) => R,
-      ...args: A
-    ): R extends void ? this : R;
+    call(procedure: ProcedureCall): this;
+    call(procedureName: string, args?: ProcedureArgs): this;
   }
 }
 
-Query.prototype.call = function call<
-  A extends any[],
-  R extends Query<any> | void,
->(
+Query.prototype.call = function call(
   this: Query,
-  fn: (q: Query, ...args: A) => R,
-  ...args: A
-): R extends void ? Query : R {
-  return (fn(this, ...args) || this) as Exclude<R, void>;
+  procedure: ProcedureCall | string,
+  args?: ProcedureArgs,
+) {
+  const call =
+    typeof procedure === 'string'
+      ? { procedureName: procedure, args: args ?? [] }
+      : procedure;
+  const clause = new Procedure(call.procedureName, call.args);
+  const next = this.continueChainClause(clause);
+  return call.yieldTerms ? next.yield(call.yieldTerms) : next;
 };
+
+interface ProcedureCall<Y extends string = string> {
+  procedureName: string;
+  args: ProcedureArgs;
+  yieldTerms?: YieldTerms<Y>;
+}
+type ProcedureArgs = Record<string, any> | any[];
+
+class Procedure extends Clause {
+  private readonly params: Parameter[];
+  constructor(public name: string, public args: Record<string, any> | any[]) {
+    super();
+    this.params = (
+      Array.isArray(args)
+        ? args.map((value) => [undefined, value] as const)
+        : entries(this.args as Record<string, any>)
+    ).map(([key, value]) =>
+      isExp(value) ? variable(value) : this.addParam(value, key),
+    );
+  }
+  build() {
+    return `CALL ${this.name}(${this.params.join(', ')})`;
+  }
+}
+
+export const procedure =
+  <const Y extends string>(
+    procedureName: string,
+    // eslint-disable-next-line @seedcompany/no-unused-vars
+    yieldDefs: readonly Y[],
+  ) =>
+  (args: ProcedureArgs) => ({
+    procedureName,
+    args,
+    yield: (yieldTerms: YieldTerms<Y>) =>
+      Object.assign(
+        (query: Query) => query.call(procedureName, args).yield(yieldTerms),
+        {
+          procedureName,
+          args,
+          yieldTerms,
+        },
+      ),
+  });

src/core/database/query-augmentation/condition-variables.ts

@@ -2,7 +2,6 @@
  * This file patches pattern conditions to support referencing existing variables.
  * This is achieved by wrapping the variable name in a `variable()` call.
  */
-import { mapValues } from '@seedcompany/common';
 import { Clause, NodePattern } from 'cypher-query-builder';
 import type { Pattern as TSPattern } from 'cypher-query-builder/dist/typings/clauses/pattern';
 import type {
@@ -37,24 +36,15 @@ export class Variable extends Parameter {
  */
 export const variable = (expression: string) => new Variable(expression);
 
+const origAddParam = ParameterBag.prototype.addParam;
 ParameterBag.prototype.addParam = function addParam(
   this: TSParameterBag,
   value: any | Variable,
   name?: string,
 ) {
-  const actualName = this.getName(name);
-  const param =
-    value instanceof Variable
-      ? new Variable(value.value, actualName)
-      : new Parameter(actualName, value);
-  this.parameterMap[actualName] = param;
-  return param;
-};
-
-ParameterBag.prototype.getParams = function getParams(this: TSParameterBag) {
-  return mapValues(this.parameterMap, (_, param, { SKIP }) =>
-    param instanceof Variable ? SKIP : param.value,
-  ).asRecord;
+  return value instanceof Variable
+    ? value
+    : origAddParam.call(this, value, name);
 };
 
 Pattern.prototype.setExpandedConditions = function (

src/core/database/query-augmentation/index.ts

@@ -11,3 +11,4 @@ import './map';
 import './pattern-formatting';
 import './subquery';
 import './summary';
+import './yield';

src/core/database/query-augmentation/yield.ts

@@ -0,0 +1,32 @@
+import { isPlainObject } from '@nestjs/common/utils/shared.utils.js';
+import { isNotFalsy, many, Many, Nil } from '@seedcompany/common';
+import { Clause, Query } from 'cypher-query-builder';
+
+declare module 'cypher-query-builder/dist/typings/query' {
+  interface Query {
+    yield(terms: YieldTerms): this;
+  }
+}
+
+export type YieldTerms<T extends string = string> =
+  | Many<T | Nil>
+  | Partial<Record<T, string | boolean | Nil>>;
+
+Query.prototype.yield = function (this: Query, terms: YieldTerms) {
+  const flattened = isPlainObject(terms)
+    ? Object.entries(terms).flatMap(([k, v]) =>
+        v === false || v == null ? [] : v === true ? k : `${k} as ${v}`,
+      )
+    : many(terms).filter(isNotFalsy);
+  if (flattened.length === 0) return this;
+  return this.continueChainClause(new Yield(flattened));
+};
+
+class Yield extends Clause {
+  constructor(public terms: readonly string[]) {
+    super();
+  }
+  build() {
+    return `YIELD ${this.terms.join(', ')}`;
+  }
+}

src/core/database/query/cypher-functions.ts

@@ -1,4 +1,6 @@
+import { procedure } from '../query-augmentation/call';
 import { exp, ExpressionInput } from './cypher-expression';
+import { IndexFullTextQueryNodes } from './full-text';
 
 /** Create a function with a name that takes a variable number of arguments */
 const fn =
@@ -75,6 +77,10 @@ export const apoc = {
     /** Converts Neo4j node to object/map of the node's properties */
     toMap: fn1('apoc.convert.toMap'),
   },
+  create: {
+    setLabels: (node: ExpressionInput, labels: readonly string[]) =>
+      procedure('apoc.create.setLabels', ['node'])({ node: exp(node), labels }),
+  },
 };
 
 /**
@@ -111,3 +117,11 @@ export const any = (
   list: ExpressionInput,
   predicate: ExpressionInput,
 ) => fn('any')(`${variable} IN ${exp(list)} WHERE ${exp(predicate)}`);
+
+export const db = {
+  index: {
+    fulltext: {
+      queryNodes: IndexFullTextQueryNodes,
+    },
+  },
+};