Fix bug when aggregating with multi-tenancy

Author: tsmith023

src/collections/aggregate/index.ts

@@ -5,6 +5,7 @@ import { DbVersionSupport } from '../../utils/dbVersion.js';
 
 import { FilterValue } from '../filters/index.js';
 
+import { WeaviateQueryError } from '../../errors.js';
 import { Aggregator } from '../../graphql/index.js';
 import { Serialize } from '../serialize/index.js';
 
@@ -444,6 +445,9 @@ class AggregateManager<T> implements Aggregate<T> {
     if (filters) {
       builder = builder.withWhere(Serialize.filtersREST(filters));
     }
+    if (this.tenant) {
+      builder = builder.withTenant(this.tenant);
+    }
     return builder;
   }
 
@@ -556,31 +560,41 @@ class AggregateManager<T> implements Aggregate<T> {
   do = <M extends PropertiesMetrics<T> | undefined = undefined>(
     query: Aggregator
   ): Promise<AggregateResult<T, M>> => {
-    return query.do().then(({ data }: any) => {
-      const { meta, ...rest } = data.Aggregate[this.name][0];
-      return {
-        properties: rest,
-        totalCount: meta?.count,
-      };
-    });
+    return query
+      .do()
+      .then(({ data }: any) => {
+        const { meta, ...rest } = data.Aggregate[this.name][0];
+        return {
+          properties: rest,
+          totalCount: meta?.count,
+        };
+      })
+      .catch((err: Error) => {
+        throw new WeaviateQueryError(err.message, 'GraphQL');
+      });
   };
 
   doGroupBy = <M extends PropertiesMetrics<T> | undefined = undefined>(
     query: Aggregator
   ): Promise<AggregateGroupByResult<T, M>[]> => {
-    return query.do().then(({ data }: any) =>
-      data.Aggregate[this.name].map((item: any) => {
-        const { groupedBy, meta, ...rest } = item;
-        return {
-          groupedBy: {
-            prop: groupedBy.path[0],
-            value: groupedBy.value,
-          },
-          properties: rest.length > 0 ? rest : undefined,
-          totalCount: meta?.count,
-        };
-      })
-    );
+    return query
+      .do()
+      .then(({ data }: any) =>
+        data.Aggregate[this.name].map((item: any) => {
+          const { groupedBy, meta, ...rest } = item;
+          return {
+            groupedBy: {
+              prop: groupedBy.path[0],
+              value: groupedBy.value,
+            },
+            properties: rest.length > 0 ? rest : undefined,
+            totalCount: meta?.count,
+          };
+        })
+      )
+      .catch((err: Error) => {
+        throw new WeaviateQueryError(err.message, 'GraphQL');
+      });
   };
 }
 

src/collections/aggregate/integration.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-non-null-asserted-optional-chain */
-import { WeaviateUnsupportedFeatureError } from '../../errors.js';
+import { WeaviateQueryError, WeaviateUnsupportedFeatureError } from '../../errors.js';
 import weaviate, { AggregateText, WeaviateClient } from '../../index.js';
 import { Collection } from '../collection/index.js';
 import { CrossReference } from '../references/index.js';
@@ -331,3 +331,52 @@ describe('Testing of the collection.aggregate methods with named vectors', () =>
     expect(result.totalCount).toEqual(0);
   });
 });
+
+describe('Testing of collection.aggregate.overAll with a multi-tenancy collection', () => {
+  let client: WeaviateClient;
+  let collection: Collection;
+  const collectionName = 'TestCollectionAggregate';
+
+  afterAll(async () => {
+    return (await client).collections.delete(collectionName).catch((err) => {
+      console.error(err);
+      throw err;
+    });
+  });
+
+  beforeAll(async () => {
+    client = await weaviate.connectToLocal();
+    return client.collections
+      .create({
+        name: collectionName,
+        properties: [
+          {
+            name: 'text',
+            dataType: 'text',
+          },
+        ],
+        multiTenancy: { enabled: true },
+      })
+      .then(async (created) => {
+        const tenants = await created.tenants.create({ name: 'test' });
+        collection = created.withTenant(tenants[0].name);
+        const data: Array<any> = [];
+        for (let i = 0; i < 100; i++) {
+          data.push({
+            properties: {
+              text: 'test',
+            },
+          });
+        }
+        await collection.data.insertMany(data);
+      });
+  });
+
+  it('should aggregate data without a search and no property metrics over the tenant', () =>
+    collection.aggregate.overAll().then((result) => expect(result.totalCount).toEqual(100)));
+
+  it('should throw an error for a non-existant tenant', () =>
+    expect(collection.withTenant('non-existing-tenant').aggregate.overAll()).rejects.toThrow(
+      WeaviateQueryError
+    ));
+});