refactor: Fold exception handling into RequestPreparationFilter

Move inner-chain exception catching from ExceptionFilter into
RequestPreparationFilter so after-hooks can fire inside the still-bound
ScopedValue block (Task 4 of 9 — behavior-preserving).

ExceptionFilter is kept and still wires onto extra-route contexts.

Author: thced

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

@@ -95,8 +95,15 @@ record HandlerConfig(
     httpServer.setExecutor(newThreadPerTaskExecutor(ofVirtual().name("http-", 0).factory()));
 
     HttpContext ctx = httpServer.createContext(Optional.ofNullable(spec.basePath()).orElse("/"));
-    ctx.getFilters().add(new ExceptionFilter(exceptionHandler));
-    ctx.getFilters().add(new RequestPreparationFilter(spec, router, validator, bodyMappers));
+    ctx.getFilters()
+        .add(
+            new RequestPreparationFilter(
+                spec,
+                router,
+                validator,
+                bodyMappers,
+                exceptionHandler,
+                handlerConfig.afterHooks()));
     ctx.getFilters()
         .add(
             new SecurityFilter(

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

@@ -1,5 +1,7 @@
 package com.retailsvc.http.internal;
 
+import com.retailsvc.http.AfterResponseHook;
+import com.retailsvc.http.ExceptionHandler;
 import com.retailsvc.http.MethodNotAllowedException;
 import com.retailsvc.http.NotFoundException;
 import com.retailsvc.http.Request;
@@ -17,25 +19,38 @@
 import com.sun.net.httpserver.HttpExchange;
 import java.io.IOException;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public final class RequestPreparationFilter extends Filter {
 
+  private static final Logger LOG = LoggerFactory.getLogger(RequestPreparationFilter.class);
   private static final String BODY_POINTER = "/body";
 
   private final Spec spec;
   private final Router router;
   private final Validator validator;
   private final Map<String, TypeMapper> bodyMappers;
+  private final ExceptionHandler exceptionHandler;
+  private final List<AfterResponseHook> afterHooks;
 
   public RequestPreparationFilter(
-      Spec spec, Router router, Validator validator, Map<String, TypeMapper> bodyMappers) {
+      Spec spec,
+      Router router,
+      Validator validator,
+      Map<String, TypeMapper> bodyMappers,
+      ExceptionHandler exceptionHandler,
+      List<AfterResponseHook> afterHooks) {
     this.spec = spec;
     this.router = router;
     this.validator = validator;
     this.bodyMappers = Map.copyOf(bodyMappers);
+    this.exceptionHandler = exceptionHandler;
+    this.afterHooks = List.copyOf(afterHooks);
   }
 
   @Override
@@ -45,6 +60,30 @@ public String description() {
 
   @Override
   public void doFilter(HttpExchange exchange, Chain chain) throws IOException {
+    Request request;
+    try {
+      request = buildRequest(exchange);
+    } catch (RuntimeException | IOException t) {
+      exceptionHandler.handle(exchange, t);
+      return;
+    }
+
+    try {
+      ScopedValue.where(DispatchHandler.CURRENT, request)
+          .call(
+              () -> {
+                runInnerChain(exchange, chain);
+                fireAfterHooks(exchange, request);
+                return null;
+              });
+    } catch (IOException | RuntimeException e) {
+      throw e;
+    } catch (Exception e) {
+      throw new IOException(e);
+    }
+  }
+
+  private Request buildRequest(HttpExchange exchange) throws IOException {
     byte[] body = exchange.getRequestBody().readAllBytes();
 
     HttpMethod method = HttpMethod.parse(exchange.getRequestMethod());
@@ -65,30 +104,28 @@ public void doFilter(HttpExchange exchange, Chain chain) throws IOException {
     ParsedBody parsedBody = validateAndParseBody(exchange, op, body);
 
     var headers = exchange.getRequestHeaders();
-    Request request =
-        new Request(
-            body,
-            parsedBody.value(),
-            parsedBody.mapper(),
-            op.operationId(),
-            match.pathParameters(),
-            exchange.getRequestURI().getRawQuery(),
-            headers::getFirst);
+    return new Request(
+        body,
+        parsedBody.value(),
+        parsedBody.mapper(),
+        op.operationId(),
+        match.pathParameters(),
+        exchange.getRequestURI().getRawQuery(),
+        headers::getFirst);
+  }
 
+  private void runInnerChain(HttpExchange exchange, Chain chain) throws IOException {
     try {
-      ScopedValue.where(DispatchHandler.CURRENT, request)
-          .call(
-              () -> {
-                chain.doFilter(exchange);
-                return null;
-              });
-    } catch (IOException | RuntimeException e) {
-      throw e;
-    } catch (Exception e) {
-      throw new IOException(e);
+      chain.doFilter(exchange);
+    } catch (RuntimeException | IOException t) {
+      exceptionHandler.handle(exchange, t);
     }
   }
 
+  private void fireAfterHooks(HttpExchange exchange, Request request) {
+    // implemented in Task 5
+  }
+
   private String stripBasePath(String path) {
     String base = spec.basePath();
     if (base == null || base.isEmpty() || base.equals("/")) {

src/test/java/com/retailsvc/http/internal/RequestPreparationFilterTest.java

@@ -4,6 +4,7 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.mockito.Mockito.mock;
 
+import com.retailsvc.http.ExceptionHandler;
 import com.retailsvc.http.MethodNotAllowedException;
 import com.retailsvc.http.NotFoundException;
 import com.retailsvc.http.Request;
@@ -26,6 +27,7 @@
 import com.sun.net.httpserver.Headers;
 import com.sun.net.httpserver.HttpExchange;
 import java.io.ByteArrayInputStream;
+import java.io.IOException;
 import java.net.URI;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
@@ -77,8 +79,23 @@ public byte[] writeTo(Object value) {
           }
         };
     Map<String, TypeMapper> mappers = Map.of("application/json", textMapper);
+    ExceptionHandler rethrow =
+        (exchange, t) -> {
+          if (t instanceof IOException ioe) {
+            throw ioe;
+          }
+          if (t instanceof RuntimeException re) {
+            throw re;
+          }
+          throw new IOException(t);
+        };
     return new RequestPreparationFilter(
-        spec, new Router(spec.operations()), new DefaultValidator(spec::resolveSchema), mappers);
+        spec,
+        new Router(spec.operations()),
+        new DefaultValidator(spec::resolveSchema),
+        mappers,
+        rethrow,
+        List.of());
   }
 
   @Test