feat: add overwriteAlias to backup restore

src/main/java/io/weaviate/client/v1/async/backup/api/BackupRestorer.java

@@ -40,6 +40,7 @@ public class BackupRestorer extends AsyncBaseClient<BackupRestoreResponse>
   private String[] excludeClassNames;
   private String backend;
   private String backupId;
+  private Boolean overwriteAlias;
   private BackupRestoreConfig config;
   private boolean waitForCompletion;
   private final Executor executor;
@@ -81,6 +82,11 @@ public BackupRestorer withWaitForCompletion(boolean waitForCompletion) {
     return this;
   }
 
+  public BackupRestorer withOverwriteAlias(boolean overwriteAlias) {
+    this.overwriteAlias = overwriteAlias;
+    return this;
+  }
+
   @Override
   public Future<Result<BackupRestoreResponse>> run(FutureCallback<Result<BackupRestoreResponse>> callback) {
     if (waitForCompletion) {
@@ -94,6 +100,7 @@ private Future<Result<BackupRestoreResponse>> restore(FutureCallback<Result<Back
         .config(BackupRestoreConfig.builder().build())
         .include(includeClassNames)
         .exclude(excludeClassNames)
+        .overwriteAlias(overwriteAlias)
         .config(config)
         .build();
     String path = String.format("/backups/%s/%s/restore", UrlEncoder.encodePathParam(backend),
@@ -236,6 +243,8 @@ private static class BackupRestore {
     String[] include;
     @SerializedName("exclude")
     String[] exclude;
+    @SerializedName("overwriteAlias")
+    Boolean overwriteAlias;
   }
 
   @Getter

src/main/java/io/weaviate/client/v1/backup/api/BackupRestorer.java

@@ -24,6 +24,7 @@ public class BackupRestorer extends BaseClient<BackupRestoreResponse> implements
   private String[] excludeClassNames;
   private String backend;
   private String backupId;
+  private Boolean overwriteAlias;
   private BackupRestoreConfig config;
   private boolean waitForCompletion;
 
@@ -47,6 +48,11 @@ public BackupRestorer withBackend(String backend) {
     return this;
   }
 
+  public BackupRestorer withOverwriteAlias(Boolean overwriteAlias) {
+    this.overwriteAlias = overwriteAlias;
+    return this;
+  }
+
   public BackupRestorer withConfig(BackupRestoreConfig config) {
     this.config = config;
     return this;
@@ -72,6 +78,7 @@ public Result<BackupRestoreResponse> run() {
     BackupRestore payload = BackupRestore.builder()
         .include(includeClassNames)
         .exclude(excludeClassNames)
+        .overwriteAlias(overwriteAlias)
         .config(config)
         .build();
 
@@ -146,6 +153,8 @@ private static class BackupRestore {
     String[] include;
     @SerializedName("exclude")
     String[] exclude;
+    @SerializedName("overwriteAlias")
+    Boolean overwriteAlias;
   }
 
   @Getter

src/test/java/io/weaviate/integration/client/WeaviateVersion.java

@@ -3,7 +3,7 @@
 public class WeaviateVersion {
 
   // docker image version
-  public static final String WEAVIATE_IMAGE = "1.32.0";
+  public static final String WEAVIATE_IMAGE = "1.33.0-rc.0";
 
   // to be set according to weaviate docker image
   public static final String EXPECTED_WEAVIATE_VERSION = "1.32.0";

src/test/java/io/weaviate/integration/client/async/backup/ClientBackupTest.java

@@ -22,6 +22,7 @@
 import io.weaviate.client.WeaviateAuthClient;
 import io.weaviate.client.WeaviateClient;
 import io.weaviate.client.base.Result;
+import io.weaviate.client.v1.aliases.model.Alias;
 import io.weaviate.client.v1.async.WeaviateAsyncClient;
 import io.weaviate.client.v1.async.backup.api.BackupCanceler;
 import io.weaviate.client.v1.async.backup.api.BackupCreateStatusGetter;
@@ -549,6 +550,57 @@ public void shouldRestoreWithRbacOptions() {
     }
   }
 
+  @Test
+  public void testOverwriteAlias_true() throws InterruptedException, ExecutionException, Exception {
+    String originalClass = "CollectionOverwriteAlias";
+    String alias = originalClass + "Alias";
+    String differentClass = "Different" + originalClass;
+
+    try (final WeaviateAsyncClient async = client.async()) {
+      Runnable arrange = runnable(() -> {
+        Result<?> res;
+
+        res = async.schema().classCreator()
+            .withClass(WeaviateClass.builder().className(originalClass).build())
+            .run().get();
+        Assertions.assertThat(res.getError()).isNull();
+        res = async.alias().creator().withClassName(originalClass).withAlias(alias).run().get();
+        Assertions.assertThat(res.getError()).isNull();
+
+        res = async.backup().creator()
+            .withBackupId(backupId)
+            .withBackend(BackupTestSuite.BACKEND)
+            .withIncludeClassNames(originalClass)
+            .withWaitForCompletion(true)
+            .run().get();
+        Assertions.assertThat(res.getError()).isNull();
+
+        res = async.schema().classDeleter().withClassName(originalClass).run().get();
+        Assertions.assertThat(res.getError()).isNull();
+        res = async.schema().classCreator()
+            .withClass(WeaviateClass.builder().className(differentClass).build())
+            .run().get();
+        Assertions.assertThat(res.getError()).isNull();
+        res = async.alias().updater().withAlias(alias).withNewClassName(differentClass).run().get();
+        Assertions.assertThat(res.getError()).isNull();
+
+        return null; // satisfy Callable
+      });
+
+      Callable<Result<?>> act = () -> async.backup().restorer()
+          .withBackupId(backupId)
+          .withBackend(BackupTestSuite.BACKEND)
+          .withIncludeClassNames(originalClass)
+          .withWaitForCompletion(true)
+          .withOverwriteAlias(true)
+          .run().get();
+
+      Supplier<Alias> getAlias = supplier(() -> async.alias().getter().withAlias(alias).run().get().getResult());
+
+      BackupTestSuite.testOverwriteAlias_true(arrange, act, getAlias, originalClass);
+    }
+  }
+
   @FunctionalInterface
   interface ThrowingSupplier<T> {
     T get() throws Exception;

src/test/java/io/weaviate/integration/client/backup/ClientBackupTest.java

@@ -3,6 +3,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
+import java.util.concurrent.Callable;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
@@ -19,6 +20,7 @@
 import io.weaviate.client.WeaviateAuthClient;
 import io.weaviate.client.WeaviateClient;
 import io.weaviate.client.base.Result;
+import io.weaviate.client.v1.aliases.model.Alias;
 import io.weaviate.client.v1.auth.exception.AuthException;
 import io.weaviate.client.v1.backup.api.BackupCreator;
 import io.weaviate.client.v1.backup.api.BackupRestorer;
@@ -514,6 +516,53 @@ public void shouldRestoreWithRbacOptions() {
         () -> client.roles().getter().withName(roleName).run());
   }
 
+  @Test
+  public void testOverwriteAlias_true() throws Exception {
+    String originalClass = "CollectionOverwriteAlias";
+    String alias = originalClass + "Alias";
+    String differentClass = "Different" + originalClass;
+
+    Runnable arrange = () -> {
+      Result<?> res;
+
+      res = client.schema().classCreator()
+          .withClass(WeaviateClass.builder().className(originalClass).build())
+          .run();
+      Assertions.assertThat(res.getError()).isNull();
+      res = client.alias().creator().withClassName(originalClass).withAlias(alias).run();
+      Assertions.assertThat(res.getError()).isNull();
+
+      res = client.backup().creator()
+          .withBackupId(backupId)
+          .withBackend(BackupTestSuite.BACKEND)
+          .withIncludeClassNames(originalClass)
+          .withWaitForCompletion(true)
+          .run();
+      Assertions.assertThat(res.getError()).isNull();
+
+      res = client.schema().classDeleter().withClassName(originalClass).run();
+      Assertions.assertThat(res.getError()).isNull();
+      res = client.schema().classCreator()
+          .withClass(WeaviateClass.builder().className(differentClass).build())
+          .run();
+      Assertions.assertThat(res.getError()).isNull();
+      res = client.alias().updater().withAlias(alias).withNewClassName(differentClass).run();
+      Assertions.assertThat(res.getError()).isNull();
+    };
+
+    Callable<Result<?>> act = () -> client.backup().restorer()
+        .withBackupId(backupId)
+        .withBackend(BackupTestSuite.BACKEND)
+        .withIncludeClassNames(originalClass)
+        .withWaitForCompletion(true)
+        .withOverwriteAlias(true)
+        .run();
+
+    Supplier<Alias> getAlias = () -> client.alias().getter().withAlias(alias).run().getResult();
+
+    BackupTestSuite.testOverwriteAlias_true(arrange, act, getAlias, originalClass);
+  }
+
   @NotNull
   private Function<String, Result<GraphQLResponse>> createSupplierGQLOfClass() {
     return (String className) -> client.graphQL().get()

src/test/java/io/weaviate/integration/tests/backup/BackupTestSuite.java

@@ -19,6 +19,7 @@
 import io.weaviate.client.base.Result;
 import io.weaviate.client.base.WeaviateError;
 import io.weaviate.client.base.WeaviateErrorMessage;
+import io.weaviate.client.v1.aliases.model.Alias;
 import io.weaviate.client.v1.backup.model.Backend;
 import io.weaviate.client.v1.backup.model.BackupCreateResponse;
 import io.weaviate.client.v1.backup.model.BackupCreateStatusResponse;
@@ -639,6 +640,16 @@ public static void testBackupRestoreWithRbacOptions(String backupId,
 
   }
 
+  public static void testOverwriteAlias_true(
+      Runnable arrange,
+      Callable<Result<?>> act,
+      Supplier<Alias> supplierAlias, String wantClassName) throws Exception {
+    arrange.run();
+    Result<?> result = act.call();
+    assertThat(result.getError()).isNull();
+    assertThat(supplierAlias.get().getClassName()).isEqualTo(wantClassName);
+  }
+
   private static void assertThatAllPizzasExist(Function<String, Result<GraphQLResponse>> supplierGQLOfClass) {
     assertThatAllFoodObjectsExist(supplierGQLOfClass, "Pizza", "Quattro Formaggi", "Frutti di Mare", "Hawaii",
         "Doener");