refactor: Extract helpers in OpenApiServer to reduce cognitive complexity

Author: thced

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

@@ -81,71 +81,113 @@ record HandlerConfig(
       throw new IllegalStateException("at least one spec binding is required");
     }
     requireNonNull(bodyMappers, "bodyMappers must not be null");
-    ExceptionHandler exceptionHandler = handlerConfig.exceptionHandler();
 
     long t0 = System.currentTimeMillis();
+    ExceptionHandler exceptionHandler = handlerConfig.exceptionHandler();
 
     InetSocketAddress socketAddress =
         (bindAddress == null)
             ? new InetSocketAddress(port)
             : new InetSocketAddress(bindAddress, port);
-    if (sslContext != null) {
-      HttpsServer https = HttpsServer.create(socketAddress, 0);
-      https.setHttpsConfigurator(new TlsHttpsConfigurator(sslContext));
-      this.httpServer = https;
-    } else {
-      this.httpServer = HttpServer.create(socketAddress, 0);
-    }
+    this.httpServer = createHttpServer(socketAddress, sslContext);
     httpServer.setExecutor(newThreadPerTaskExecutor(ofVirtual().name("http-", 0).factory()));
 
     ResponseRenderer renderer = new ResponseRenderer(bodyMappers);
+    boolean anyBindingAtRoot =
+        wireBindings(httpServer, bindings, bodyMappers, handlerConfig, exceptionHandler, renderer);
+    wireExtras(httpServer, anyBindingAtRoot, handlerConfig.extras(), exceptionHandler, renderer);
+
+    httpServer.start();
+    this.shutdownTimeoutSeconds = shutdownTimeoutSeconds;
+    logStartup(t0);
+  }
+
+  private static HttpServer createHttpServer(InetSocketAddress addr, SSLContext sslContext)
+      throws IOException {
+    if (sslContext != null) {
+      HttpsServer https = HttpsServer.create(addr, 0);
+      https.setHttpsConfigurator(new TlsHttpsConfigurator(sslContext));
+      return https;
+    }
+    return HttpServer.create(addr, 0);
+  }
 
+  @SuppressWarnings("java:S107")
+  private static boolean wireBindings(
+      HttpServer httpServer,
+      List<SpecBinding> bindings,
+      Map<String, TypeMapper> bodyMappers,
+      HandlerConfig handlerConfig,
+      ExceptionHandler exceptionHandler,
+      ResponseRenderer renderer) {
     boolean anyBindingAtRoot = false;
     for (SpecBinding binding : bindings) {
       String basePath = Optional.ofNullable(binding.spec().basePath()).orElse("/");
       anyBindingAtRoot |= "/".equals(basePath);
-      Map<String, Operation> operationsById =
-          binding.spec().operations().stream()
-              .collect(Collectors.toUnmodifiableMap(Operation::operationId, op -> op));
-      HttpContext ctx = httpServer.createContext(basePath);
-      ctx.getFilters()
-          .add(
-              new RequestPreparationFilter(
-                  binding.spec(),
-                  binding.router(),
-                  binding.validator(),
-                  bodyMappers,
-                  exceptionHandler,
-                  renderer,
-                  handlerConfig.afterHooks()));
-      ctx.getFilters()
-          .add(
-              new SecurityFilter(
-                  operationsById,
-                  binding.spec().securitySchemes(),
-                  binding.spec().security(),
-                  binding.securityValidators(),
-                  handlerConfig.externalAuth()));
-      ctx.setHandler(
-          new DispatchHandler(
-              binding.handlers(),
-              handlerConfig.interceptors(),
-              handlerConfig.decorators(),
-              renderer));
-    }
-
-    if (!anyBindingAtRoot) {
-      ExtrasRouter extrasRouter = new ExtrasRouter(handlerConfig.extras(), renderer);
-      HttpContext extrasCtx = httpServer.createContext("/", extrasRouter);
-      extrasCtx.getFilters().add(new ExceptionFilter(exceptionHandler, renderer));
-    } else if (!handlerConfig.extras().isEmpty()) {
-      throw new IllegalStateException(
-          "extras cannot be registered when a binding owns basePath '/'");
+      wireBinding(
+          httpServer, basePath, binding, bodyMappers, handlerConfig, exceptionHandler, renderer);
     }
-    httpServer.start();
+    return anyBindingAtRoot;
+  }
 
-    this.shutdownTimeoutSeconds = shutdownTimeoutSeconds;
+  @SuppressWarnings("java:S107")
+  private static void wireBinding(
+      HttpServer httpServer,
+      String basePath,
+      SpecBinding binding,
+      Map<String, TypeMapper> bodyMappers,
+      HandlerConfig handlerConfig,
+      ExceptionHandler exceptionHandler,
+      ResponseRenderer renderer) {
+    Map<String, Operation> operationsById =
+        binding.spec().operations().stream()
+            .collect(Collectors.toUnmodifiableMap(Operation::operationId, op -> op));
+    HttpContext ctx = httpServer.createContext(basePath);
+    ctx.getFilters()
+        .add(
+            new RequestPreparationFilter(
+                binding.spec(),
+                binding.router(),
+                binding.validator(),
+                bodyMappers,
+                exceptionHandler,
+                renderer,
+                handlerConfig.afterHooks()));
+    ctx.getFilters()
+        .add(
+            new SecurityFilter(
+                operationsById,
+                binding.spec().securitySchemes(),
+                binding.spec().security(),
+                binding.securityValidators(),
+                handlerConfig.externalAuth()));
+    ctx.setHandler(
+        new DispatchHandler(
+            binding.handlers(),
+            handlerConfig.interceptors(),
+            handlerConfig.decorators(),
+            renderer));
+  }
+
+  private static void wireExtras(
+      HttpServer httpServer,
+      boolean anyBindingAtRoot,
+      Map<String, RequestHandler> extras,
+      ExceptionHandler exceptionHandler,
+      ResponseRenderer renderer) {
+    if (anyBindingAtRoot) {
+      if (!extras.isEmpty()) {
+        throw new IllegalStateException(
+            "extras cannot be registered when a binding owns basePath '/'");
+      }
+      return;
+    }
+    ExtrasRouter extrasRouter = new ExtrasRouter(extras, renderer);
+    HttpContext extrasCtx = httpServer.createContext("/", extrasRouter);
+    extrasCtx.getFilters().add(new ExceptionFilter(exceptionHandler, renderer));
+  }
 
+  private void logStartup(long t0) {
     String host = httpServer.getAddress().getHostString();
     String displayHost = host.contains(":") ? "[" + host + "]" : host;
     LOG.info(
@@ -384,30 +426,62 @@ public Builder extraRoute(String path, RequestHandler handler) {
     }
 
     public OpenApiServer build() throws IOException {
+      List<SpecBinding> effectiveBindings = resolveBindings();
+      validateBindings(effectiveBindings);
+      Map<String, String> seenBasePaths = rejectDuplicateBasePaths(effectiveBindings);
+      rejectExtrasOnBasePath(seenBasePaths);
+
+      Map<String, TypeMapper> resolved = resolveBodyMappers(bodyMappers);
+      ExceptionHandler effectiveExceptionHandler =
+          exceptionHandler != null ? exceptionHandler : Handlers.defaultExceptionHandler();
+      HandlerConfig handlerConfig =
+          new HandlerConfig(
+              interceptors,
+              decorators,
+              effectiveExceptionHandler,
+              extras,
+              externalAuth,
+              List.copyOf(afterHooks));
+      int resolvedPort = resolvePort();
+      SSLContext sslContext =
+          httpsCertChain != null ? PemSslContext.load(httpsCertChain, httpsPrivateKey) : null;
+      return new OpenApiServer(
+          effectiveBindings,
+          resolved,
+          handlerConfig,
+          resolvedPort,
+          bindAddress,
+          shutdownTimeoutSeconds,
+          sslContext);
+    }
+
+    private List<SpecBinding> resolveBindings() {
       boolean usedLegacy = spec != null || handlers != null || !securityValidators.isEmpty();
       boolean usedAddSpec = !bindings.isEmpty();
       if (usedLegacy && usedAddSpec) {
         throw new IllegalStateException(
             "use either spec()/handler()/securityValidator() or addSpec(), not both");
       }
-      List<SpecBinding> effectiveBindings;
       if (usedAddSpec) {
-        effectiveBindings = List.copyOf(bindings);
-      } else {
-        requireNonNull(spec, "Spec must not be null");
-        requireNonNull(handlers, "handlers must not be null");
-        effectiveBindings = List.of(SpecBinding.of(spec, handlers, securityValidators));
+        return List.copyOf(bindings);
       }
+      requireNonNull(spec, "Spec must not be null");
+      requireNonNull(handlers, "handlers must not be null");
+      return List.of(SpecBinding.of(spec, handlers, securityValidators));
+    }
 
+    private void validateBindings(List<SpecBinding> effectiveBindings) {
       for (SpecBinding b : effectiveBindings) {
         if (!externalAuth) {
           validateSecurityWiring(b.spec(), b.securityValidators());
         }
         validateHandlerWiring(b.spec(), b.handlers());
       }
+    }
 
+    private static Map<String, String> rejectDuplicateBasePaths(List<SpecBinding> bindings) {
       Map<String, String> seenBasePaths = new LinkedHashMap<>();
-      for (SpecBinding b : effectiveBindings) {
+      for (SpecBinding b : bindings) {
         String bp = Optional.ofNullable(b.spec().basePath()).orElse("/");
         String existingTitle = seenBasePaths.putIfAbsent(bp, b.spec().info().title());
         if (existingTitle != null) {
@@ -421,7 +495,10 @@ public OpenApiServer build() throws IOException {
                   + "'");
         }
       }
+      return seenBasePaths;
+    }
 
+    private void rejectExtrasOnBasePath(Map<String, String> seenBasePaths) {
       for (String path : extras.keySet()) {
         if (seenBasePaths.containsKey(path)) {
           throw new IllegalStateException(
@@ -432,29 +509,6 @@ public OpenApiServer build() throws IOException {
                   + "'");
         }
       }
-
-      Map<String, TypeMapper> resolved = resolveBodyMappers(bodyMappers);
-      ExceptionHandler effectiveExceptionHandler =
-          exceptionHandler != null ? exceptionHandler : Handlers.defaultExceptionHandler();
-      HandlerConfig handlerConfig =
-          new HandlerConfig(
-              interceptors,
-              decorators,
-              effectiveExceptionHandler,
-              extras,
-              externalAuth,
-              List.copyOf(afterHooks));
-      int resolvedPort = resolvePort();
-      SSLContext sslContext =
-          httpsCertChain != null ? PemSslContext.load(httpsCertChain, httpsPrivateKey) : null;
-      return new OpenApiServer(
-          effectiveBindings,
-          resolved,
-          handlerConfig,
-          resolvedPort,
-          bindAddress,
-          shutdownTimeoutSeconds,
-          sslContext);
     }
 
     private int resolvePort() {