fix: Drop TypeMapper from healthHandler and derive up from dependencies

healthHandler no longer requires a TypeMapper — the fixed wire shape is
rendered by a built-in JSON writer with proper string escaping, so the
health endpoint works without a JSON library on the classpath.

HealthOutcome's up flag is now derived: empty dependencies report as up,
otherwise up is the conjunction of every dependency's status.

Author: thced

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

@@ -74,65 +74,90 @@ public static HttpHandler aliveHandler() {
 
   /**
    * Health endpoint handler. Accepts GET and HEAD; returns 200 with {@code application/json} body
-   * when the supplied probe reports {@code up == true}, and 503 with the same body shape otherwise.
-   * A probe that throws a {@link RuntimeException} or returns {@code null} is mapped to a {@code
-   * Down} outcome with an empty dependency list (and 503); the failure is never propagated to the
-   * default exception handler.
+   * when the supplied probe reports up (all dependencies up, or no dependencies), and 503 with the
+   * same body shape otherwise. A probe that throws a {@link RuntimeException} or returns {@code
+   * null} is mapped to a {@code Down} response with an empty dependency list (and 503); the failure
+   * is never propagated to the default exception handler.
    *
    * <p>The wire shape is
    *
    * <pre>{@code
    * {"outcome":"Up","dependencies":[{"id":"jdbc","status":"Up"}]}
    * }</pre>
    *
-   * <p>Serialisation is delegated to the supplied {@code jsonMapper} — typically the same {@link
-   * TypeMapper} the caller registered for {@code application/json} on the server. The handler hands
-   * the mapper a record-shaped DTO with the components in the order shown above; any standard JSON
-   * library (Gson, Jackson, …) serialises it identically.
+   * <p>The body is rendered by a built-in writer; no JSON library on the classpath is required.
    *
-   * @param jsonMapper used to encode the wire-shape DTO to bytes
    * @param probe supplier of the current {@link HealthOutcome}
    */
-  public static HttpHandler healthHandler(TypeMapper jsonMapper, Supplier<HealthOutcome> probe) {
-    Objects.requireNonNull(jsonMapper, "jsonMapper");
+  public static HttpHandler healthHandler(Supplier<HealthOutcome> probe) {
     Objects.requireNonNull(probe, "probe");
     return new MethodLimitedHandler(
         exchange -> {
           try (exchange) {
-            HealthOutcome outcome;
+            boolean up;
+            List<Dependency> dependencies;
             try {
-              outcome = Objects.requireNonNull(probe.get(), "Health probe returned null");
+              HealthOutcome outcome =
+                  Objects.requireNonNull(probe.get(), "Health probe returned null");
+              up = outcome.up();
+              dependencies = outcome.dependencies();
             } catch (RuntimeException e) {
               LOG.warn("Health probe failed", e);
-              outcome = new HealthOutcome(false, List.of());
+              up = false;
+              dependencies = List.of();
             }
-            byte[] body = jsonMapper.writeTo(toWireShape(outcome));
-            int status = outcome.up() ? HTTP_OK : HTTP_UNAVAILABLE;
+            byte[] body = renderJson(up, dependencies).getBytes(UTF_8);
+            int status = up ? HTTP_OK : HTTP_UNAVAILABLE;
             exchange.getResponseHeaders().add("Content-Type", "application/json");
             exchange.sendResponseHeaders(status, body.length);
             exchange.getResponseBody().write(body);
           }
         });
   }
 
-  private static HealthBody toWireShape(HealthOutcome outcome) {
-    return new HealthBody(
-        label(outcome.up()),
-        outcome.dependencies().stream()
-            .map(d -> new DependencyBody(d.id(), label(d.up())))
-            .toList());
+  private static String renderJson(boolean up, List<Dependency> dependencies) {
+    StringBuilder sb = new StringBuilder(64);
+    sb.append("{\"outcome\":\"").append(label(up)).append("\",\"dependencies\":[");
+    for (int i = 0; i < dependencies.size(); i++) {
+      if (i > 0) {
+        sb.append(',');
+      }
+      Dependency d = dependencies.get(i);
+      sb.append("{\"id\":");
+      appendJsonString(sb, d.id());
+      sb.append(",\"status\":\"").append(label(d.up())).append("\"}");
+    }
+    return sb.append("]}").toString();
+  }
+
+  private static void appendJsonString(StringBuilder sb, String s) {
+    sb.append('"');
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      switch (c) {
+        case '"' -> sb.append("\\\"");
+        case '\\' -> sb.append("\\\\");
+        case '\b' -> sb.append("\\b");
+        case '\f' -> sb.append("\\f");
+        case '\n' -> sb.append("\\n");
+        case '\r' -> sb.append("\\r");
+        case '\t' -> sb.append("\\t");
+        default -> {
+          if (c < 0x20) {
+            sb.append(String.format("\\u%04x", (int) c));
+          } else {
+            sb.append(c);
+          }
+        }
+      }
+    }
+    sb.append('"');
   }
 
   private static String label(boolean up) {
     return up ? "Up" : "Down";
   }
 
-  /** Wire-shape DTO for the health endpoint. Component order defines JSON field order. */
-  private record HealthBody(String outcome, List<DependencyBody> dependencies) {}
-
-  /** Wire-shape DTO for a single dependency entry. */
-  private record DependencyBody(String id, String status) {}
-
   /**
    * Serves a classpath resource. Content-Type is inferred from the file extension. The resource is
    * loaded eagerly; a missing resource fails immediately with {@link IllegalArgumentException}.

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

@@ -6,17 +6,20 @@
 /**
  * Carrier for the {@link Handlers#healthHandler health handler} response.
  *
- * <p>The library translates {@code up} into the wire value {@code "Up"} or {@code "Down"} on the
- * way out; callers work in booleans. Construct the outcome from whatever check-running mechanism
- * the caller prefers — this library has no opinion.
+ * <p>Overall health is derived from {@link #dependencies()}: an empty list reports as {@code "Up"};
+ * otherwise the outcome is {@code "Up"} only when every dependency is up. Callers describe their
+ * dependencies and the library aggregates.
  *
- * @param up overall health — {@code true} renders as {@code "Up"} with HTTP 200; {@code false}
- *     renders as {@code "Down"} with HTTP 503
  * @param dependencies per-dependency statuses; {@code null} is normalised to an empty list
  */
-public record HealthOutcome(boolean up, List<Dependency> dependencies) {
+public record HealthOutcome(List<Dependency> dependencies) {
 
   public HealthOutcome {
     dependencies = List.copyOf(Objects.requireNonNullElse(dependencies, List.of()));
   }
+
+  /** {@code true} when every dependency is up (vacuously true for an empty list). */
+  public boolean up() {
+    return dependencies.stream().allMatch(Dependency::up);
+  }
 }

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

@@ -8,7 +8,6 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import com.retailsvc.http.internal.gson.GsonJsonMapper;
 import com.sun.net.httpserver.Headers;
 import com.sun.net.httpserver.HttpExchange;
 import java.io.ByteArrayOutputStream;
@@ -19,18 +18,16 @@
 
 class HealthHandlerTest {
 
-  private static final TypeMapper JSON = new GsonJsonMapper();
-
   @Test
-  void getReturns200AndJsonBodyWhenUp() throws IOException {
-    HealthOutcome outcome = new HealthOutcome(true, List.of(new Dependency("jdbc", true)));
+  void getReturns200AndJsonBodyWhenAllDependenciesUp() throws IOException {
+    HealthOutcome outcome = new HealthOutcome(List.of(new Dependency("jdbc", true)));
     HttpExchange ex = newExchange("GET");
     Headers headers = new Headers();
     when(ex.getResponseHeaders()).thenReturn(headers);
     ByteArrayOutputStream body = new ByteArrayOutputStream();
     when(ex.getResponseBody()).thenReturn(body);
 
-    Handlers.healthHandler(JSON, () -> outcome).handle(ex);
+    Handlers.healthHandler(() -> outcome).handle(ex);
 
     verify(ex).sendResponseHeaders(HTTP_OK, (long) body.size());
     assertThat(headers.getFirst("Content-Type")).isEqualTo("application/json");
@@ -46,22 +43,22 @@ void getReturns200WithEmptyDependencyArrayWhenNoDeps() throws IOException {
     ByteArrayOutputStream body = new ByteArrayOutputStream();
     when(ex.getResponseBody()).thenReturn(body);
 
-    Handlers.healthHandler(JSON, () -> new HealthOutcome(true, List.of())).handle(ex);
+    Handlers.healthHandler(() -> new HealthOutcome(List.of())).handle(ex);
 
     verify(ex).sendResponseHeaders(HTTP_OK, (long) body.size());
     assertThat(body).hasToString("{\"outcome\":\"Up\",\"dependencies\":[]}");
   }
 
   @Test
-  void getReturns503WhenDown() throws IOException {
-    HealthOutcome outcome = new HealthOutcome(false, List.of(new Dependency("jdbc", false)));
+  void getReturns503WhenAnyDependencyDown() throws IOException {
+    HealthOutcome outcome = new HealthOutcome(List.of(new Dependency("jdbc", false)));
     HttpExchange ex = newExchange("GET");
     Headers headers = new Headers();
     when(ex.getResponseHeaders()).thenReturn(headers);
     ByteArrayOutputStream body = new ByteArrayOutputStream();
     when(ex.getResponseBody()).thenReturn(body);
 
-    Handlers.healthHandler(JSON, () -> outcome).handle(ex);
+    Handlers.healthHandler(() -> outcome).handle(ex);
 
     verify(ex).sendResponseHeaders(HTTP_UNAVAILABLE, (long) body.size());
     assertThat(headers.getFirst("Content-Type")).isEqualTo("application/json");
@@ -78,7 +75,7 @@ void headIsAccepted() throws IOException {
     ByteArrayOutputStream body = new ByteArrayOutputStream();
     when(ex.getResponseBody()).thenReturn(body);
 
-    Handlers.healthHandler(JSON, () -> new HealthOutcome(true, List.of())).handle(ex);
+    Handlers.healthHandler(() -> new HealthOutcome(List.of())).handle(ex);
 
     verify(ex).sendResponseHeaders(HTTP_OK, (long) body.size());
   }
@@ -89,7 +86,7 @@ void postReturns405WithAllowHeader() throws IOException {
     Headers headers = new Headers();
     when(ex.getResponseHeaders()).thenReturn(headers);
 
-    Handlers.healthHandler(JSON, () -> new HealthOutcome(true, List.of())).handle(ex);
+    Handlers.healthHandler(() -> new HealthOutcome(List.of())).handle(ex);
 
     verify(ex).sendResponseHeaders(HTTP_BAD_METHOD, -1);
     assertThat(headers.getFirst("Allow")).isEqualTo("GET, HEAD");
@@ -107,7 +104,7 @@ void runtimeExceptionFromProbeMapsToDown503() throws IOException {
         () -> {
           throw new IllegalStateException("boom");
         };
-    Handlers.healthHandler(JSON, failing).handle(ex);
+    Handlers.healthHandler(failing).handle(ex);
 
     verify(ex).sendResponseHeaders(HTTP_UNAVAILABLE, (long) body.size());
     assertThat(body).hasToString("{\"outcome\":\"Down\",\"dependencies\":[]}");
@@ -121,12 +118,29 @@ void nullReturnFromProbeMapsToDown503() throws IOException {
     ByteArrayOutputStream body = new ByteArrayOutputStream();
     when(ex.getResponseBody()).thenReturn(body);
 
-    Handlers.healthHandler(JSON, () -> null).handle(ex);
+    Handlers.healthHandler(() -> null).handle(ex);
 
     verify(ex).sendResponseHeaders(HTTP_UNAVAILABLE, (long) body.size());
     assertThat(body).hasToString("{\"outcome\":\"Down\",\"dependencies\":[]}");
   }
 
+  @Test
+  void escapesSpecialCharsInDependencyId() throws IOException {
+    HealthOutcome outcome = new HealthOutcome(List.of(new Dependency("a\"b\\c\nd", true)));
+    HttpExchange ex = newExchange("GET");
+    Headers headers = new Headers();
+    when(ex.getResponseHeaders()).thenReturn(headers);
+    ByteArrayOutputStream body = new ByteArrayOutputStream();
+    when(ex.getResponseBody()).thenReturn(body);
+
+    Handlers.healthHandler(() -> outcome).handle(ex);
+
+    assertThat(body)
+        .hasToString(
+            "{\"outcome\":\"Up\",\"dependencies\":[{\"id\":\"a\\\"b\\\\c\\n"
+                + "d\",\"status\":\"Up\"}]}");
+  }
+
   private static HttpExchange newExchange(String method) {
     HttpExchange ex = mock(HttpExchange.class);
     when(ex.getRequestMethod()).thenReturn(method);

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

@@ -9,24 +9,42 @@
 class HealthOutcomeTest {
 
   @Test
-  void exposesUpAndDependencies() {
-    HealthOutcome o = new HealthOutcome(true, List.of(new Dependency("jdbc", true)));
-    assertThat(o.up()).isTrue();
+  void exposesDependencies() {
+    HealthOutcome o = new HealthOutcome(List.of(new Dependency("jdbc", true)));
     assertThat(o.dependencies()).containsExactly(new Dependency("jdbc", true));
   }
 
   @Test
   void coercesNullDependenciesToEmpty() {
-    HealthOutcome o = new HealthOutcome(true, null);
+    HealthOutcome o = new HealthOutcome(null);
     assertThat(o.dependencies()).isEmpty();
   }
 
   @Test
   void copiesDependencyListDefensively() {
     List<Dependency> mutable = new ArrayList<>();
     mutable.add(new Dependency("jdbc", true));
-    HealthOutcome o = new HealthOutcome(true, mutable);
+    HealthOutcome o = new HealthOutcome(mutable);
     mutable.clear();
     assertThat(o.dependencies()).hasSize(1);
   }
+
+  @Test
+  void emptyDependenciesIsUp() {
+    assertThat(new HealthOutcome(List.of()).up()).isTrue();
+  }
+
+  @Test
+  void upWhenAllDependenciesUp() {
+    HealthOutcome o =
+        new HealthOutcome(List.of(new Dependency("jdbc", true), new Dependency("redis", true)));
+    assertThat(o.up()).isTrue();
+  }
+
+  @Test
+  void downWhenAnyDependencyDown() {
+    HealthOutcome o =
+        new HealthOutcome(List.of(new Dependency("jdbc", true), new Dependency("redis", false)));
+    assertThat(o.up()).isFalse();
+  }
 }