feat: add list backups to v3 API

Author: bevzzz

src/backup/journey.test.ts

@@ -7,7 +7,6 @@ import {
 import weaviate, { WeaviateClient } from '../v2/index.js';
 import { Backend } from './index.js';
 
-import { requireAtLeast } from '../../test/version';
 const {
   createTestFoodSchemaAndData,
   cleanupTestFood,
@@ -951,62 +950,6 @@ describe('fails restoring backup with invalid compression config', () => {
   it('cleans up', () => cleanupTestFood(client));
 });
 
-requireAtLeast(1, 32, 0).describe('get all exising backups', () => {
-  const BACKEND: Backend = 'filesystem';
-  const BACKUP_ID = randomBackupId();
-  const BACKUP_ID_PIZZA = BACKUP_ID + '-pizza';
-  const BACKUP_ID_SOUP = BACKUP_ID + '-soup';
-
-  const client = weaviate.client({
-    scheme: 'http',
-    host: 'localhost:8080',
-  });
-
-  it('sets up', () => createTestFoodSchemaAndData(client));
-
-  it('creates backup pizza', () => {
-    return client.backup
-      .creator()
-      .withIncludeClassNames(PIZZA_CLASS_NAME)
-      .withBackend(BACKEND)
-      .withBackupId(BACKUP_ID_PIZZA)
-      .withWaitForCompletion(true)
-      .do()
-      .catch((err: any) => {
-        throw new Error('should not fail on create backup: ' + err);
-      });
-  });
-
-  it('creates backup soup', () => {
-    return client.backup
-      .creator()
-      .withIncludeClassNames(SOUP_CLASS_NAME)
-      .withBackend(BACKEND)
-      .withBackupId(BACKUP_ID_SOUP)
-      .withWaitForCompletion(true)
-      .do()
-      .catch((err: any) => {
-        throw new Error('should not fail on create backup: ' + err);
-      });
-  });
-
-  it('get all', () => {
-    return client.backup
-      .getter()
-      .withBackend(BACKEND)
-      .do()
-      .then((allResponse) => {
-        const relevant = allResponse.filter((b) => b.id === BACKUP_ID_SOUP || b.id === BACKUP_ID_PIZZA);
-        expect(relevant).toHaveLength(2);
-      })
-      .catch((err: any) => {
-        throw new Error('should not fail on getting all: ' + err);
-      });
-  });
-
-  it('cleans up', () => cleanupTestFood(client));
-});
-
 function assertThatAllPizzasExist(client: WeaviateClient) {
   return assertThatAllFoodObjectsExist(client, 'Pizza', 4);
 }

src/collections/backup/client.ts

@@ -30,7 +30,7 @@ import {
   BackupStatusReturn,
 } from './types.js';
 
-export const backup = (connection: Connection) => {
+export const backup = (connection: Connection): Backup => {
   const parseStatus = (res: BackupCreateStatusResponse | BackupRestoreResponse): BackupStatusReturn => {
     if (res.id === undefined) {
       throw new WeaviateUnexpectedResponseError('Backup ID is undefined in response');
@@ -202,6 +202,9 @@ export const backup = (connection: Connection) => {
           }
         : parseResponse(res);
     },
+    list: (backend: Backend): Promise<BackupReturn[]> => {
+      return connection.get<BackupReturn[]>(`/backups/${backend}`);
+    },
   };
 };
 
@@ -251,4 +254,14 @@ export interface Backup {
    * @throws {WeaviateBackupCanceled} If the backup restoration is canceled.
    */
   restore(args: BackupArgs<BackupConfigRestore>): Promise<BackupReturn>;
+
+  /** List existing backups (completed and in-progress) created in a given backend.
+   *
+   * @param {Backend} backend Backend whence to list backups.
+   * @returns {Promise<BackupReturn[]>} The response from Weaviate.
+   * @throws {WeaviateInvalidInputError} If the input is invalid.
+   * @throws {WeaviateBackupFailed} If the backup restoration fails.
+   * @throws {WeaviateBackupCanceled} If the backup restoration is canceled.
+   * */
+  list(backend: Backend): Promise<BackupReturn[]>;
 }

src/collections/backup/integration.test.ts

@@ -1,6 +1,7 @@
 /* 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 { requireAtLeast } from '../../../test/version.js';
 import { Backend } from '../../backup/index.js';
 import weaviate, { Collection, WeaviateClient } from '../../index.js';
 
@@ -88,6 +89,23 @@ describe('Integration testing of backups', () => {
       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,8 +116,38 @@ describe('Integration testing of backups', () => {
       .then(getCollection)
       .then(testCollectionWaitForCompletion)
       .then(testCollectionNoWaitForCompletion));
-});
 
-function randomBackupId() {
-  return 'backup-id-' + Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
-}
+  requireAtLeast(1, 32, 0).it('get all exising backups', async () => {
+    await clientPromise.then(async (client) => {
+      await client.collections.create({ name: 'TestListBackups' }).then((col) => col.data.insert());
+
+      const wantBackups: string[] = [];
+      for (let i = 0; i < 3; i++) {
+        wantBackups.push(
+          await client.backup
+            .create({
+              backupId: randomBackupId(),
+              backend: 'filesystem',
+              includeCollections: ['TestListBackups'],
+              waitForCompletion: true,
+            })
+            .then((res) => {
+              return res.id;
+            })
+        );
+      }
+
+      const gotBackups: string[] = await client.backup
+        .list('filesystem')
+        .then((res) => res.map((bu) => bu.id));
+
+      // There may be other backups created in other tests;
+      expect(gotBackups.length).toBeGreaterThanOrEqual(wantBackups.length);
+      expect(gotBackups).toEqual(expect.arrayContaining(wantBackups));
+    });
+  });
+
+  function randomBackupId() {
+    return 'backup-id-' + Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+  }
+});