fix: pass new defaults to aggregate client

Author: bevzzz

src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandle.java

@@ -40,13 +40,13 @@ public CollectionHandle(
 
   /** Copy constructor that sets new defaults. */
   private CollectionHandle(CollectionHandle<PropertiesT> c, CollectionHandleDefaults defaults) {
-    this.aggregate = c.aggregate;
-    this.tenants = c.tenants;
-
     this.config = new WeaviateConfigClient(c.config, defaults);
+    this.aggregate = new WeaviateAggregateClient(c.aggregate, defaults);
     this.query = new WeaviateQueryClient<>(c.query, defaults);
     this.data = new WeaviateDataClient<>(c.data, defaults);
     this.defaults = defaults;
+
+    this.tenants = c.tenants;
   }
 
   public Paginator<PropertiesT> paginate() {

src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleAsync.java

@@ -43,13 +43,13 @@ public CollectionHandleAsync(
 
   /** Copy constructor that sets new defaults. */
   private CollectionHandleAsync(CollectionHandleAsync<PropertiesT> c, CollectionHandleDefaults defaults) {
-    this.aggregate = c.aggregate;
-    this.tenants = c.tenants;
-
     this.config = new WeaviateConfigClientAsync(c.config, defaults);
+    this.aggregate = new WeaviateAggregateClientAsync(c.aggregate, defaults);
     this.query = new WeaviateQueryClientAsync<>(c.query, defaults);
     this.data = new WeaviateDataClientAsync<>(c.data, defaults);
     this.defaults = defaults;
+
+    this.tenants = c.tenants;
   }
 
   public AsyncPaginator<PropertiesT> paginate() {

src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractAggregateClient.java

@@ -32,6 +32,12 @@ abstract class AbstractAggregateClient<ResponseT, GroupedResponseT> {
     this.defaults = defaults;
   }
 
+  AbstractAggregateClient(
+      AbstractAggregateClient<ResponseT, GroupedResponseT> c,
+      CollectionHandleDefaults defaults) {
+    this(c.collection, c.transport, defaults);
+  }
+
   protected abstract ResponseT performRequest(Aggregation aggregation);
 
   protected abstract GroupedResponseT performRequest(Aggregation aggregation, GroupBy groupBy);

src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClient.java

@@ -13,6 +13,11 @@ public WeaviateAggregateClient(
     super(collection, transport, defaults);
   }
 
+  /** Copy constructor that sets new defaults. */
+  public WeaviateAggregateClient(WeaviateAggregateClient c, CollectionHandleDefaults defaults) {
+    super(c, defaults);
+  }
+
   protected final AggregateResponse performRequest(Aggregation aggregation) {
     var request = new AggregateRequest(aggregation, null);
     return this.transport.performRequest(request, AggregateRequest.rpc(collection, defaults));

src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClientAsync.java

@@ -16,6 +16,11 @@ public WeaviateAggregateClientAsync(
     super(collection, transport, defaults);
   }
 
+  /** Copy constructor that sets new defaults. */
+  public WeaviateAggregateClientAsync(WeaviateAggregateClientAsync c, CollectionHandleDefaults defaults) {
+    super(c, defaults);
+  }
+
   protected final CompletableFuture<AggregateResponse> performRequest(Aggregation aggregation) {
     var request = new AggregateRequest(aggregation, null);
     return this.transport.performRequestAsync(request, AggregateRequest.rpc(collection, defaults));

src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java

@@ -23,9 +23,10 @@ abstract class AbstractQueryClient<PropertiesT, SingleT, ResponseT, GroupedRespo
   }
 
   /** Copy constructor that sets new defaults. */
-  AbstractQueryClient(AbstractQueryClient<PropertiesT, SingleT, ResponseT, GroupedResponseT> qc,
+  AbstractQueryClient(
+      AbstractQueryClient<PropertiesT, SingleT, ResponseT, GroupedResponseT> c,
       CollectionHandleDefaults defaults) {
-    this(qc.collection, qc.grpcTransport, defaults);
+    this(c.collection, c.grpcTransport, defaults);
   }
 
   protected abstract SingleT byId(ById byId);

src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClient.java

@@ -19,8 +19,8 @@ public WeaviateQueryClient(
   }
 
   /** Copy constructor that sets new defaults. */
-  public WeaviateQueryClient(WeaviateQueryClient<T> qc, CollectionHandleDefaults defaults) {
-    super(qc, defaults);
+  public WeaviateQueryClient(WeaviateQueryClient<T> c, CollectionHandleDefaults defaults) {
+    super(c, defaults);
   }
 
   @Override

src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClientAsync.java

@@ -0,0 +1,99 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+import io.weaviate.client6.v1.internal.rest.RestTransport;
+
+public class WeaviateTenantsClientAsync {
+  private final CollectionDescriptor<?> collection;
+  private final RestTransport restTransport;
+  private final GrpcTransport grpcTransport;
+
+  public WeaviateTenantsClientAsync(
+      CollectionDescriptor<?> collection,
+      RestTransport restTransport,
+      GrpcTransport grpcTransport) {
+    this.collection = collection;
+    this.restTransport = restTransport;
+    this.grpcTransport = grpcTransport;
+  }
+
+  public CompletableFuture<Void> create(Tenant... tenants) throws IOException {
+    return create(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> create(List<Tenant> tenants) throws IOException {
+    return this.restTransport.performRequestAsync(new CreateTenantsRequest(tenants),
+        CreateTenantsRequest.endpoint(collection));
+  }
+
+  public CompletableFuture<Optional<Tenant>> get(String tenant) {
+    var tenants = get(List.of(tenant));
+    return tenants.thenApply(result -> result.isEmpty() ? Optional.empty() : Optional.ofNullable(result.get(0)));
+  }
+
+  public CompletableFuture<List<Tenant>> list() {
+    return get();
+  }
+
+  public CompletableFuture<List<Tenant>> get(String... tenants) {
+    return get(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<List<Tenant>> get(List<String> tenants) {
+    return this.grpcTransport.performRequestAsync(new GetTenantsRequest(tenants), GetTenantsRequest.rpc(collection));
+  }
+
+  public CompletableFuture<Void> update(Tenant... tenants) throws IOException {
+    return update(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> update(List<Tenant> tenants) throws IOException {
+    return this.restTransport.performRequestAsync(new UpdateTenantsRequest(tenants),
+        UpdateTenantsRequest.endpoint(collection));
+  }
+
+  public CompletableFuture<Void> delete(String... tenants) throws IOException {
+    return delete(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> delete(List<String> tenants) throws IOException {
+    return this.restTransport.performRequestAsync(new DeleteTenantsRequest(tenants),
+        DeleteTenantsRequest.endpoint(collection));
+  }
+
+  public CompletableFuture<Boolean> exists(String tenant) throws IOException {
+    return this.restTransport.performRequestAsync(new TenantExistsRequest(tenant),
+        TenantExistsRequest.endpoint(collection));
+  }
+
+  public CompletableFuture<Void> activate(String... tenants) throws IOException {
+    return activate(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> activate(List<String> tenants) throws IOException {
+    return update(tenants.stream().map(Tenant::active).toList());
+  }
+
+  public CompletableFuture<Void> deactivate(String... tenants) throws IOException {
+    return deactivate(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> deactivate(List<String> tenants) throws IOException {
+    return update(tenants.stream().map(Tenant::inactive).toList());
+  }
+
+  public CompletableFuture<Void> offload(String... tenants) throws IOException {
+    return offload(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> offload(List<String> tenants) throws IOException {
+    return update(tenants.stream().map(t -> new Tenant(t, TenantStatus.OFFLOADED)).toList());
+  }
+}