feat: Add JacksonJsonTypeMapper adapter for ObjectMapper-backed JSON mapping

Author: thced

README.md

@@ -24,7 +24,8 @@ It is designed to be simple to use while providing the essential features needed
 - An OpenAPI 3.1.x specification (`openapi.json` or `openapi.yaml`).
 - For `application/json` request/response bodies, either:
   - Gson on the classpath — auto-registered via the built-in `GsonJsonMapper` (integer-preserving, JSR-310 written as ISO-8601), or
-  - a user-supplied `TypeMapper` registered via `Builder.bodyMapper("application/json", mapper)` (e.g. backed by Jackson).
+  - Jackson via the built-in `JacksonJsonTypeMapper(ObjectMapper)` adapter (caller supplies a configured `ObjectMapper`), or
+  - any other `TypeMapper` you register via `Builder.bodyMapper("application/json", mapper)`.
 - Built-in mappers for `application/x-www-form-urlencoded` and `text/plain` need no configuration. Any other media type (`application/xml`, `application/cbor`, etc.) requires registering its own `TypeMapper`.
 
 
@@ -117,17 +118,23 @@ The library ships an internal `GsonJsonMapper` that is auto-registered for `appl
 - Returns JSON integers as `Long` and fractional numbers as `Double`.
 - Writes JSR-310 types (`Instant`, `OffsetDateTime`, `ZonedDateTime`, `LocalDateTime`, `LocalDate`, `LocalTime`) as ISO-8601 strings.
 
-For non-ISO date formats, custom naming strategies, or other custom serialization, register your own `TypeMapper`:
+For Jackson, the library ships a `JacksonJsonTypeMapper` adapter that wraps an `ObjectMapper` you configure (modules, naming strategy, JSR-310, date formats — all your call):
 
 ``` java
+ObjectMapper objectMapper = new ObjectMapper()
+    .registerModule(new JavaTimeModule())
+    .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
+
 var server = OpenApiServer.builder()
     .spec(spec)
-    .bodyMapper("application/json", new MyCustomJsonMapper())
+    .bodyMapper("application/json", new JacksonJsonTypeMapper(objectMapper))
     .handlers(handlers)
     .build();
 ```
 
-If Gson is not on the classpath and no `application/json` mapper is registered, `build()` throws `IllegalStateException`.
+The same shape applies to any custom mapper — implement `TypeMapper` and register it.
+
+If neither Gson is on the classpath nor any `application/json` mapper is registered, `build()` throws `IllegalStateException`.
 
 ### Body parsers and response writers
 

pom.xml

@@ -38,6 +38,12 @@
   </dependencyManagement>
 
   <dependencies>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.21.3</version>
+      <optional>true</optional>
+    </dependency>
     <dependency>
       <groupId>com.google.code.gson</groupId>
       <artifactId>gson</artifactId>

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

@@ -0,0 +1,52 @@
+package com.retailsvc.http;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.Objects;
+
+/**
+ * {@link TypeMapper} for {@code application/json} backed by Jackson. The caller supplies a
+ * fully-configured {@link ObjectMapper}; this class never adds modules or changes settings — the
+ * mapper you pass is the mapper you get.
+ *
+ * <p>Typical wiring:
+ *
+ * <pre>{@code
+ * OpenApiServer.builder()
+ *     .spec(spec)
+ *     .bodyMapper("application/json", new JacksonJsonTypeMapper(myObjectMapper))
+ *     .handlers(handlers)
+ *     .build();
+ * }</pre>
+ *
+ * <p>Jackson is an <em>optional</em> Maven dependency of this library; consumers that use Jackson
+ * must declare {@code jackson-databind} themselves. Consumers that use Gson can rely on the
+ * built-in {@code GsonJsonMapper} auto-fallback instead.
+ */
+public final class JacksonJsonTypeMapper implements TypeMapper {
+
+  private final ObjectMapper mapper;
+
+  public JacksonJsonTypeMapper(ObjectMapper mapper) {
+    this.mapper = Objects.requireNonNull(mapper, "mapper must not be null");
+  }
+
+  @Override
+  public Object readFrom(byte[] body, String contentTypeHeader) {
+    try {
+      return mapper.readValue(body, Object.class);
+    } catch (IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  @Override
+  public byte[] writeTo(Object value) {
+    try {
+      return mapper.writeValueAsBytes(value);
+    } catch (IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+}

src/test/java/com/retailsvc/http/JacksonJsonTypeMapperTest.java

@@ -0,0 +1,50 @@
+package com.retailsvc.http;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+
+class JacksonJsonTypeMapperTest {
+
+  private final JacksonJsonTypeMapper mapper = new JacksonJsonTypeMapper(new ObjectMapper());
+
+  @Test
+  void readsJsonObjectAsMap() {
+    byte[] body = "{\"n\":42,\"s\":\"hi\",\"a\":[1,2]}".getBytes(StandardCharsets.UTF_8);
+
+    Object parsed = mapper.readFrom(body, "application/json");
+
+    assertThat(parsed).isInstanceOf(Map.class);
+    @SuppressWarnings("unchecked")
+    Map<String, Object> m = (Map<String, Object>) parsed;
+    assertThat(m).containsEntry("n", 42).containsEntry("s", "hi").containsEntry("a", List.of(1, 2));
+  }
+
+  @Test
+  void writesMapAsJson() {
+    byte[] out = mapper.writeTo(Map.of("k", "v"));
+
+    assertThat(new String(out, StandardCharsets.UTF_8)).isEqualTo("{\"k\":\"v\"}");
+  }
+
+  @Test
+  void wrapsReadFailureAsUncheckedIOException() {
+    byte[] malformed = "not json".getBytes(StandardCharsets.UTF_8);
+
+    assertThatThrownBy(() -> mapper.readFrom(malformed, "application/json"))
+        .isInstanceOf(UncheckedIOException.class);
+  }
+
+  @Test
+  void rejectsNullObjectMapper() {
+    assertThatThrownBy(() -> new JacksonJsonTypeMapper(null))
+        .isInstanceOf(NullPointerException.class)
+        .hasMessageContaining("mapper");
+  }
+}

src/test/java/com/retailsvc/http/ResponseTest.java

@@ -0,0 +1,74 @@
+package com.retailsvc.http;
+
+import static java.net.HttpURLConnection.HTTP_ACCEPTED;
+import static java.net.HttpURLConnection.HTTP_CREATED;
+import static java.net.HttpURLConnection.HTTP_NOT_FOUND;
+import static java.net.HttpURLConnection.HTTP_NOT_IMPLEMENTED;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+
+class ResponseTest {
+
+  @Test
+  void acceptedNoBody() {
+    Response r = Response.accepted();
+
+    assertThat(r.status()).isEqualTo(HTTP_ACCEPTED);
+    assertThat(r.body()).isNull();
+    assertThat(r.headers()).isEmpty();
+  }
+
+  @Test
+  void acceptedWithBody() {
+    Map<String, String> job = Map.of("id", "job-42");
+    Response r = Response.accepted(job);
+
+    assertThat(r.status()).isEqualTo(HTTP_ACCEPTED);
+    assertThat(r.body()).isEqualTo(job);
+  }
+
+  @Test
+  void createdWithBody() {
+    Map<String, String> resource = Map.of("id", "x-1");
+    Response r = Response.created(resource);
+
+    assertThat(r.status()).isEqualTo(HTTP_CREATED);
+    assertThat(r.body()).isEqualTo(resource);
+    assertThat(r.headers()).isEmpty();
+  }
+
+  @Test
+  void createdWithLocation() {
+    Response r = Response.created(Map.of("id", "x-1"), "/things/x-1");
+
+    assertThat(r.status()).isEqualTo(HTTP_CREATED);
+    assertThat(r.headers()).containsEntry("Location", "/things/x-1");
+  }
+
+  @Test
+  void notFoundNoBody() {
+    Response r = Response.notFound();
+
+    assertThat(r.status()).isEqualTo(HTTP_NOT_FOUND);
+    assertThat(r.body()).isNull();
+  }
+
+  @Test
+  void notFoundWithBody() {
+    Map<String, String> problem = Map.of("title", "Missing");
+    Response r = Response.notFound(problem);
+
+    assertThat(r.status()).isEqualTo(HTTP_NOT_FOUND);
+    assertThat(r.body()).isEqualTo(problem);
+  }
+
+  @Test
+  void notImplementedNoBody() {
+    Response r = Response.notImplemented();
+
+    assertThat(r.status()).isEqualTo(HTTP_NOT_IMPLEMENTED);
+    assertThat(r.body()).isNull();
+  }
+}