Add item ordering in record value mapper

Author: adrienmaillard

contrib/src/main/java/gov/nasa/jpl/aerie/contrib/serialization/mappers/RecordValueMapper.java

@@ -8,6 +8,7 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.RecordComponent;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -36,11 +37,15 @@ public record Component<R, T>(
   @Override
   public ValueSchema getValueSchema() {
     final var valueSchemas = new HashMap<String, ValueSchema>();
+    final var metadata = new ArrayList<SerializedValue>();
     for (final var component : this.components) {
+      metadata.add(SerializedValue.of(component.name));
       valueSchemas.put(component.name,
                        component.mapper.getValueSchema());
     }
-    return ValueSchema.ofStruct(valueSchemas);
+    return components.isEmpty() ?
+        ValueSchema.ofStruct(valueSchemas) :
+        ValueSchema.withMeta("item_order", SerializedValue.of(metadata), ValueSchema.ofStruct(valueSchemas));
   }
 
   @Override

contrib/src/test/java/gov/nasa/jpl/aerie/contrib/serialization/mappers/RecordValueMapperTest.java

@@ -16,6 +16,7 @@ record EmptyRecord() {}
   record StringRecord(String aString) {}
 
   record MultiValueRecord(String aString, Map<String, List<Boolean>> fancy) {}
+  record NestedMultiValueRecord(String aString, Map<String, List<Boolean>> fancy, MultiValueRecord record) {}
 
   @Test
   void getValueSchema_emptyRecord() {
@@ -32,12 +33,16 @@ void getValueSchema_stringRecord() {
             StringRecord::aString,
             new StringValueMapper()
         ))).getValueSchema();
-    assertEquals(ValueSchema.ofStruct(Map.of("aString", ValueSchema.STRING)), valueSchema);
+    assertEquals(ValueSchema.withMeta(
+        "item_order",
+        SerializedValue.of(List.of(SerializedValue.of("aString"))),
+        ValueSchema.ofStruct(Map.of("aString", ValueSchema.STRING))),
+                 valueSchema);
+
   }
 
-  @Test
-  void getValueSchema_multiValueRecord() {
-    final var valueSchema = new RecordValueMapper<>(
+  final RecordValueMapper<MultiValueRecord> getMultiValueRecordValueSchema() {
+    return new RecordValueMapper<>(
         MultiValueRecord.class,
         List.of(
             new RecordValueMapper.Component<>(
@@ -49,15 +54,65 @@ void getValueSchema_multiValueRecord() {
                 "fancy",
                 MultiValueRecord::fancy,
                 new MapValueMapper<>(new StringValueMapper(), new ListValueMapper<>(new BooleanValueMapper()))
+            )));
+  }
+
+  @Test
+  void getValueSchema_multiValueRecord() {
+    final var valueSchema = getMultiValueRecordValueSchema();
+    assertEquals(
+        ValueSchema.withMeta(
+            "item_order",
+            SerializedValue.of(List.of(SerializedValue.of("aString"), SerializedValue.of("fancy"))),
+            ValueSchema.ofStruct(Map.of(
+                "aString", ValueSchema.STRING,
+                "fancy", ValueSchema.ofSeries(ValueSchema.ofStruct(Map.of(
+                    "key", ValueSchema.STRING,
+                    "value", ValueSchema.ofSeries(ValueSchema.BOOLEAN))))))),
+        valueSchema);
+  }
+
+  @Test
+  void getValueSchema_nested() {
+    final var valueSchema = new RecordValueMapper<>(
+        NestedMultiValueRecord.class,
+        List.of(
+            new RecordValueMapper.Component<>(
+                "aString",
+                NestedMultiValueRecord::aString,
+                new StringValueMapper()
+            ),
+            new RecordValueMapper.Component<>(
+                "fancy",
+                NestedMultiValueRecord::fancy,
+                new MapValueMapper<>(new StringValueMapper(), new ListValueMapper<>(new BooleanValueMapper()))
+            ),
+            new RecordValueMapper.Component<>(
+                "record",
+                NestedMultiValueRecord::record,
+                getMultiValueRecordValueSchema()
             ))).getValueSchema();
-    assertEquals(ValueSchema.ofStruct(Map.of(
-        "aString", ValueSchema.STRING,
-        "fancy", ValueSchema.ofSeries(
+    assertEquals(
+        ValueSchema.withMeta(
+            "item_order",
+            SerializedValue.of(List.of(
+                SerializedValue.of("aString"),
+                SerializedValue.of("fancy"),
+                SerializedValue.of("record"))),
             ValueSchema.ofStruct(Map.of(
-                "key", ValueSchema.STRING,
-                "value", ValueSchema.ofSeries(ValueSchema.BOOLEAN)
-            ))
-        ))), valueSchema);
+                "aString", ValueSchema.STRING,
+                "fancy", ValueSchema.ofSeries(ValueSchema.ofStruct(Map.of(
+                    "key", ValueSchema.STRING,
+                    "value", ValueSchema.ofSeries(ValueSchema.BOOLEAN)))),
+                "record", ValueSchema.withMeta(
+                    "item_order",
+                    SerializedValue.of(List.of(SerializedValue.of("aString"), SerializedValue.of("fancy"))),
+                    ValueSchema.ofStruct(Map.of(
+                        "aString", ValueSchema.STRING,
+                        "fancy", ValueSchema.ofSeries(ValueSchema.ofStruct(Map.of(
+                            "key", ValueSchema.STRING,
+                            "value", ValueSchema.ofSeries(ValueSchema.BOOLEAN)))))))))),
+        valueSchema);
   }
 
   @Test