feat: add helper factory for building and/or operator expressions

Author: bevzzz

src/collections/query/integration.test.ts

@@ -1,10 +1,12 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-non-null-asserted-optional-chain */
+import { requireAtLeast } from '../../../test/version.js';
 import { WeaviateUnsupportedFeatureError } from '../../errors.js';
 import weaviate, { WeaviateClient } from '../../index.js';
 import { Collection } from '../collection/index.js';
 import { CrossReference, Reference } from '../references/index.js';
 import { GroupByOptions } from '../types/index.js';
+import { Bm25Operator } from './utils.js';
 
 describe('Testing of the collection.query methods with a simple collection', () => {
   let client: WeaviateClient;
@@ -132,6 +134,28 @@ describe('Testing of the collection.query methods with a simple collection', ()
     expect(ret.objects[0].uuid).toEqual(id);
   });
 
+  requireAtLeast(1, 31, 0)('bm25 search operator (minimum_should_match)', () => {
+    it('should query with bm25 + operator', async () => {
+      const ret = await collection.query.bm25('carrot', {
+        limit: 1,
+        operator: Bm25Operator.or({ minimumMatch: 1 }),
+      });
+      expect(ret.objects.length).toEqual(1);
+      expect(ret.objects[0].properties.testProp).toEqual('carrot');
+      expect(ret.objects[0].uuid).toEqual(id);
+    });
+
+    it('should query with hybrid + bm25Operator', async () => {
+      const ret = await collection.query.hybrid('carrot', {
+        limit: 1,
+        bm25Operator: Bm25Operator.and({ minimumMatch: 1 }),
+      });
+      expect(ret.objects.length).toEqual(1);
+      expect(ret.objects[0].properties.testProp).toEqual('carrot');
+      expect(ret.objects[0].uuid).toEqual(id);
+    });
+  });
+
   it('should query with hybrid and vector', async () => {
     const ret = await collection.query.hybrid('carrot', {
       limit: 1,

src/collections/query/types.ts

@@ -85,7 +85,7 @@ export type Bm25QueryProperty<T> = {
 };
 
 export type Bm25OperatorOptions = {
-  operator: 'and' | 'or';
+  operator: 'And' | 'Or';
   minimumMatch: number;
 }
 

src/collections/query/utils.ts

@@ -1,5 +1,5 @@
 import { MultiTargetVectorJoin } from '../index.js';
-import { NearVectorInputType, TargetVectorInputType } from './types.js';
+import { Bm25OperatorOptions, NearVectorInputType, TargetVectorInputType } from './types.js';
 
 export class NearVectorInputGuards {
   public static is1DArray(input: NearVectorInputType): input is number[] {
@@ -34,3 +34,14 @@ export class TargetVectorInputGuards {
     return i.combination !== undefined && i.targetVectors !== undefined;
   }
 }
+
+export class Bm25Operator {
+  static and(opts: Omit<Bm25OperatorOptions, 'operator'>): Bm25OperatorOptions {
+    return { ...opts, operator: 'And' };
+  }
+
+  static or(opts: Omit<Bm25OperatorOptions, 'operator'>): Bm25OperatorOptions {
+    return { ...opts, operator: 'Or' };
+  }
+
+}

src/collections/serialize/index.ts

@@ -967,7 +967,7 @@ export class Serialize {
     if (searchOperator) {
       return SearchOperatorOptions.fromPartial({
         minimumOrTokensMatch: searchOperator.minimumMatch,
-        operator: searchOperator.operator === 'and' as const ? SearchOperatorOptions_Operator.OPERATOR_AND : SearchOperatorOptions_Operator.OPERATOR_OR,
+        operator: searchOperator.operator === 'And' as const ? SearchOperatorOptions_Operator.OPERATOR_AND : SearchOperatorOptions_Operator.OPERATOR_OR,
       });
     }
   }
@@ -1080,6 +1080,8 @@ export class Serialize {
       }
     };
     const { targets, targetVectors, vectorBytes, nearText, nearVector } = Serialize.hybridVector(args);
+
+    console.info(`search operator: ${JSON.stringify(SearchOperatorOptions.toJSON(this.bm25SearchOperator(args.bm25Operator)!))}`);
     return Hybrid.fromPartial({
       query: args.query,
       alpha: args.alpha ? args.alpha : 0.5,