feat: support list backups

src/backup/journey.test.ts

@@ -950,56 +950,6 @@ describe('fails restoring backup with invalid compression config', () => {
   it('cleans up', () => cleanupTestFood(client));
 });
 
-// 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 => {
-//         expect(allResponse).toHaveLength(2);
-//         expect(allResponse).toEqual(expect.arrayContaining([
-//           expect.objectContaining({id: BACKUP_ID_PIZZA}),
-//           expect.objectContaining({id: BACKUP_ID_SOUP}),
-//         ]));
-//       })
-//       .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 @@
   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');
@@ -197,11 +197,14 @@
       }
       return status
         ? {
-            ...parseResponse(res),
-            ...status,
-          }
+          ...parseResponse(res),
+          ...status,
+        }
         : parseResponse(res);
     },
+    list: (backend: Backend): Promise<BackupReturn[]> => {
+      return connection.get<BackupReturn[]>(`/backups/${backend}`);
+    },
   };
 };
 
@@ -251,4 +254,11 @@
    * @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.
+   * */
+  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);
+  }
+});