feat: integrate proxy support for REST/gRPC/OIDC and add new OIDC authentication grant

.github/workflows/test.yaml

@@ -78,7 +78,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        WEAVIATE_VERSION: ["1.32.24", "1.33.11", "1.34.7", "1.35.2"]
+        WEAVIATE_VERSION: ["1.32.24", "1.33.11", "1.34.7", "1.35.2", "1.36.1"]
     steps:
       - uses: actions/checkout@v4
 

README.md

@@ -15,7 +15,7 @@ To start using Weaviate Java Client add the dependency to `pom.xml`:
 <dependency>
     <groupId>io.weaviate</groupId>
     <artifactId>client6</artifactId>
-    <version>6.0.1</version>
+    <version>6.1.0</version>
 </dependency>
 ```
 
@@ -28,7 +28,7 @@ This ensures that all dynamically-loaded dependecies of `io.grpc` are resolved c
 <dependency>
     <groupId>io.weaviate</groupId>
     <artifactId>client6</artifactId>
-    <version>6.0.1</version>
+    <version>6.1.0</version>
     <classifier>all</classifier>
 </dependency>
 ```

pom.xml

@@ -5,7 +5,7 @@
   <groupId>io.weaviate</groupId>
   <artifactId>client6</artifactId>
   <packaging>jar</packaging>
-  <version>6.0.2-SNAPSHOT</version>
+  <version>6.1.1-SNAPSHOT</version>
 
   <name>${project.groupId}:${project.artifactId}</name>
   <description>Official Java client for Weaviate Vector Search Engine</description>
@@ -42,7 +42,7 @@
     <connection>scm:git:git://github.com/weaviate/java-client.git</connection>
     <developerConnection>scm:git:ssh://github.com:weaviate/java-client.git</developerConnection>
     <url>https://github.com/weaviate/java-client/tree/main</url>
-    <tag>6.0.1</tag>
+    <tag>6.1.0</tag>
   </scm>
 
   <properties>

src/it/java/io/weaviate/ConcurrentTest.java

@@ -126,10 +126,37 @@ public static void requireAtLeast(Weaviate.Version required) {
         .isGreaterThanOrEqualTo(required.semver);
   }
 
+  @FunctionalInterface
+  public interface ThrowingRunnable {
+    void run() throws Exception;
+  }
+
+  /**
+   * Run a block of code only if the server version is recent enough.
+   *
+   * @param required Minimal required version.
+   * @param r        Runnable.
+   */
   public static void requireAtLeast(Weaviate.Version required, Runnable r) {
     var actual = SemanticVersion.of(Weaviate.VERSION);
     if (actual.compareTo(required.semver) >= 0) {
       r.run();
     }
   }
+
+  /**
+   * Wraps a {@link ThrowingRunnable} as {@link Runnable} that
+   * re-throws all exceptions as {@link RuntimeException}.
+   *
+   * @param tr Runnable which may throw a checked exception.
+   */
+  public static Runnable throwing(ThrowingRunnable tr) {
+    return () -> {
+      try {
+        tr.run();
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+    };
+  }
 }

src/it/java/io/weaviate/containers/Weaviate.java

@@ -26,7 +26,7 @@
 
 public class Weaviate extends WeaviateContainer {
   public static final String DOCKER_IMAGE = "semitechnologies/weaviate";
-  public static final String LATEST_VERSION = Version.V135.semver.toString();
+  public static final String LATEST_VERSION = Version.latest().semver.toString();
   public static final String VERSION;
 
   static {
@@ -41,17 +41,30 @@ public enum Version {
     V132(1, 32, 24),
     V133(1, 33, 11),
     V134(1, 34, 7),
-    V135(1, 35, 2);
+    V135(1, 35, 2),
+    V136(1, 36, 1);
 
     public final SemanticVersion semver;
 
     private Version(int major, int minor, int patch) {
       this.semver = new SemanticVersion(major, minor, patch);
     }
 
+    private Version(int major, int minor, String patch) {
+      this.semver = new SemanticVersion(major, minor, patch);
+    }
+
     public void orSkip() {
       ConcurrentTest.requireAtLeast(this);
     }
+
+    public static Version latest() {
+      Version[] versions = Version.class.getEnumConstants();
+      if (versions == null) {
+        throw new IllegalStateException("No versions are defined");
+      }
+      return versions[versions.length - 1];
+    }
   }
 
   /**
@@ -287,6 +300,9 @@ public Weaviate build() {
         c.withEnv("ENABLE_MODULES", String.join(",", enableModules));
       }
 
+      // Required in v1.36.1, but we'll just set it by default.
+      c.withEnv("OBJECTS_TTL_DELETE_SCHEDULE", "@hourly");
+
       var apiKeyUsers = new HashSet<String>();
       apiKeyUsers.addAll(adminUsers);
       apiKeyUsers.addAll(viewerUsers);

src/it/java/io/weaviate/integration/BackupITest.java

@@ -14,6 +14,8 @@
 import org.assertj.core.api.InstanceOfAssertFactories;
 import org.junit.Test;
 
+import com.sun.nio.sctp.IllegalUnbindException;
+
 import io.weaviate.ConcurrentTest;
 import io.weaviate.client6.v1.api.WeaviateClient;
 import io.weaviate.client6.v1.api.backup.Backup;
@@ -112,14 +114,22 @@ public void test_lifecycle() throws IOException, TimeoutException {
 
     // Act: delete data and restore backup #1
     client.collections.delete(nsA);
-    client.backup.restore(backup_1, backend, restore -> restore.includeCollections(nsA));
+    var restoreMe = client.backup.restore(backup_1, backend, restore -> restore.includeCollections(nsA));
 
     // Assert: object inserted in the beginning of the test is present
-    var restore_1 = client.backup.getRestoreStatus(backup_1, backend)
-        .orElseThrow().waitForCompletion(client);
-    Assertions.assertThat(restore_1).as("restore backup #1")
+    restoreMe = restoreMe.waitForCompletion(client);
+    Assertions.assertThat(restoreMe).as("restore backup #1")
         .returns(BackupStatus.SUCCESS, Backup::status);
     Assertions.assertThat(collectionA.size()).as("after restore backup #1").isEqualTo(1);
+
+    // Act: restore and cancel
+    requireAtLeast(Weaviate.Version.V136, throwing(() -> {
+      var restore_2 = client.backup.restore(backup_2, backend);
+      client.backup.cancelRestore(backup_2, backend);
+      var canceledRestore = restore_2.waitForStatus(client, BackupStatus.CANCELED);
+      Assertions.assertThat(canceledRestore).as("cancel backup restore #2")
+          .returns(BackupStatus.CANCELED, Backup::status);
+    }));
   }
 
   @Test
@@ -215,13 +225,11 @@ public void test_lifecycle_async() throws ExecutionException, InterruptedExcepti
 
       // Act: delete data and restore backup #1
       async.collections.delete(nsA).join();
-      async.backup.restore(backup_1, backend, restore -> restore.includeCollections(nsA)).join();
+      var restoreMe = async.backup.restore(backup_1, backend, restore -> restore.includeCollections(nsA)).join();
 
       // Assert: object inserted in the beginning of the test is present
-      var restore_1 = async.backup.getRestoreStatus(backup_1, backend)
-          .thenCompose(bak -> bak.orElseThrow().waitForCompletion(async))
-          .join();
-      Assertions.assertThat(restore_1).as("restore backup #1")
+      restoreMe = restoreMe.waitForCompletion(async).join();
+      Assertions.assertThat(restoreMe).as("restore backup #1")
           .returns(BackupStatus.SUCCESS, Backup::status);
       Assertions.assertThat(collectionA.size().join()).as("after restore backup #1").isEqualTo(1);
     }

src/it/java/io/weaviate/integration/CollectionsITest.java

@@ -18,7 +18,9 @@
 import io.weaviate.client6.v1.api.collections.Quantization;
 import io.weaviate.client6.v1.api.collections.ReferenceProperty;
 import io.weaviate.client6.v1.api.collections.Replication;
+import io.weaviate.client6.v1.api.collections.Replication.AsyncReplicationConfig;
 import io.weaviate.client6.v1.api.collections.VectorConfig;
+import io.weaviate.client6.v1.api.collections.config.PropertyIndexType;
 import io.weaviate.client6.v1.api.collections.config.Shard;
 import io.weaviate.client6.v1.api.collections.config.ShardStatus;
 import io.weaviate.client6.v1.api.collections.generative.DummyGenerative;
@@ -328,4 +330,94 @@ public void test_objectTtl() throws IOException {
         .extracting(CollectionConfig::objectTtl).isNotNull()
         .returns(false, ObjectTtl::enabled);
   }
+
+  @Test
+  public void test_dropPropertyIndex() throws IOException {
+    Weaviate.Version.V136.orSkip();
+
+    // Arrange
+    var nsThings = ns("Things");
+    var things = client.collections.create(nsThings,
+        c -> c.properties(
+            Property.text("title", p -> p
+                .indexFilterable(true)
+                .indexSearchable(true)),
+            Property.integer("size", p -> p
+                .indexRangeFilters(true))));
+
+    var config = things.config.get();
+    Assertions.assertThat(config).get()
+        .extracting(CollectionConfig::properties, InstanceOfAssertFactories.list(Property.class))
+        .allSatisfy(property -> {
+          boolean isNumeric = property.dataTypes().contains(DataType.INT);
+
+          Assertions.assertThat(property)
+              .returns(true, Property::indexFilterable)
+              .returns(!isNumeric, Property::indexSearchable)
+              .returns(isNumeric, Property::indexRangeFilters);
+        });
+
+    things.config.dropPropertyIndex("title", PropertyIndexType.FILTERABLE);
+    things.config.dropPropertyIndex("title", PropertyIndexType.SEARCHABLE);
+
+    things.config.dropPropertyIndex("size", PropertyIndexType.FILTERABLE);
+    things.config.dropPropertyIndex("size", PropertyIndexType.RANGE_FILTERS);
+
+    config = things.config.get();
+    Assertions.assertThat(config).get()
+        .extracting(CollectionConfig::properties, InstanceOfAssertFactories.list(Property.class))
+        .allSatisfy(property -> Assertions.assertThat(property)
+            .returns(false, Property::indexFilterable)
+            .returns(false, Property::indexSearchable)
+            .returns(false, Property::indexRangeFilters));
+    }
+
+  @Test
+  public void test_asyncReplicationConfig() throws IOException {
+    Weaviate.Version.latest().orSkip();
+
+    // Arrange
+    var nsThings = ns("Things");
+
+    // Act
+    var things = client.collections.create(nsThings,
+        c -> c.replication(Replication.of(
+            repl -> repl
+                .asyncEnabled(true)
+                .asyncReplication(AsyncReplicationConfig.of(
+                    async -> async
+                        .hashTreeHeight(1)
+                        .maxWorkers(2)
+                        .frequencyMillis(3)
+                        .frequencyMillisWhilePropagating(4)
+                        .aliveNodesCheckingFrequencyMillis(5)
+                        .loggingFrequencySeconds(6)
+                        .diffBatchSize(7)
+                        .diffPerNodeTimeoutSeconds(8)
+                        .prePropagationTimeoutSeconds(9)
+                        .propagationTimeoutSeconds(10)
+                        .propagationDelayMillis(11)
+                        .propagationLimit(12)
+                        .propagationConcurrency(13)
+                        .propagationBatchSize(14))))));
+
+    // Assert
+    Assertions.assertThat(things.config.get()).get()
+        .extracting(CollectionConfig::replication)
+        .extracting(Replication::asyncReplicationConfig)
+        .returns(1, AsyncReplicationConfig::hashTreeHeight)
+        .returns(2, AsyncReplicationConfig::maxWorkers)
+        .returns(3, AsyncReplicationConfig::frequencyMillis)
+        .returns(4, AsyncReplicationConfig::frequencyMillisWhilePropagating)
+        .returns(5, AsyncReplicationConfig::aliveNodesCheckingFrequencyMillis)
+        .returns(6, AsyncReplicationConfig::loggingFrequencySeconds)
+        .returns(7, AsyncReplicationConfig::diffBatchSize)
+        .returns(8, AsyncReplicationConfig::diffPerNodeTimeoutSeconds)
+        .returns(9, AsyncReplicationConfig::prePropagationTimeoutSeconds)
+        .returns(10, AsyncReplicationConfig::propagationTimeoutSeconds)
+        .returns(11, AsyncReplicationConfig::propagationDelayMillis)
+        .returns(12, AsyncReplicationConfig::propagationLimit)
+        .returns(13, AsyncReplicationConfig::propagationConcurrency)
+        .returns(14, AsyncReplicationConfig::propagationBatchSize);
+  }
 }

src/it/java/io/weaviate/integration/OIDCSupportITest.java

@@ -104,7 +104,7 @@ public void test_resourceOwnerPassword() throws Exception {
 
   @Test
   public void test_clientCredentials() throws Exception {
-    Assume.assumeTrue("OKTA_CLIENT_SECRET is not set", OKTA_CLIENT_SECRET != null && OKTA_CLIENT_SECRET.isBlank());
+    Assume.assumeTrue("OKTA_CLIENT_SECRET is not set", OKTA_CLIENT_SECRET != null && !OKTA_CLIENT_SECRET.isBlank());
     Assume.assumeTrue("no internet connection", hasInternetConnection());
 
     // Check norwal client credentials flow works.

src/it/java/io/weaviate/integration/RbacITest.java

@@ -84,15 +84,6 @@ public void test_roles_Lifecycle() throws IOException {
           Permission.groups("my-group", GroupType.OIDC, GroupsPermission.Action.READ));
     });
 
-    requireAtLeast(Weaviate.Version.V132, () -> {
-      permissions.add(
-          Permission.aliases("ThingsAlias", myCollection, AliasesPermission.Action.CREATE));
-    });
-    requireAtLeast(Weaviate.Version.V133, () -> {
-      permissions.add(
-          Permission.groups("my-group", GroupType.OIDC, GroupsPermission.Action.READ));
-    });
-
     // Act: create role
     client.roles.create(nsRole, permissions);
 

src/main/java/io/weaviate/client6/v1/api/Authentication.java

@@ -56,6 +56,26 @@ public static Authentication resourceOwnerPassword(String username, String passw
     };
   }
 
+  /**
+   * Authenticate using Resource Owner Password Credentials authorization grant.
+   *
+   * @param clientSecret Client secret.
+   * @param username     Resource owner username.
+   * @param password     Resource owner password.
+   * @param scopes       Client scopes.
+   *
+   * @return Authentication provider.
+   * @throws WeaviateOAuthException if an error occurred at any point of the token
+   *                                exchange process.
+   */
+  public static Authentication resourceOwnerPasswordCredentials(String clientSecret, String username, String password,
+                                                                List<String> scopes) {
+    return transport -> {
+      OidcConfig oidc = OidcUtils.getConfig(transport).withScopes(scopes).withScopes("offline_access");
+      return TokenProvider.resourceOwnerPasswordCredentials(oidc, clientSecret, username, password);
+    };
+  }
+
   /**
    * Authenticate using Client Credentials authorization grant.
    *