Add options for specifying deletionStrategy in replication config methods/returns

Author: tsmith023

src/collections/config/types/index.ts

@@ -40,8 +40,11 @@ export type MultiTenancyConfig = {
   enabled: boolean;
 };
 
+export type ReplicationDeletionStrategy = 'DeleteOnConflict' | 'NoAutomatedResolution';
+
 export type ReplicationConfig = {
   asyncEnabled: boolean;
+  deletionStrategy: ReplicationDeletionStrategy;
   factor: number;
 };
 

src/collections/config/utils.ts

@@ -265,6 +265,7 @@ class ConfigMapping {
     return {
       factor: v.factor,
       asyncEnabled: v.asyncEnabled ? v.asyncEnabled : false,
+      deletionStrategy: v.deletionStrategy ? v.deletionStrategy : 'NoAutomatedResolution',
     };
   }
   static sharding(v?: WeaviateShardingConfig): ShardingConfig {

src/collections/configure/index.ts

@@ -3,6 +3,7 @@ import {
   InvertedIndexConfigUpdate,
   MultiTenancyConfigCreate,
   ReplicationConfigCreate,
+  ReplicationDeletionStrategy,
   ShardingConfigCreate,
   VectorConfigUpdate,
   VectorIndexType,
@@ -131,10 +132,19 @@ const configure = {
    * See [the docs](https://weaviate.io/developers/weaviate/concepts/replication-architecture#replication-vs-sharding) for more details.
    *
    * @param {boolean} [options.asyncEnabled] Whether asynchronous replication is enabled. Default is false.
+   * @param {ReplicationDeletionStrategy} [options.deletionStrategy] The deletion strategy when replication conflicts are detected between deletes and reads.
    * @param {number} [options.factor] The replication factor. Default is 1.
    */
-  replication: (options: { asyncEnabled?: boolean; factor?: number }): ReplicationConfigCreate => {
-    return { asyncEnabled: options.asyncEnabled, factor: options.factor };
+  replication: (options: {
+    asyncEnabled?: boolean;
+    deletionStrategy?: ReplicationDeletionStrategy;
+    factor?: number;
+  }): ReplicationConfigCreate => {
+    return {
+      asyncEnabled: options.asyncEnabled,
+      deletionStrategy: options.deletionStrategy,
+      factor: options.factor,
+    };
   },
   /**
    * Create a `ShardingConfigCreate` object to be used when defining the sharding configuration of your collection.
@@ -217,10 +227,19 @@ const reconfigure = {
    * See [the docs](https://weaviate.io/developers/weaviate/concepts/replication-architecture#replication-vs-sharding) for more details.
    *
    * @param {boolean} [options.asyncEnabled] Whether asynchronous replication is enabled.
+   * @param {ReplicationDeletionStrategy} [options.deletionStrategy] The deletion strategy when replication conflicts are detected between deletes and reads.
    * @param {number} [options.factor] The replication factor.
    */
-  replication: (options: { asyncEnabled?: boolean; factor?: number }): ReplicationConfigCreate => {
-    return { asyncEnabled: options.asyncEnabled, factor: options.factor };
+  replication: (options: {
+    asyncEnabled?: boolean;
+    deletionStrategy?: ReplicationDeletionStrategy;
+    factor?: number;
+  }): ReplicationConfigCreate => {
+    return {
+      asyncEnabled: options.asyncEnabled,
+      deletionStrategy: options.deletionStrategy,
+      factor: options.factor,
+    };
   },
 };
 

src/collections/configure/types/base.ts

@@ -1,11 +1,18 @@
 import { WeaviateNestedProperty, WeaviateProperty } from '../../../openapi/types.js';
-import { InvertedIndexConfig, MultiTenancyConfig, ReplicationConfig } from '../../config/types/index.js';
+import {
+  InvertedIndexConfig,
+  MultiTenancyConfig,
+  ReplicationConfig,
+  ReplicationDeletionStrategy,
+} from '../../config/types/index.js';
 import { DataType } from '../../types/index.js';
 import { NonRefKeys, RefKeys } from '../../types/internal.js';
 
-export type RecursivePartial<T> = {
-  [P in keyof T]?: RecursivePartial<T[P]>;
-};
+export type RecursivePartial<T> = T extends object
+  ? {
+      [P in keyof T]?: RecursivePartial<T[P]>;
+    }
+  : T;
 
 export type InvertedIndexConfigCreate = RecursivePartial<InvertedIndexConfig>;
 
@@ -133,6 +140,7 @@ export type ReplicationConfigCreate = RecursivePartial<ReplicationConfig>;
 
 export type ReplicationConfigUpdate = {
   asyncEnabled?: boolean;
+  deletionStragey?: ReplicationDeletionStrategy;
   factor?: number;
 };
 

src/collections/configure/unit.test.ts

@@ -79,10 +79,12 @@ describe('Unit testing of the configure factory class', () => {
   it('should create the correct ReplicationConfig type with all values', () => {
     const config = configure.replication({
       asyncEnabled: true,
+      deletionStrategy: 'DeleteOnConflict',
       factor: 2,
     });
     expect(config).toEqual<ReplicationConfigCreate>({
       asyncEnabled: true,
+      deletionStrategy: 'DeleteOnConflict',
       factor: 2,
     });
   });

src/collections/integration.test.ts

@@ -578,6 +578,8 @@ describe('Testing of the collections.create method', () => {
 
     expect(response.multiTenancy.enabled).toEqual(true);
 
+    expect(response.replication.asyncEnabled).toEqual(false);
+    expect(response.replication.deletionStrategy).toEqual('DeleteOnConflict');
     expect(response.replication.factor).toEqual(2);
 
     const indexConfig = response.vectorizers.default.indexConfig as VectorIndexConfigHNSW;

src/openapi/schema.ts

@@ -147,12 +147,16 @@ export interface paths {
     head: operations['tenant.exists'];
   };
   '/backups/{backend}': {
+    /** [Coming soon] List all backups in progress not implemented yet. */
+    get: operations['backups.list'];
     /** Starts a process of creating a backup for a set of classes */
     post: operations['backups.create'];
   };
   '/backups/{backend}/{id}': {
     /** Returns status of backup creation attempt for a set of classes */
     get: operations['backups.create.status'];
+    /** Cancel created backup with specified ID */
+    delete: operations['backups.cancel'];
   };
   '/backups/{backend}/{id}/restore': {
     /** Returns status of a backup restoration attempt for a set of classes */
@@ -344,6 +348,11 @@ export interface definitions {
     factor?: number;
     /** @description Enable asynchronous replication */
     asyncEnabled?: boolean;
+    /**
+     * @description Conflict resolution strategy for deleted objects
+     * @enum {string}
+     */
+    deletionStrategy?: 'NoAutomatedResolution' | 'DeleteOnConflict';
   };
   /** @description tuning parameters for the BM25 algorithm */
   BM25Config: {
@@ -572,7 +581,7 @@ export interface definitions {
      * @default STARTED
      * @enum {string}
      */
-    status?: 'STARTED' | 'TRANSFERRING' | 'TRANSFERRED' | 'SUCCESS' | 'FAILED';
+    status?: 'STARTED' | 'TRANSFERRING' | 'TRANSFERRED' | 'SUCCESS' | 'FAILED' | 'CANCELED';
   };
   /** @description The definition of a backup restore metadata */
   BackupRestoreStatusResponse: {
@@ -648,6 +657,20 @@ export interface definitions {
      */
     status?: 'STARTED' | 'TRANSFERRING' | 'TRANSFERRED' | 'SUCCESS' | 'FAILED';
   };
+  /** @description The definition of a backup create response body */
+  BackupListResponse: {
+    /** @description The ID of the backup. Must be URL-safe and work as a filesystem path, only lowercase, numbers, underscore, minus characters allowed. */
+    id?: string;
+    /** @description destination path of backup files proper to selected backend */
+    path?: string;
+    /** @description The list of classes for which the existed backup process */
+    classes?: string[];
+    /**
+     * @description status of backup process
+     * @enum {string}
+     */
+    status?: 'STARTED' | 'TRANSFERRING' | 'TRANSFERRED' | 'SUCCESS' | 'FAILED' | 'CANCELED';
+  }[];
   /** @description Request body for restoring a backup for a set of classes */
   BackupRestoreRequest: {
     /** @description Custom configuration for the backup restoration process */
@@ -2685,6 +2708,35 @@ export interface operations {
       };
     };
   };
+  /** [Coming soon] List all backups in progress not implemented yet. */
+  'backups.list': {
+    parameters: {
+      path: {
+        /** Backup backend name e.g. filesystem, gcs, s3. */
+        backend: string;
+      };
+    };
+    responses: {
+      /** Existed backups */
+      200: {
+        schema: definitions['BackupListResponse'];
+      };
+      /** Unauthorized or invalid credentials. */
+      401: unknown;
+      /** Forbidden */
+      403: {
+        schema: definitions['ErrorResponse'];
+      };
+      /** Invalid backup list. */
+      422: {
+        schema: definitions['ErrorResponse'];
+      };
+      /** An error has occurred while trying to fulfill the request. Most likely the ErrorResponse will contain more information about the error. */
+      500: {
+        schema: definitions['ErrorResponse'];
+      };
+    };
+  };
   /** Starts a process of creating a backup for a set of classes */
   'backups.create': {
     parameters: {
@@ -2752,6 +2804,35 @@ export interface operations {
       };
     };
   };
+  /** Cancel created backup with specified ID */
+  'backups.cancel': {
+    parameters: {
+      path: {
+        /** Backup backend name e.g. filesystem, gcs, s3. */
+        backend: string;
+        /** The ID of a backup. Must be URL-safe and work as a filesystem path, only lowercase, numbers, underscore, minus characters allowed. */
+        id: string;
+      };
+    };
+    responses: {
+      /** Successfully deleted. */
+      204: never;
+      /** Unauthorized or invalid credentials. */
+      401: unknown;
+      /** Forbidden */
+      403: {
+        schema: definitions['ErrorResponse'];
+      };
+      /** Invalid backup cancellation attempt. */
+      422: {
+        schema: definitions['ErrorResponse'];
+      };
+      /** An error has occurred while trying to fulfill the request. Most likely the ErrorResponse will contain more information about the error. */
+      500: {
+        schema: definitions['ErrorResponse'];
+      };
+    };
+  };
   /** Returns status of a backup restoration attempt for a set of classes */
   'backups.restore.status': {
     parameters: {