v6: Simplify WeaviateObject interface

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

@@ -20,14 +20,14 @@
 import io.weaviate.client6.v1.api.collections.ReferenceProperty;
 import io.weaviate.client6.v1.api.collections.VectorConfig;
 import io.weaviate.client6.v1.api.collections.Vectors;
-import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.api.collections.data.BatchReference;
 import io.weaviate.client6.v1.api.collections.data.DeleteManyResponse;
 import io.weaviate.client6.v1.api.collections.data.Reference;
 import io.weaviate.client6.v1.api.collections.query.Metadata;
 import io.weaviate.client6.v1.api.collections.query.Metadata.MetadataField;
 import io.weaviate.client6.v1.api.collections.query.QueryMetadata;
 import io.weaviate.client6.v1.api.collections.query.QueryReference;
+import io.weaviate.client6.v1.api.collections.query.QueryWeaviateObject;
 import io.weaviate.client6.v1.api.collections.query.Where;
 import io.weaviate.containers.Container;
 
@@ -99,11 +99,11 @@ public void testBlobData() throws IOException {
         "breed", "ragdoll",
         "img", ragdollPng));
 
-    var got = cats.query.byId(ragdoll.metadata().uuid(),
+    var got = cats.query.byId(ragdoll.uuid(),
         cat -> cat.returnProperties("img"));
 
     Assertions.assertThat(got).get()
-        .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP)
+        .extracting(QueryWeaviateObject::properties, InstanceOfAssertFactories.MAP)
         .extractingByKey("img").isEqualTo(ragdollPng);
   }
 
@@ -140,59 +140,59 @@ public void testReferences_AddReplaceDelete() throws IOException {
 
     // Act: add reference
     persons.data.referenceAdd(
-        john.metadata().uuid(),
+        john.uuid(),
         "hasFriend",
         Reference.object(albie));
 
     // Assert
-    var johnWithFriends = persons.query.byId(john.metadata().uuid(),
+    var johnWithFriends = persons.query.byId(john.uuid(),
         query -> query.returnReferences(
             QueryReference.single("hasFriend",
                 friend -> friend.returnProperties("name"))));
 
     Assertions.assertThat(johnWithFriends).get()
         .as("friends after ADD")
-        .extracting(WeaviateObject::references).extracting("hasFriend")
-        .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class))
+        .extracting(QueryWeaviateObject::references).extracting("hasFriend")
+        .asInstanceOf(InstanceOfAssertFactories.list(QueryWeaviateObject.class))
         .hasSize(1)
-        .first().extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP)
+        .first().extracting(QueryWeaviateObject::properties, InstanceOfAssertFactories.MAP)
         .returns("albie", friend -> friend.get("name"));
 
     // Act: replace reference
     var barbara = persons.data.insert(Map.of("name", "barbara"));
     persons.data.referenceReplace(
-        john.metadata().uuid(),
+        john.uuid(),
         "hasFriend",
         Reference.object(barbara));
 
-    johnWithFriends = persons.query.byId(john.metadata().uuid(),
+    johnWithFriends = persons.query.byId(john.uuid(),
         query -> query.returnReferences(
             QueryReference.single("hasFriend",
                 friend -> friend.returnProperties("name"))));
 
     Assertions.assertThat(johnWithFriends).get()
         .as("friends after REPLACE")
-        .extracting(WeaviateObject::references).extracting("hasFriend")
-        .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class))
+        .extracting(QueryWeaviateObject::references).extracting("hasFriend")
+        .asInstanceOf(InstanceOfAssertFactories.list(QueryWeaviateObject.class))
         .hasSize(1)
-        .first().extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP)
+        .first().extracting(QueryWeaviateObject::properties, InstanceOfAssertFactories.MAP)
         .returns("barbara", friend -> friend.get("name"));
 
     // Act: delete reference
     persons.data.referenceDelete(
-        john.metadata().uuid(),
+        john.uuid(),
         "hasFriend",
         Reference.object(barbara));
 
     // Assert
-    johnWithFriends = persons.query.byId(john.metadata().uuid(),
+    johnWithFriends = persons.query.byId(john.uuid(),
         query -> query.returnReferences(
             QueryReference.single("hasFriend")));
 
     Assertions.assertThat(johnWithFriends).get()
         .as("friends after DELETE")
-        .extracting(WeaviateObject::references).extracting("hasFriend")
-        .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class))
+        .extracting(QueryWeaviateObject::references).extracting("hasFriend")
+        .asInstanceOf(InstanceOfAssertFactories.list(QueryWeaviateObject.class))
         .isEmpty();
   }
 
@@ -210,15 +210,15 @@ public void testReplace() throws IOException {
     var ivanhoe = books.data.insert(Map.of("title", "ivanhoe"));
 
     // Act
-    books.data.replace(ivanhoe.metadata().uuid(),
+    books.data.replace(ivanhoe.uuid(),
         replace -> replace.properties(Map.of("year", 1819)));
 
     // Assert
-    var replacedIvanhoe = books.query.byId(ivanhoe.metadata().uuid());
+    var replacedIvanhoe = books.query.byId(ivanhoe.uuid());
 
     Assertions.assertThat(replacedIvanhoe).get()
         .as("has ONLY year property")
-        .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP)
+        .extracting(QueryWeaviateObject::properties, InstanceOfAssertFactories.MAP)
         .doesNotContain(Map.entry("title", "ivanhoe"))
         .contains(Map.entry("year", 1819L));
   }
@@ -251,15 +251,15 @@ public void testUpdate() throws IOException {
     var ivanhoe = books.data.insert(Map.of("title", "ivanhoe"));
 
     // Act
-    books.data.update(ivanhoe.metadata().uuid(),
+    books.data.update(ivanhoe.uuid(),
         update -> update
             .properties(Map.of("year", 1819))
             .reference("writtenBy", Reference.objects(walter))
             .vectors(Vectors.of(vector)));
 
     // Assert
     var updIvanhoe = books.query.byId(
-        ivanhoe.metadata().uuid(),
+        ivanhoe.uuid(),
         query -> query
             .includeVector()
             .returnReferences(QueryReference.single("writtenBy")));
@@ -268,20 +268,20 @@ public void testUpdate() throws IOException {
         .satisfies(book -> {
           Assertions.assertThat(book)
               .as("has both year and title property")
-              .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP)
+              .extracting(QueryWeaviateObject::properties, InstanceOfAssertFactories.MAP)
               .contains(Map.entry("title", "ivanhoe"), Map.entry("year", 1819L));
 
           Assertions.assertThat(book)
               .as("has reference to Authors")
-              .extracting(WeaviateObject::references, InstanceOfAssertFactories.MAP)
-              .extractingByKey("writtenBy", InstanceOfAssertFactories.list(WeaviateObject.class))
+              .extracting(QueryWeaviateObject::references, InstanceOfAssertFactories.MAP)
+              .extractingByKey("writtenBy", InstanceOfAssertFactories.list(QueryWeaviateObject.class))
               .first()
-              .extracting(WeaviateObject::properties, InstanceOfAssertFactories.MAP)
+              .extracting(QueryWeaviateObject::properties, InstanceOfAssertFactories.MAP)
               .contains(Map.entry("name", "walter scott"));
 
           Assertions.assertThat(book)
               .as("has a vector")
-              .extracting(WeaviateObject::metadata)
+              .extracting(QueryWeaviateObject::metadata)
               .extracting(QueryMetadata::vectors)
               .returns(vector, Vectors::getDefaultSingle);
         });
@@ -298,8 +298,8 @@ public void testDeleteMany() throws IOException {
 
     var things = client.collections.use(nsThings);
     things.data.insert(Map.of("last_used", 1));
-    var delete_1 = things.data.insert(Map.of("last_used", 5)).metadata().uuid();
-    var delete_2 = things.data.insert(Map.of("last_used", 9)).metadata().uuid();
+    var delete_1 = things.data.insert(Map.of("last_used", 5)).uuid();
+    var delete_2 = things.data.insert(Map.of("last_used", 9)).uuid();
 
     // Act (dry run)
     things.data.deleteMany(
@@ -387,15 +387,16 @@ public void testReferenceAddMany() throws IOException {
     // Assert
     Assertions.assertThat(response.errors()).isEmpty();
 
-    var goodburgAirports = cities.query.byId(goodburg.metadata().uuid(),
+    var goodburgAirports = cities.query.byId(goodburg.uuid(),
         city -> city.returnReferences(
             QueryReference.single("hasAirports")));
 
     Assertions.assertThat(goodburgAirports).get()
         .as("Goodburg has 3 airports")
-        .extracting(WeaviateObject::references)
-        .extracting(references -> references.get("hasAirports"), InstanceOfAssertFactories.list(WeaviateObject.class))
-        .extracting(WeaviateObject::uuid)
+        .extracting(QueryWeaviateObject::references)
+        .extracting(references -> references.get("hasAirports"),
+            InstanceOfAssertFactories.list(QueryWeaviateObject.class))
+        .extracting(QueryWeaviateObject::uuid)
         .contains(alpha, bravo, charlie);
   }
 
@@ -473,7 +474,7 @@ public void testDataTypes() throws IOException {
 
     // Assert
     Assertions.assertThat(got).get()
-        .extracting(WeaviateObject::properties)
+        .extracting(QueryWeaviateObject::properties)
         .asInstanceOf(InstanceOfAssertFactories.map(String.class, Object.class))
         // Most of PhoneNumber fields are only present on read and are null on write.
         .usingRecursiveComparison()

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

@@ -17,10 +17,10 @@
 import io.weaviate.client6.v1.api.collections.CollectionConfig;
 import io.weaviate.client6.v1.api.collections.GeoCoordinates;
 import io.weaviate.client6.v1.api.collections.PhoneNumber;
-import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.api.collections.annotations.Collection;
 import io.weaviate.client6.v1.api.collections.annotations.Property;
 import io.weaviate.client6.v1.api.collections.data.InsertManyResponse.InsertObject;
+import io.weaviate.client6.v1.api.collections.query.QueryWeaviateObject;
 import io.weaviate.client6.v1.api.collections.query.Where;
 import io.weaviate.containers.Container;
 
@@ -358,7 +358,7 @@ public void test_partialScan() throws IOException {
 
     // Assert
     Assertions.assertThat(got).get()
-        .extracting(WeaviateObject::properties)
+        .extracting(QueryWeaviateObject::properties)
         .returns("Dystopia", Song::title)
         .returns(null, Song::album)
         .returns(0, Song::year)

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

@@ -18,10 +18,10 @@
 import io.weaviate.client6.v1.api.WeaviateClient;
 import io.weaviate.client6.v1.api.WeaviateException;
 import io.weaviate.client6.v1.api.collections.Property;
-import io.weaviate.client6.v1.api.collections.WeaviateMetadata;
-import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.api.collections.pagination.PaginationException;
 import io.weaviate.client6.v1.api.collections.query.Metadata;
+import io.weaviate.client6.v1.api.collections.query.QueryMetadata;
+import io.weaviate.client6.v1.api.collections.query.QueryWeaviateObject;
 import io.weaviate.containers.Container;
 
 public class PaginationITest extends ConcurrentTest {
@@ -39,15 +39,15 @@ public void testIterateAll() throws IOException {
     var inserted = new ArrayList<String>();
     for (var i = 0; i < count; i++) {
       var object = things.data.insert(Collections.emptyMap());
-      inserted.add(object.metadata().uuid());
+      inserted.add(object.uuid());
     }
     assumeTrue("all objects were inserted", inserted.size() == count);
 
     var allThings = things.paginate();
 
     // Act: stream
     var gotStream = allThings.stream()
-        .map(WeaviateObject::metadata).map(WeaviateMetadata::uuid).toList();
+        .map(QueryWeaviateObject::metadata).map(QueryMetadata::uuid).toList();
 
     // Assert
     Assertions.assertThat(gotStream)
@@ -84,7 +84,7 @@ public void testResumePagination() throws IOException {
     var inserted = new ArrayList<String>();
     for (var i = 0; i < count; i++) {
       var object = things.data.insert(Collections.emptyMap());
-      inserted.add(object.metadata().uuid());
+      inserted.add(object.uuid());
     }
 
     // Iterate over first 5 objects
@@ -114,7 +114,7 @@ public void testWithQueryOptions() throws IOException {
     var inserted = new ArrayList<String>();
     for (var i = 0; i < count; i++) {
       var object = things.data.insert(Collections.emptyMap());
-      inserted.add(object.metadata().uuid());
+      inserted.add(object.uuid());
     }
 
     // Act / Assert

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

@@ -11,12 +11,11 @@
 
 import io.weaviate.ConcurrentTest;
 import io.weaviate.client6.v1.api.WeaviateClient;
-import io.weaviate.client6.v1.api.collections.ObjectMetadata;
 import io.weaviate.client6.v1.api.collections.Property;
 import io.weaviate.client6.v1.api.collections.ReferenceProperty;
-import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.api.collections.data.Reference;
 import io.weaviate.client6.v1.api.collections.query.QueryReference;
+import io.weaviate.client6.v1.api.collections.query.QueryWeaviateObject;
 import io.weaviate.containers.Container;
 
 /**
@@ -74,7 +73,7 @@ public void testReferences() throws IOException {
         Map.of("name", "Alex"),
         opt -> opt
             .reference("hasAwards", Reference.uuids(
-                grammy_1.metadata().uuid(), oscar_1.metadata().uuid()))
+                grammy_1.uuid(), oscar_1.uuid()))
             .reference("hasAwards", Reference.objects(grammy_2, oscar_2)));
 
     // Act: add one more reference
@@ -91,28 +90,28 @@ public void testReferences() throws IOException {
         .extracting(ReferenceProperty::dataTypes, InstanceOfAssertFactories.list(String.class))
         .containsOnly(nsMovies);
 
-    var gotAlex = artists.query.byId(alex.metadata().uuid(),
+    var gotAlex = artists.query.byId(alex.uuid(),
         opt -> opt.returnReferences(
             QueryReference.multi("hasAwards", nsOscar),
             QueryReference.multi("hasAwards", nsGrammy)));
 
     Assertions.assertThat(gotAlex).get()
         .as("Artists: fetch by id including hasAwards references")
 
-        // Cast references to Map<String, List<WeaviateObject>>
-        .extracting(WeaviateObject::references, InstanceOfAssertFactories.map(String.class, List.class))
+        // Cast references to Map<String, List<QueryWeaviateObject>>
+        .extracting(QueryWeaviateObject::references, InstanceOfAssertFactories.map(String.class, List.class))
         .as("hasAwards object reference").extractingByKey("hasAwards")
-        .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class))
+        .asInstanceOf(InstanceOfAssertFactories.list(QueryWeaviateObject.class))
 
-        .extracting(object -> ((ObjectMetadata) object.metadata()).uuid())
+        .extracting(object -> object.uuid())
         .containsOnly(
             // INVESTIGATE: When references to 2+ collections are requested,
             // seems to Weaviate only return references to the first one in the list.
             // In this case we request { "hasAwards": Oscars } and { "hasAwards": Grammys }
             // so the latter will not be in the response.
             //
             // grammy_1.metadata().id(), grammy_2.metadata().id(),
-            oscar_1.metadata().uuid(), oscar_2.metadata().uuid());
+            oscar_1.uuid(), oscar_2.uuid());
   }
 
   @Test
@@ -155,7 +154,7 @@ public void testNestedReferences() throws IOException {
             .reference("hasAwards", Reference.objects(grammy_1)));
 
     // Assert: fetch nested references
-    var gotAlex = artists.query.byId(alex.metadata().uuid(),
+    var gotAlex = artists.query.byId(alex.uuid(),
         opt -> opt.returnReferences(
             QueryReference.single("hasAwards",
                 ref -> ref
@@ -166,20 +165,20 @@ public void testNestedReferences() throws IOException {
     Assertions.assertThat(gotAlex).get()
         .as("Artists: fetch by id including nested references")
 
-        // Cast references to Map<String, List<WeaviateObject>>
-        .extracting(WeaviateObject::references, InstanceOfAssertFactories.map(String.class, List.class))
+        // Cast references to Map<String, List<QueryWeaviateObject>>
+        .extracting(QueryWeaviateObject::references, InstanceOfAssertFactories.map(String.class, List.class))
         .as("hasAwards object reference").extractingByKey("hasAwards")
-        .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class))
+        .asInstanceOf(InstanceOfAssertFactories.list(QueryWeaviateObject.class))
 
         .hasSize(1).allSatisfy(award -> Assertions.assertThat(award)
-            .returns(grammy_1.metadata().uuid(), grammy -> ((ObjectMetadata) grammy.metadata()).uuid())
+            .returns(grammy_1.uuid(), grammy -> grammy.uuid())
 
-            // Cast references to Map<String, List<WeaviateObject>>
-            .extracting(WeaviateObject::references, InstanceOfAssertFactories.map(String.class, List.class))
+            // Cast references to Map<String, List<QueryWeaviateObject>>
+            .extracting(QueryWeaviateObject::references, InstanceOfAssertFactories.map(String.class, List.class))
             .as("presentedBy object reference").extractingByKey("presentedBy")
-            .asInstanceOf(InstanceOfAssertFactories.list(WeaviateObject.class))
+            .asInstanceOf(InstanceOfAssertFactories.list(QueryWeaviateObject.class))
 
-            .hasSize(1).extracting(WeaviateObject::properties)
+            .hasSize(1).extracting(QueryWeaviateObject::properties)
             .allSatisfy(properties -> Assertions.assertThat(properties)
                 .asInstanceOf(InstanceOfAssertFactories.map(String.class, Object.class))
                 .containsEntry("ceo", "Harvy Mason")));