refactor: Address Sonar findings on transport-neutral Request

- OpenApiServer: bundle handlers/interceptors/decorators/exceptionHandler/
  extras into a private HandlerConfig record, dropping the constructor
  from 9 params to 5 (under Sonar's brain-overload threshold of 7).
- OpenApiServer.jsonMapper: use the existing JSON constant instead of
  duplicating the "application/json" literal.
- Request: switch headerLookup from Function<String,String> to the more
  specialised UnaryOperator<String>.
- DispatchHandlerTest.withRequest: drop the unused HttpExchange parameter
  (no longer needed now that Request is built from primitives).

Author: thced

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

@@ -43,21 +43,26 @@ public class OpenApiServer implements AutoCloseable {
   private final HttpServer httpServer;
   private final int shutdownTimeoutSeconds;
 
-  OpenApiServer(
-      Spec spec,
-      Map<String, TypeMapper> bodyMappers,
+  /** Internal grouping of handler-related configuration to keep the constructor signature small. */
+  record HandlerConfig(
       Map<String, RequestHandler> handlers,
-      List<ResponseDecorator> decorators,
       List<RequestInterceptor> interceptors,
+      List<ResponseDecorator> decorators,
       ExceptionHandler exceptionHandler,
+      Map<String, HttpHandler> extras) {}
+
+  OpenApiServer(
+      Spec spec,
+      Map<String, TypeMapper> bodyMappers,
+      HandlerConfig handlerConfig,
       int port,
-      Map<String, HttpHandler> extras,
       int shutdownTimeoutSeconds)
       throws IOException {
 
     requireNonNull(spec, "Spec must not be null");
     requireNonNull(bodyMappers, "bodyMappers must not be null");
-    requireNonNull(handlers, "handlers must not be null");
+    requireNonNull(handlerConfig.handlers(), "handlers must not be null");
+    ExceptionHandler exceptionHandler = handlerConfig.exceptionHandler();
     if (exceptionHandler == null) {
       LOG.warn("No ExceptionHandler set, using default");
       exceptionHandler = Handlers.defaultExceptionHandler();
@@ -74,9 +79,13 @@ public class OpenApiServer implements AutoCloseable {
     ctx.getFilters().add(new ExceptionFilter(exceptionHandler));
     ctx.getFilters().add(new RequestPreparationFilter(spec, router, validator, bodyMappers));
     ctx.setHandler(
-        new DispatchHandler(handlers, interceptors, decorators, new ResponseRenderer(bodyMappers)));
+        new DispatchHandler(
+            handlerConfig.handlers(),
+            handlerConfig.interceptors(),
+            handlerConfig.decorators(),
+            new ResponseRenderer(bodyMappers)));
 
-    for (Map.Entry<String, HttpHandler> e : extras.entrySet()) {
+    for (Map.Entry<String, HttpHandler> e : handlerConfig.extras().entrySet()) {
       HttpContext extraCtx = httpServer.createContext(e.getKey());
       extraCtx.getFilters().add(new ExceptionFilter(exceptionHandler));
       extraCtx.setHandler(e.getValue());
@@ -146,7 +155,7 @@ public Builder bodyMapper(String mediaType, TypeMapper mapper) {
     }
 
     public Builder jsonMapper(TypeMapper mapper) {
-      return bodyMapper("application/json", mapper);
+      return bodyMapper(JSON, mapper);
     }
 
     public Builder handlers(Map<String, RequestHandler> handlers) {
@@ -224,16 +233,9 @@ public OpenApiServer build() throws IOException {
         }
       }
       Map<String, TypeMapper> resolved = resolveBodyMappers(bodyMappers);
-      return new OpenApiServer(
-          spec,
-          resolved,
-          handlers,
-          decorators,
-          interceptors,
-          exceptionHandler,
-          port,
-          extras,
-          shutdownTimeoutSeconds);
+      HandlerConfig handlerConfig =
+          new HandlerConfig(handlers, interceptors, decorators, exceptionHandler, extras);
+      return new OpenApiServer(spec, resolved, handlerConfig, port, shutdownTimeoutSeconds);
     }
 
     private static Map<String, TypeMapper> resolveBodyMappers(

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

@@ -6,7 +6,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Function;
+import java.util.function.UnaryOperator;
 
 /**
  * Read-only per-request handle passed to {@link RequestHandler}. Carries the parsed body, path
@@ -28,7 +28,7 @@ public final class Request {
   private final String operationId;
   private final Map<String, String> pathParameters;
   private final String rawQuery;
-  private final Function<String, String> headerLookup;
+  private final UnaryOperator<String> headerLookup;
   private Map<String, String> queryParamCache;
 
   /**
@@ -51,7 +51,7 @@ public Request(
       String operationId,
       Map<String, String> pathParameters,
       String rawQuery,
-      Function<String, String> headerLookup) {
+      UnaryOperator<String> headerLookup) {
     this.body = body;
     this.parsed = parsed;
     this.bodyMapper = bodyMapper;

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

@@ -8,14 +8,14 @@
 import java.nio.charset.StandardCharsets;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Function;
+import java.util.function.UnaryOperator;
 import org.junit.jupiter.api.Test;
 
 class RequestTest {
 
-  private static final Function<String, String> NO_HEADERS = name -> null;
+  private static final UnaryOperator<String> NO_HEADERS = name -> null;
 
-  private static Function<String, String> headers(String... pairs) {
+  private static UnaryOperator<String> headers(String... pairs) {
     Map<String, String> map = new java.util.HashMap<>();
     for (int i = 0; i < pairs.length; i += 2) {
       map.put(pairs[i].toLowerCase(), pairs[i + 1]);

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

@@ -29,8 +29,7 @@ private static DispatchHandler dispatcher(Map<String, RequestHandler> handlers)
     return new DispatchHandler(handlers, List.of(), List.of(), new ResponseRenderer(Map.of()));
   }
 
-  private static void withRequest(
-      HttpExchange exchange, String operationId, ScopedValue.CallableOp<Void, Exception> body)
+  private static void withRequest(String operationId, ScopedValue.CallableOp<Void, Exception> body)
       throws Exception {
     Request req = new Request(new byte[0], null, null, operationId, Map.of(), null, n -> null);
     ScopedValue.where(DispatchHandler.CURRENT, req).call(body);
@@ -47,7 +46,6 @@ void invokesRegisteredHandler() throws Exception {
     HttpExchange ex = stubExchange();
 
     withRequest(
-        ex,
         "get-x",
         () -> {
           dispatcher(Map.of("get-x", handler)).handle(ex);
@@ -65,7 +63,6 @@ void throwsWhenHandlerMissing() {
     assertThatThrownBy(
             () ->
                 withRequest(
-                    ex,
                     "ghost",
                     () -> {
                       d.handle(ex);