feat: GsonJsonMapper implements TypedTypeMapper and round-trips JSR-310

Author: thced

README.md

@@ -44,7 +44,8 @@ public class PostDataHandler implements RequestHandler {
     byte[] body = request.bytes();
     // Loose structural view (Map / List / boxed primitives), produced by the registered TypeMapper.
     Object parsed = request.parsed();
-    // Or, when the JSON mapper is Jackson (a TypedTypeMapper), get a typed POJO directly.
+    // Or get a typed POJO directly (works with the Gson and Jackson built-ins; both implement
+    // TypedTypeMapper).
     MyDto dto = request.asPojo(MyDto.class);
     // Path parameters, query parameters, and headers are also available.
     String id = request.pathParam("id");
@@ -117,8 +118,9 @@ public class YourServerLauncher {
 
 The library ships an internal `GsonJsonMapper` that is auto-registered for `application/json` when Gson is on the classpath and no user-supplied JSON mapper has been registered. It:
 
-- Returns JSON integers as `Long` and fractional numbers as `Double`.
-- Writes JSR-310 types (`Instant`, `OffsetDateTime`, `ZonedDateTime`, `LocalDateTime`, `LocalDate`, `LocalTime`) as ISO-8601 strings.
+- Returns JSON integers as `Long` and fractional numbers as `Double` for the loose `request.parsed()` view.
+- For `request.asPojo(MyDto.class)`, delegates to Gson — the target type's fields determine the Java types (`int`, `long`, `Instant`, etc.).
+- Round-trips JSR-310 types (`Instant`, `OffsetDateTime`, `ZonedDateTime`, `LocalDateTime`, `LocalDate`, `LocalTime`) as their ISO-8601 string form.
 
 For Jackson, the library ships a `JacksonJsonTypeMapper` adapter that wraps an `ObjectMapper` you configure (modules, naming strategy, JSR-310, date formats — all your call):
 

src/main/java/com/retailsvc/http/internal/gson/GsonJsonMapper.java

@@ -10,8 +10,9 @@
 import com.google.gson.JsonPrimitive;
 import com.google.gson.TypeAdapter;
 import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
 import com.google.gson.stream.JsonWriter;
-import com.retailsvc.http.TypeMapper;
+import com.retailsvc.http.TypedTypeMapper;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.time.Instant;
@@ -27,28 +28,36 @@
 import java.util.function.Function;
 
 /**
- * Built-in {@link TypeMapper} for {@code application/json} backed by Gson. Auto-registered by
+ * Built-in {@link TypedTypeMapper} for {@code application/json} backed by Gson. Auto-registered by
  * {@link com.retailsvc.http.OpenApiServer.Builder} when Gson is on the classpath and no
  * user-supplied JSON mapper has been registered.
  *
- * <p>JSON numbers without a decimal point or exponent are returned as {@code Long}; fractional
- * numbers are returned as {@code Double}. JSR-310 types ({@code Instant}, {@code OffsetDateTime},
- * {@code ZonedDateTime}, {@code LocalDateTime}, {@code LocalDate}, {@code LocalTime}) are written
- * as their ISO-8601 string form.
+ * <p>The loose {@link #readFrom(byte[], String)} path returns JSON numbers without a decimal point
+ * or exponent as {@code Long} and fractional numbers as {@code Double}. The typed {@link
+ * #readAs(byte[], String, Class)} path delegates to Gson, so target-type fields determine the
+ * resulting Java types (an {@code int} field gets an {@code int}, an {@code Instant} field gets an
+ * {@code Instant}, etc.).
+ *
+ * <p>JSR-310 types ({@code Instant}, {@code OffsetDateTime}, {@code ZonedDateTime}, {@code
+ * LocalDateTime}, {@code LocalDate}, {@code LocalTime}) are round-tripped as their ISO-8601 string
+ * form.
  */
-public final class GsonJsonMapper implements TypeMapper {
+public final class GsonJsonMapper implements TypedTypeMapper {
 
   private final Gson gson;
 
   public GsonJsonMapper() {
     this.gson =
         new GsonBuilder()
-            .registerTypeAdapter(Instant.class, isoStringWriter(Instant::toString))
-            .registerTypeAdapter(OffsetDateTime.class, isoStringWriter(OffsetDateTime::toString))
-            .registerTypeAdapter(ZonedDateTime.class, isoStringWriter(ZonedDateTime::toString))
-            .registerTypeAdapter(LocalDateTime.class, isoStringWriter(LocalDateTime::toString))
-            .registerTypeAdapter(LocalDate.class, isoStringWriter(LocalDate::toString))
-            .registerTypeAdapter(LocalTime.class, isoStringWriter(LocalTime::toString))
+            .registerTypeAdapter(Instant.class, iso(Instant::toString, Instant::parse))
+            .registerTypeAdapter(
+                OffsetDateTime.class, iso(OffsetDateTime::toString, OffsetDateTime::parse))
+            .registerTypeAdapter(
+                ZonedDateTime.class, iso(ZonedDateTime::toString, ZonedDateTime::parse))
+            .registerTypeAdapter(
+                LocalDateTime.class, iso(LocalDateTime::toString, LocalDateTime::parse))
+            .registerTypeAdapter(LocalDate.class, iso(LocalDate::toString, LocalDate::parse))
+            .registerTypeAdapter(LocalTime.class, iso(LocalTime::toString, LocalTime::parse))
             .create();
   }
 
@@ -58,6 +67,11 @@ public Object readFrom(byte[] body, String contentTypeHeader) {
     return toJavaObject(element);
   }
 
+  @Override
+  public <T> T readAs(byte[] body, String contentTypeHeader, Class<T> type) {
+    return gson.fromJson(new String(body, StandardCharsets.UTF_8), type);
+  }
+
   @Override
   public byte[] writeTo(Object value) {
     return gson.toJson(value).getBytes(StandardCharsets.UTF_8);
@@ -120,7 +134,8 @@ private static Object toNumber(String raw) {
     return Double.parseDouble(raw);
   }
 
-  private static <T> TypeAdapter<T> isoStringWriter(Function<T, String> toIso) {
+  /** Round-trips a JSR-310 type as an ISO-8601 string. */
+  private static <T> TypeAdapter<T> iso(Function<T, String> toIso, Function<String, T> fromIso) {
     return new TypeAdapter<T>() {
       @Override
       public void write(JsonWriter out, T value) throws IOException {
@@ -132,9 +147,12 @@ public void write(JsonWriter out, T value) throws IOException {
       }
 
       @Override
-      public T read(JsonReader in) {
-        throw new UnsupportedOperationException(
-            "GsonJsonMapper does not parse JSR-310 types; values arrive as String");
+      public T read(JsonReader in) throws IOException {
+        if (in.peek() == JsonToken.NULL) {
+          in.nextNull();
+          return null;
+        }
+        return fromIso.apply(in.nextString());
       }
     };
   }

src/test/java/com/retailsvc/http/internal/gson/GsonJsonMapperTest.java

@@ -98,6 +98,36 @@ void writesLocalTimeAsIso8601() {
         .isEqualTo("{\"t\":\"10:00\"}");
   }
 
+  @Test
+  void readAsDeserialisesPojo() {
+    Item item = mapper.readAs(bytes("{\"id\":\"x-1\",\"qty\":7}"), "application/json", Item.class);
+
+    assertThat(item.id).isEqualTo("x-1");
+    assertThat(item.qty).isEqualTo(7);
+  }
+
+  @Test
+  void readAsRoundTripsJsr310Fields() {
+    WithDates value =
+        mapper.readAs(
+            bytes("{\"ts\":\"2026-05-13T10:00:00Z\",\"day\":\"2026-05-13\"}"),
+            "application/json",
+            WithDates.class);
+
+    assertThat(value.ts).isEqualTo(Instant.parse("2026-05-13T10:00:00Z"));
+    assertThat(value.day).isEqualTo(LocalDate.of(2026, 5, 13));
+  }
+
+  static final class Item {
+    String id;
+    int qty;
+  }
+
+  static final class WithDates {
+    Instant ts;
+    LocalDate day;
+  }
+
   private static byte[] bytes(String s) {
     return s.getBytes(StandardCharsets.UTF_8);
   }