Add Filters.not() and .containsNone() capabilities

Author: tsmith023

.github/workflows/main.yaml

@@ -12,7 +12,8 @@ env:
   WEAVIATE_129: 1.29.9
   WEAVIATE_130: 1.30.12
   WEAVIATE_131: 1.31.5
-  WEAVIATE_132: 1.32.4-cdf9a3b
+  WEAVIATE_132: 1.32.5
+  WEAVIATE_133: 1.33.0-rc.1
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
@@ -45,9 +46,10 @@ jobs:
           { node: "22.x", weaviate: $WEAVIATE_129},
           { node: "22.x", weaviate: $WEAVIATE_130},
           { node: "22.x", weaviate: $WEAVIATE_131},
-          { node: "18.x", weaviate: $WEAVIATE_132},
-          { node: "20.x", weaviate: $WEAVIATE_132},
-          { node: "22.x", weaviate: $WEAVIATE_132}
+          { node: "22.x", weaviate: $WEAVIATE_132},
+          { node: "18.x", weaviate: $WEAVIATE_133},
+          { node: "20.x", weaviate: $WEAVIATE_133},
+          { node: "22.x", weaviate: $WEAVIATE_133},
         ]
     steps:
     - uses: actions/checkout@v3

src/collections/filters/classes.ts

@@ -43,7 +43,7 @@ export class Filters {
   static and(...filters: FilterValue[]): FilterValue<null> {
     return {
       operator: 'And',
-      filters: filters,
+      filters,
       value: null,
     };
   }
@@ -55,7 +55,19 @@ export class Filters {
   static or(...filters: FilterValue[]): FilterValue<null> {
     return {
       operator: 'Or',
-      filters: filters,
+      filters,
+      value: null,
+    };
+  }
+  /**
+   * Negate a filter using the logical NOT operator.
+   *
+   * @param {FilterValue} filter The filter to negate.
+   */
+  static not(filter: FilterValue): FilterValue<null> {
+    return {
+      operator: 'Not',
+      filters: [filter],
       value: null,
     };
   }
@@ -140,6 +152,14 @@ export class FilterProperty<V> extends FilterBase implements FilterByProperty<V>
     };
   }
 
+  public containsNone<U extends ContainsValue<V>>(value: U[]): FilterValue<U[]> {
+    return {
+      operator: 'ContainsNone',
+      target: this.targetPath(),
+      value: value,
+    };
+  }
+
   public containsAll<U extends ContainsValue<V>>(value: U[]): FilterValue<U[]> {
     return {
       operator: 'ContainsAll',

src/collections/filters/integration.test.ts

@@ -1,5 +1,6 @@
 /* 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 weaviate, { WeaviateClient } from '../../index.js';
 import { Collection } from '../collection/index.js';
 import { CrossReference, Reference } from '../references/index.js';
@@ -120,6 +121,34 @@ describe('Testing of the filter class with a simple collection', () => {
     expect(obj.uuid).toEqual(ids[1]);
   });
 
+  it('should filter a fetch objects query with a contains-all filter', async () => {
+    const res = await collection.query.fetchObjects({
+      filters: collection.filter.byProperty('text').containsAll(['two']),
+    });
+    expect(res.objects.length).toEqual(1);
+    const obj = res.objects[0];
+    expect(obj.properties.text).toEqual('two');
+  });
+
+  it('should filter a fetch objects query with a contains-any filter', async () => {
+    const res = await collection.query.fetchObjects({
+      filters: collection.filter.byProperty('text').containsAny(['two', 'three']),
+    });
+    expect(res.objects.length).toEqual(2);
+    const texts = res.objects.map((o) => o.properties.text);
+    expect(texts).toContain('two');
+    expect(texts).toContain('three');
+  });
+
+  requireAtLeast(1, 33, 0).it('should filter a fetch objects query with a contains-none filter', async () => {
+    const res = await collection.query.fetchObjects({
+      filters: collection.filter.byProperty('text').containsNone(['one', 'three']),
+    });
+    expect(res.objects.length).toEqual(1);
+    const obj = res.objects[0];
+    expect(obj.properties.text).toEqual('two');
+  });
+
   it('should filter a fetch objects query with an AND filter', async () => {
     const res = await collection.query.fetchObjects({
       filters: Filters.and(
@@ -147,15 +176,16 @@ describe('Testing of the filter class with a simple collection', () => {
     // Return of fetch not necessarily in order due to filter
     expect(res.objects.map((o) => o.properties.text)).toContain('two');
     expect(res.objects.map((o) => o.properties.text)).toContain('three');
+  });
 
-    expect(res.objects.map((o) => o.properties.int)).toContain(2);
-    expect(res.objects.map((o) => o.properties.int)).toContain(3);
-
-    expect(res.objects.map((o) => o.properties.float)).toContain(2.2);
-    expect(res.objects.map((o) => o.properties.float)).toContain(3.3);
+  requireAtLeast(1, 33, 0).it('should filter a fetch objects query with a NOT filter', async () => {
+    const res = await collection.query.fetchObjects({
+      filters: Filters.not(collection.filter.byProperty('text').equal('one')),
+    });
+    expect(res.objects.length).toEqual(2);
 
-    expect(res.objects.map((o) => o.uuid)).toContain(ids[1]);
-    expect(res.objects.map((o) => o.uuid)).toContain(ids[2]);
+    expect(res.objects.map((o) => o.properties.text)).toContain('two');
+    expect(res.objects.map((o) => o.properties.text)).toContain('three');
   });
 
   it('should filter a fetch objects query with a reference filter', async () => {

src/collections/filters/types.ts

@@ -13,8 +13,10 @@ export type Operator =
   | 'WithinGeoRange'
   | 'ContainsAny'
   | 'ContainsAll'
+  | 'ContainsNone'
   | 'And'
-  | 'Or';
+  | 'Or'
+  | 'Not';
 
 export type FilterValue<V = any> = {
   filters?: FilterValue[];
@@ -133,6 +135,13 @@ export interface FilterByProperty<T> {
    * @returns {FilterValue<U[]>} The filter value.
    */
   containsAll: <U extends ContainsValue<T>>(value: U[]) => FilterValue<U[]>;
+  /**
+   * Filter on whether the property contains none of the given values.
+   *
+   * @param {U[]} value The values to filter on.
+   * @returns {FilterValue<U[]>} The filter value.
+   */
+  containsNone: <U extends ContainsValue<T>>(value: U[]) => FilterValue<U[]>;
   /**
    * Filter on whether the property is equal to the given value.
    *

src/collections/filters/unit.test.ts

@@ -25,7 +25,7 @@ describe('Unit testing of filters', () => {
       });
     });
 
-    it('should create a contains all filter with a primitive type', () => {
+    it('should create a contains all filter with an array type', () => {
       const f = filter.byProperty('name').containsAll(['John', 'Doe']);
       expect(f).toEqual<FilterValue<string[]>>({
         operator: 'ContainsAll',
@@ -47,7 +47,7 @@ describe('Unit testing of filters', () => {
       });
     });
 
-    it('should create a contains any filter with a primitive type', () => {
+    it('should create a contains any filter with an array type', () => {
       const f = filter.byProperty('name').containsAny(['John', 'Doe']);
       expect(f).toEqual<FilterValue<string[]>>({
         operator: 'ContainsAny',
@@ -69,6 +69,17 @@ describe('Unit testing of filters', () => {
       });
     });
 
+    it('should create a contains none filter with an array type', () => {
+      const f = filter.byProperty('friends').containsNone(['John', 'Doe']);
+      expect(f).toEqual<FilterValue<string[]>>({
+        operator: 'ContainsNone',
+        target: {
+          property: 'friends',
+        },
+        value: ['John', 'Doe'],
+      });
+    });
+
     it('should create an equal filter', () => {
       const f = filter.byProperty('name').equal('John');
       expect(f).toEqual<FilterValue<string>>({
@@ -893,5 +904,20 @@ describe('Unit testing of filters', () => {
         ],
       });
     });
+
+    it('should map a NOT filter', () => {
+      const f = Filters.not(filter.byProperty('name').equal('John'));
+      const s = Serialize.filtersREST(f);
+      expect(s).toEqual<WhereFilter>({
+        operator: 'Not',
+        operands: [
+          {
+            operator: 'Equal',
+            path: ['name'],
+            valueText: 'John',
+          },
+        ],
+      });
+    });
   });
 });

src/collections/serialize/index.ts

@@ -1504,6 +1504,11 @@ export class Serialize {
           operator: Filters_Operator.OPERATOR_OR,
           filters: resolveFilters(filters),
         });
+      case 'Not':
+        return FiltersGRPC.fromPartial({
+          operator: Filters_Operator.OPERATOR_NOT,
+          filters: resolveFilters(filters),
+        });
       default:
         return FiltersGRPC.fromPartial({
           operator: Serialize.operator(filters.operator),
@@ -1568,7 +1573,7 @@ export class Serialize {
 
   public static filtersREST = (filters: FilterValue): WhereFilter => {
     const { value } = filters;
-    if (filters.operator === 'And' || filters.operator === 'Or') {
+    if (filters.operator === 'And' || filters.operator === 'Or' || filters.operator === 'Not') {
       return {
         operator: filters.operator,
         operands: filters.filters?.map(Serialize.filtersREST),
@@ -1660,6 +1665,8 @@ export class Serialize {
         return Filters_Operator.OPERATOR_CONTAINS_ANY;
       case 'ContainsAll':
         return Filters_Operator.OPERATOR_CONTAINS_ALL;
+      case 'ContainsNone':
+        return Filters_Operator.OPERATOR_CONTAINS_NONE;
       case 'GreaterThan':
         return Filters_Operator.OPERATOR_GREATER_THAN;
       case 'GreaterThanEqual':