feat: overwriteAlias for backup restore

src/backup/backupRestorer.ts

@@ -26,6 +26,7 @@ export default class BackupRestorer extends CommandBase {
   private statusGetter: BackupRestoreStatusGetter;
   private waitForCompletion?: boolean;
   private config?: RestoreConfig;
+  private overwriteAlias?: boolean;
 
   constructor(client: Connection, statusGetter: BackupRestoreStatusGetter) {
     super(client);
@@ -65,6 +66,11 @@ export default class BackupRestorer extends CommandBase {
     return this;
   }
 
+  withOverwriteAlias(overwriteAlias: boolean) {
+    this.overwriteAlias = overwriteAlias;
+    return this;
+  }
+
   withConfig(cfg: RestoreConfig) {
     this.config = cfg;
     return this;
@@ -89,6 +95,7 @@ export default class BackupRestorer extends CommandBase {
       config: this.config,
       include: this.includeClassNames,
       exclude: this.excludeClassNames,
+      overwriteAlias: this.overwriteAlias,
     } as BackupRestoreRequest;
 
     if (this.waitForCompletion) {

src/collections/backup/client.ts

@@ -163,6 +163,9 @@
       if (args.excludeCollections) {
         builder = builder.withExcludeClassNames(...args.excludeCollections);
       }
+      if (args.config?.overwriteAlias) {
+        builder = builder.withOverwriteAlias(args.config?.overwriteAlias);
+      }
       if (args.config) {
         builder = builder.withConfig({
           CPUPercentage: args.config.cpuPercentage,
@@ -197,9 +200,9 @@
       }
       return status
         ? {
-            ...parseResponse(res),
-            ...status,
-          }
+          ...parseResponse(res),
+          ...status,
+        }
         : parseResponse(res);
     },
   };

src/collections/backup/collection.ts

@@ -1,6 +1,5 @@
 import { Backend } from '../../backup/index.js';
 import Connection from '../../connection/index.js';
-import { WeaviateInvalidInputError } from '../../errors.js';
 import { backup } from './client.js';
 import { BackupReturn, BackupStatusArgs, BackupStatusReturn } from './types.js';
 

src/collections/backup/integration.test.ts

@@ -1,8 +1,10 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable @typescript-eslint/no-non-null-asserted-optional-chain */
 /* eslint-disable no-await-in-loop */
 import { Backend } from '../../backup/index.js';
 import weaviate, { Collection, WeaviateClient } from '../../index.js';
+import { requireAtLeast } from '../../../test/version';
+import { WeaviateBackupFailed } from '../../errors.js';
 
 // These must run sequentially because Weaviate is not capable of running multiple backups at the same time
 describe('Integration testing of backups', () => {
@@ -88,6 +90,23 @@
       backend: res.backend as 'filesystem',
     });
     expect(status).not.toBe('SUCCESS'); // can be 'STARTED' or 'TRANSFERRING' depending on the speed of the test machine
+
+    // wait to complete so that other tests can run without colliding with Weaviate's lack of simultaneous backups
+    let wait = true;
+    while (wait) {
+      const { status, error } = await collection.backup.getCreateStatus({
+        backupId: res.id as string,
+        backend: res.backend as Backend,
+      });
+      if (status === 'SUCCESS') {
+        wait = false;
+      }
+      if (status === 'FAILED') {
+        throw new Error(`Backup creation failed: ${error}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+
     return collection;
   };
 
@@ -98,6 +117,87 @@
       .then(getCollection)
       .then(testCollectionWaitForCompletion)
       .then(testCollectionNoWaitForCompletion));
+
+  requireAtLeast(1, 32, 3).describe('overwrite alias', () => {
+
+    test('overwriteAlias=true', async () => {
+      const client = await clientPromise;
+
+      const things = await client.collections.create({ name: "ThingsTrue" });
+      await client.alias.create({ collection: things.name, alias: `${things.name}Alias` });
+
+      const backup = await client.backup.create({
+        backend: 'filesystem',
+        backupId: randomBackupId(),
+        includeCollections: [things.name],
+        waitForCompletion: true,
+      });
+
+      await client.collections.delete(things.name);
+      await client.alias.delete(`${things.name}Alias`);
+
+      // Change alias to point to a different collection
+      const inventory = await client.collections.create({ name: "InventoryTrue" });
+      await client.alias.create({ collection: inventory.name, alias: `${things.name}Alias` });
+
+
+      // Restore backup with overwriteAlias=true
+      await client.backup.restore({
+        backend: 'filesystem',
+        backupId: backup.id,
+        includeCollections: [things.name],
+        waitForCompletion: true,
+        config: { overwriteAlias: true },
+      });
+
+      // Assert: alias points to the original collection
+      const alias = await client.alias.get(`${things.name}Alias`);
+      expect(alias.collection).toEqual(things.name);
+    });
+
+    test('overwriteAlias=false', async () => {
+      const client = await clientPromise;
+
+      const things = await client.collections.create({ name: "ThingsFalse" });
+      await client.alias.create({ collection: things.name, alias: `${things.name}Alias` });
+
+      const backup = await client.backup.create({
+        backend: 'filesystem',
+        backupId: randomBackupId(),
+        includeCollections: [things.name],
+        waitForCompletion: true,
+      });
+
+      await client.collections.delete(things.name);
+      await client.alias.delete(`${things.name}Alias`);
+
+      // Change alias to point to a different collection
+      const inventory = await client.collections.create({ name: "InventoryFalse" });
+      await client.alias.create({ collection: inventory.name, alias: `${things.name}Alias` });
+
+
+      // Restore backup with overwriteAlias=true
+      const restored = client.backup.restore({
+        backend: 'filesystem',
+        backupId: backup.id,
+        includeCollections: [things.name],
+        waitForCompletion: true,
+        config: { overwriteAlias: false },
+      });
+
+      // Assert: fails with "alias already exists" error
+      await expect(restored).rejects.toThrowError(WeaviateBackupFailed);
+    });
+
+    it('cleanup', async () => {
+      await clientPromise.then(async c => {
+        await Promise.all(["ThingsTrue", "ThingsFalse", "InventoryTrue", "InventoryFalse"]
+          .map(name => c.collections.delete(name).catch(e => { })));
+        await c.alias.delete("ThingsFalseAlias").catch(e => { });
+        await c.alias.delete("ThingsTrueAlias").catch(e => { });
+      });
+    })
+  });
 });
 
 function randomBackupId() {

src/collections/backup/types.ts

@@ -37,6 +37,8 @@ export type BackupConfigCreate = {
 export type BackupConfigRestore = {
   /** The percentage of CPU to use for the backuop restoration job. */
   cpuPercentage?: number;
+  /**Allows ovewriting the collection alias if there is a conflict. */
+  overwriteAlias?: boolean;
 };
 
 /** The arguments required to create and restore backups. */