feat!: Replace JsonMapper with bodyMapper(mediaType, TypeMapper) + Gson fallback

Author: thced

src/main/java/com/retailsvc/http/JsonMapper.java

@@ -6,8 +6,10 @@
 
 import com.retailsvc.http.internal.DispatchHandler;
 import com.retailsvc.http.internal.ExceptionFilter;
+import com.retailsvc.http.internal.FormTypeMapper;
 import com.retailsvc.http.internal.RequestPreparationFilter;
 import com.retailsvc.http.internal.Router;
+import com.retailsvc.http.internal.TextTypeMapper;
 import com.retailsvc.http.spec.Spec;
 import com.retailsvc.http.validate.DefaultValidator;
 import com.sun.net.httpserver.HttpContext;
@@ -30,47 +32,16 @@ public class OpenApiServer implements AutoCloseable {
 
   private static final Logger LOG = LoggerFactory.getLogger(OpenApiServer.class);
   private static final int DEFAULT_PORT = 8080;
+  private static final String JSON = "application/json";
+  private static final String GSON_CLASS = "com.google.gson.Gson";
+  private static final String GSON_MAPPER_CLASS = "com.retailsvc.http.internal.gson.GsonJsonMapper";
 
   private final HttpServer httpServer;
   private final int shutdownTimeoutSeconds;
 
-  /**
-   * @param spec The parsed {@link Spec}
-   * @param jsonMapper Body deserializer
-   * @param handlers Mappings between operationId and {@link HttpHandler}
-   * @param exceptionHandler Error handler receiving exceptions thrown from a handler
-   * @throws IOException If an error occurs during server start
-   */
-  public OpenApiServer(
-      Spec spec,
-      JsonMapper jsonMapper,
-      Map<String, HttpHandler> handlers,
-      ExceptionHandler exceptionHandler)
-      throws IOException {
-    this(spec, jsonMapper, handlers, exceptionHandler, DEFAULT_PORT, Map.of(), 0);
-  }
-
-  /**
-   * @param spec The parsed {@link Spec}
-   * @param jsonMapper Body deserializer
-   * @param handlers Mappings between operationId and {@link HttpHandler}
-   * @param exceptionHandler Error handler receiving exceptions thrown from a handler
-   * @param port The server port to use
-   * @throws IOException If an error occurs during server start
-   */
-  public OpenApiServer(
-      Spec spec,
-      JsonMapper jsonMapper,
-      Map<String, HttpHandler> handlers,
-      ExceptionHandler exceptionHandler,
-      int port)
-      throws IOException {
-    this(spec, jsonMapper, handlers, exceptionHandler, port, Map.of(), 0);
-  }
-
   OpenApiServer(
       Spec spec,
-      JsonMapper jsonMapper,
+      Map<String, TypeMapper> bodyMappers,
       Map<String, HttpHandler> handlers,
       ExceptionHandler exceptionHandler,
       int port,
@@ -79,7 +50,7 @@ public OpenApiServer(
       throws IOException {
 
     requireNonNull(spec, "Spec must not be null");
-    requireNonNull(jsonMapper, "JsonMapper must not be null");
+    requireNonNull(bodyMappers, "bodyMappers must not be null");
     requireNonNull(handlers, "handlers must not be null");
     if (exceptionHandler == null) {
       LOG.warn("No ExceptionHandler set, using default");
@@ -95,7 +66,7 @@ public OpenApiServer(
 
     HttpContext ctx = httpServer.createContext(Optional.ofNullable(spec.basePath()).orElse("/"));
     ctx.getFilters().add(new ExceptionFilter(exceptionHandler));
-    ctx.getFilters().add(new RequestPreparationFilter(spec, router, validator, jsonMapper));
+    ctx.getFilters().add(new RequestPreparationFilter(spec, router, validator, bodyMappers));
     ctx.setHandler(new DispatchHandler(handlers));
 
     for (Map.Entry<String, HttpHandler> e : extras.entrySet()) {
@@ -144,7 +115,7 @@ public static Builder builder() {
   public static final class Builder {
 
     private Spec spec;
-    private JsonMapper jsonMapper;
+    private final LinkedHashMap<String, TypeMapper> bodyMappers = new LinkedHashMap<>();
     private Map<String, HttpHandler> handlers;
     private ExceptionHandler exceptionHandler;
     private int port = DEFAULT_PORT;
@@ -158,8 +129,10 @@ public Builder spec(Spec spec) {
       return this;
     }
 
-    public Builder jsonMapper(JsonMapper jsonMapper) {
-      this.jsonMapper = jsonMapper;
+    public Builder bodyMapper(String mediaType, TypeMapper mapper) {
+      requireNonNull(mediaType, "mediaType must not be null");
+      requireNonNull(mapper, "mapper must not be null");
+      bodyMappers.put(mediaType.toLowerCase(java.util.Locale.ROOT), mapper);
       return this;
     }
 
@@ -204,7 +177,6 @@ public Builder addHandler(String path, HttpHandler handler) {
 
     public OpenApiServer build() throws IOException {
       requireNonNull(spec, "Spec must not be null");
-      requireNonNull(jsonMapper, "JsonMapper must not be null");
       requireNonNull(handlers, "handlers must not be null");
       String basePath = Optional.ofNullable(spec.basePath()).orElse("/");
       for (String path : extras.keySet()) {
@@ -213,8 +185,43 @@ public OpenApiServer build() throws IOException {
               "extra handler path " + path + " conflicts with spec basePath " + basePath);
         }
       }
+      Map<String, TypeMapper> resolved = resolveBodyMappers(bodyMappers);
       return new OpenApiServer(
-          spec, jsonMapper, handlers, exceptionHandler, port, extras, shutdownTimeoutSeconds);
+          spec, resolved, handlers, exceptionHandler, port, extras, shutdownTimeoutSeconds);
+    }
+
+    private static Map<String, TypeMapper> resolveBodyMappers(
+        Map<String, TypeMapper> userSupplied) {
+      LinkedHashMap<String, TypeMapper> out = new LinkedHashMap<>();
+      out.put("application/x-www-form-urlencoded", new FormTypeMapper());
+      out.put("text/plain", new TextTypeMapper());
+      out.putAll(userSupplied);
+      if (!out.containsKey(JSON)) {
+        TypeMapper fallback = tryLoadGsonMapper();
+        if (fallback != null) {
+          out.put(JSON, fallback);
+        }
+      }
+      if (!out.containsKey(JSON)) {
+        throw new IllegalStateException(
+            "No TypeMapper registered for application/json and Gson not found on classpath; "
+                + "register one via Builder.bodyMapper(\"application/json\", ...)");
+      }
+      return out;
+    }
+
+    private static TypeMapper tryLoadGsonMapper() {
+      try {
+        Class.forName(GSON_CLASS, false, OpenApiServer.class.getClassLoader());
+      } catch (ClassNotFoundException _) {
+        return null;
+      }
+      try {
+        Class<?> cls = Class.forName(GSON_MAPPER_CLASS, true, OpenApiServer.class.getClassLoader());
+        return (TypeMapper) cls.getDeclaredConstructor().newInstance();
+      } catch (ReflectiveOperationException e) {
+        throw new IllegalStateException("Failed to load " + GSON_MAPPER_CLASS, e);
+      }
     }
   }
 }

src/main/java/com/retailsvc/http/OpenApiServer.java

@@ -1,9 +1,9 @@
 package com.retailsvc.http.internal;
 
-import com.retailsvc.http.JsonMapper;
 import com.retailsvc.http.MethodNotAllowedException;
 import com.retailsvc.http.NotFoundException;
 import com.retailsvc.http.Request;
+import com.retailsvc.http.TypeMapper;
 import com.retailsvc.http.ValidationException;
 import com.retailsvc.http.spec.HttpMethod;
 import com.retailsvc.http.spec.MediaType;
@@ -26,16 +26,14 @@ public final class RequestPreparationFilter extends Filter {
   private final Spec spec;
   private final Router router;
   private final Validator validator;
-  private final JsonMapper jsonMapper;
-  private final FormUrlEncodedParser formParser = new FormUrlEncodedParser();
-  private final TextPlainParser textParser = new TextPlainParser();
+  private final Map<String, TypeMapper> bodyMappers;
 
   public RequestPreparationFilter(
-      Spec spec, Router router, Validator validator, JsonMapper jsonMapper) {
+      Spec spec, Router router, Validator validator, Map<String, TypeMapper> bodyMappers) {
     this.spec = spec;
     this.router = router;
     this.validator = validator;
-    this.jsonMapper = jsonMapper;
+    this.bodyMappers = Map.copyOf(bodyMappers);
   }
 
   @Override
@@ -150,13 +148,18 @@ private Object validateAndParseBody(HttpExchange exchange, Operation op, byte[]
           new ValidationError(
               "/body", "content-type", "unsupported content type: " + mediaType, null));
     }
-    Object parsed =
-        switch (mediaType) {
-          case "application/x-www-form-urlencoded" ->
-              FormBodyCoercion.coerce(formParser.parse(body, header), mt.schema());
-          case "text/plain" -> textParser.parse(body, header);
-          default -> jsonMapper.mapFrom(body);
-        };
+    TypeMapper mapper = bodyMappers.get(mediaType);
+    if (mapper == null) {
+      throw new ValidationException(
+          new ValidationError(
+              "/body", "content-type", "unsupported content type: " + mediaType, null));
+    }
+    Object parsed = mapper.readFrom(body, header);
+    if (mediaType.equals("application/x-www-form-urlencoded") && parsed instanceof Map<?, ?> map) {
+      @SuppressWarnings("unchecked")
+      Map<String, Object> typed = (Map<String, Object>) map;
+      parsed = FormBodyCoercion.coerce(typed, mt.schema());
+    }
     validator.validate(parsed, mt.schema(), "");
     return parsed;
   }

src/main/java/com/retailsvc/http/internal/RequestPreparationFilter.java

@@ -2,10 +2,7 @@
 
 import static com.retailsvc.http.Handlers.defaultExceptionHandler;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.fail;
 
-import com.sun.net.httpserver.HttpHandler;
-import java.io.IOException;
 import java.net.URI;
 import java.net.http.HttpRequest;
 import java.net.http.HttpResponse.BodyHandlers;
@@ -19,7 +16,6 @@ void aliveExtraReturns204AndBypassesValidation() throws Exception {
     try (var s =
             OpenApiServer.builder()
                 .spec(spec)
-                .jsonMapper(jsonMapper())
                 .handlers(Map.of())
                 .exceptionHandler(defaultExceptionHandler())
                 .port(0)
@@ -44,7 +40,6 @@ void specHandlerServesClasspathResource() throws Exception {
     try (var s =
             OpenApiServer.builder()
                 .spec(spec)
-                .jsonMapper(jsonMapper())
                 .handlers(Map.of())
                 .exceptionHandler(defaultExceptionHandler())
                 .port(0)
@@ -67,15 +62,14 @@ void specHandlerServesClasspathResource() throws Exception {
 
   @Test
   void extraHandlerExceptionFlowsThroughExceptionHandler() throws Exception {
-    HttpHandler boom =
+    com.sun.net.httpserver.HttpHandler boom =
         ex -> {
           throw new RuntimeException("boom");
         };
 
     try (var s =
             OpenApiServer.builder()
                 .spec(spec)
-                .jsonMapper(jsonMapper())
                 .handlers(Map.of())
                 .exceptionHandler(defaultExceptionHandler())
                 .port(0)
@@ -93,15 +87,4 @@ void extraHandlerExceptionFlowsThroughExceptionHandler() throws Exception {
       assertThat(resp.statusCode()).isEqualTo(500);
     }
   }
-
-  @Test
-  void existingPublicConstructorStillWorks() {
-    try {
-      try (var s = new OpenApiServer(spec, jsonMapper(), Map.of(), defaultExceptionHandler(), 0)) {
-        assertThat(s.listenPort()).isGreaterThan(0);
-      }
-    } catch (IOException io) {
-      fail(io);
-    }
-  }
 }