Add Backup types

src/backup/backupCreateStatusGetter.ts

@@ -1,6 +1,7 @@
 import Connection from '../connection';
 import { validateBackupId, validateBackend } from './validation';
 import { CommandBase } from '../validation/commandBase';
+import { BackupCreateStatusResponse } from '../types';
 
 export default class BackupCreateStatusGetter extends CommandBase {
   private backend?: string;
@@ -20,19 +21,19 @@ export default class BackupCreateStatusGetter extends CommandBase {
     return this;
   }
 
-  validate() {
+  validate = (): void => {
     this.addErrors([...validateBackend(this.backend), ...validateBackupId(this.backupId)]);
-  }
+  };
 
-  do() {
+  do = (): Promise<BackupCreateStatusResponse | Error> => {
     this.validate();
     if (this.errors.length > 0) {
       return Promise.reject(new Error('invalid usage: ' + this.errors.join(', ')));
     }
-    return this.client.get(this._path());
-  }
+    return this.client.get(this._path()) as Promise<BackupCreateStatusResponse>;
+  };
 
-  _path() {
+  private _path = (): string => {
     return `/backups/${this.backend}/${this.backupId}`;
-  }
+  };
 }

src/backup/backupCreator.ts

@@ -8,6 +8,7 @@ import {
 import BackupCreateStatusGetter from './backupCreateStatusGetter';
 import Connection from '../connection';
 import { CommandBase } from '../validation/commandBase';
+import { BackupCreateRequest, BackupCreateResponse, BackupCreateStatusResponse } from '../types';
 
 const WAIT_INTERVAL = 1000;
 
@@ -57,16 +58,16 @@ export default class BackupCreator extends CommandBase {
     return this;
   }
 
-  validate() {
+  validate = (): void => {
     this.addErrors([
       ...validateIncludeClassNames(this.includeClassNames),
       ...validateExcludeClassNames(this.excludeClassNames),
       ...validateBackend(this.backend),
       ...validateBackupId(this.backupId),
     ]);
-  }
+  };
 
-  do() {
+  do = (): Promise<BackupCreateResponse> => {
     this.validate();
     if (this.errors.length > 0) {
       return Promise.reject(new Error('invalid usage: ' + this.errors.join(', ')));
@@ -77,20 +78,20 @@ export default class BackupCreator extends CommandBase {
       config: {},
       include: this.includeClassNames,
       exclude: this.excludeClassNames,
-    };
+    } as BackupCreateRequest;
 
     if (this.waitForCompletion) {
       return this._createAndWaitForCompletion(payload);
     }
     return this._create(payload);
-  }
+  };
 
-  _create(payload: any) {
-    return this.client.post(this._path(), payload);
-  }
+  _create = (payload: BackupCreateRequest): Promise<BackupCreateResponse> => {
+    return this.client.post(this._path(), payload) as Promise<BackupCreateResponse>;
+  };
 
-  _createAndWaitForCompletion(payload: any) {
-    return new Promise((resolve, reject) => {
+  _createAndWaitForCompletion = (payload: BackupCreateRequest): Promise<BackupCreateResponse> => {
+    return new Promise<BackupCreateResponse>((resolve, reject) => {
       this._create(payload)
         .then((createResponse: any) => {
           this.statusGetter.withBackend(this.backend!).withBackupId(this.backupId!);
@@ -115,14 +116,17 @@ export default class BackupCreator extends CommandBase {
         })
         .catch(reject);
     });
-  }
+  };
 
-  _path() {
+  private _path = (): string => {
     return `/backups/${this.backend}`;
-  }
+  };
 
-  _merge(createStatusResponse: any, createResponse: any) {
-    const merged: any = {};
+  _merge = (
+    createStatusResponse: BackupCreateStatusResponse,
+    createResponse: BackupCreateResponse
+  ): BackupCreateResponse => {
+    const merged: BackupCreateResponse = {};
     if ('id' in createStatusResponse) {
       merged.id = createStatusResponse.id;
     }
@@ -142,5 +146,5 @@ export default class BackupCreator extends CommandBase {
       merged.classes = createResponse.classes;
     }
     return merged;
-  }
+  };
 }

src/backup/backupGetter.ts

@@ -1,6 +1,7 @@
 import { validateBackend } from './validation';
 import Connection from '../connection';
 import { CommandBase } from '../validation/commandBase';
+import { BackupCreateResponse } from '../types';
 
 export default class BackupGetter extends CommandBase {
   private backend?: string;
@@ -14,20 +15,20 @@ export default class BackupGetter extends CommandBase {
     return this;
   }
 
-  validate() {
+  validate = (): void => {
     this.addErrors(validateBackend(this.backend));
-  }
+  };
 
-  do() {
+  do = (): Promise<BackupCreateResponse[] | Error> => {
     this.validate();
     if (this.errors.length > 0) {
       return Promise.reject(new Error('invalid usage: ' + this.errors.join(', ')));
     }
 
     return this.client.get(this._path());
-  }
+  };
 
-  _path() {
+  private _path = (): string => {
     return `/backups/${this.backend}`;
-  }
+  };
 }

src/backup/backupRestoreStatusGetter.ts

@@ -1,6 +1,7 @@
 import { validateBackupId, validateBackend } from './validation';
 import Connection from '../connection';
 import { CommandBase } from '../validation/commandBase';
+import { BackupRestoreStatusResponse } from '../types';
 
 export default class BackupRestoreStatusGetter extends CommandBase {
   private backend?: string;
@@ -20,20 +21,20 @@ export default class BackupRestoreStatusGetter extends CommandBase {
     return this;
   }
 
-  validate() {
+  validate = (): void => {
     this.addErrors([...validateBackend(this.backend), ...validateBackupId(this.backupId)]);
-  }
+  };
 
-  do() {
+  do = (): Promise<BackupRestoreStatusResponse | Error> => {
     this.validate();
     if (this.errors.length > 0) {
       return Promise.reject(new Error('invalid usage: ' + this.errors.join(', ')));
     }
 
     return this.client.get(this._path());
-  }
+  };
 
-  _path() {
+  private _path = (): string => {
     return `/backups/${this.backend}/${this.backupId}/restore`;
-  }
+  };
 }

src/backup/backupRestorer.ts

@@ -8,6 +8,7 @@ import {
 import Connection from '../connection';
 import BackupRestoreStatusGetter from './backupRestoreStatusGetter';
 import { CommandBase } from '../validation/commandBase';
+import { BackupRestoreRequest, BackupRestoreResponse, BackupRestoreStatusResponse } from '../types';
 
 const WAIT_INTERVAL = 1000;
 
@@ -57,16 +58,16 @@ export default class BackupRestorer extends CommandBase {
     return this;
   }
 
-  validate() {
+  validate = (): void => {
     this.addErrors([
       ...validateIncludeClassNames(this.includeClassNames || []),
       ...validateExcludeClassNames(this.excludeClassNames || []),
       ...validateBackend(this.backend),
       ...validateBackupId(this.backupId),
     ]);
-  }
+  };
 
-  do() {
+  do = (): Promise<BackupRestoreResponse> => {
     this.validate();
     if (this.errors.length > 0) {
       return Promise.reject(new Error('invalid usage: ' + this.errors.join(', ')));
@@ -76,20 +77,20 @@ export default class BackupRestorer extends CommandBase {
       config: {},
       include: this.includeClassNames,
       exclude: this.excludeClassNames,
-    };
+    } as BackupRestoreRequest;
 
     if (this.waitForCompletion) {
       return this._restoreAndWaitForCompletion(payload);
     }
     return this._restore(payload);
-  }
+  };
 
-  _restore(payload: any) {
+  _restore = (payload: BackupRestoreRequest): Promise<BackupRestoreResponse> => {
     return this.client.post(this._path(), payload);
-  }
+  };
 
-  _restoreAndWaitForCompletion(payload: any) {
-    return new Promise((resolve, reject) => {
+  _restoreAndWaitForCompletion = (payload: BackupRestoreRequest): Promise<BackupRestoreResponse> => {
+    return new Promise<BackupRestoreResponse>((resolve, reject) => {
       this._restore(payload)
         .then((restoreResponse: any) => {
           this.statusGetter.withBackend(this.backend!).withBackupId(this.backupId!);
@@ -114,14 +115,17 @@ export default class BackupRestorer extends CommandBase {
         })
         .catch(reject);
     });
-  }
+  };
 
-  _path() {
+  private _path = (): string => {
     return `/backups/${this.backend}/${this.backupId}/restore`;
-  }
+  };
 
-  _merge(restoreStatusResponse: any, restoreResponse: any) {
-    const merged: any = {};
+  _merge = (
+    restoreStatusResponse: BackupRestoreStatusResponse,
+    restoreResponse: BackupRestoreResponse
+  ): BackupRestoreResponse => {
+    const merged: BackupRestoreResponse = {};
     if ('id' in restoreStatusResponse) {
       merged.id = restoreStatusResponse.id;
     }
@@ -141,5 +145,5 @@ export default class BackupRestorer extends CommandBase {
       merged.classes = restoreResponse.classes;
     }
     return merged;
-  }
+  };
 }

src/backup/journey.test.ts

@@ -1,4 +1,5 @@
 import weaviate, { WeaviateClient } from '../index';
+import { BackupCreateResponse } from '../types';
 
 const {
   createTestFoodSchemaAndData,
@@ -30,7 +31,7 @@ describe('create and restore backup with waiting', () => {
       .withBackupId(BACKUP_ID)
       .withWaitForCompletion(true)
       .do()
-      .then((createResponse: any) => {
+      .then((createResponse: BackupCreateResponse) => {
         expect(createResponse.id).toBe(BACKUP_ID);
         expect(createResponse.classes).toHaveLength(1);
         expect(createResponse.classes).toContain(PIZZA_CLASS_NAME);

src/types.ts

@@ -5,3 +5,11 @@ export type WeaviateObjectList = definitions['ObjectsListResponse'];
 export type Reference = definitions['SingleRef'];
 export type WeaviateError = definitions['ErrorResponse'];
 export type Properties = definitions['PropertySchema'];
+export type DataObject = definitions['Object'];
+
+export type BackupCreateRequest = definitions['BackupCreateRequest'];
+export type BackupCreateResponse = definitions['BackupCreateResponse'];
+export type BackupCreateStatusResponse = definitions['BackupCreateStatusResponse'];
+export type BackupRestoreRequest = definitions['BackupRestoreRequest'];
+export type BackupRestoreResponse = definitions['BackupRestoreResponse'];
+export type BackupRestoreStatusResponse = definitions['BackupRestoreStatusResponse'];