feat(internal): Router with exact and templated indexes plus allowedMethods()

Author: thced

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

@@ -0,0 +1,61 @@
+package com.retailsvc.http.internal;
+
+import com.retailsvc.http.spec.HttpMethod;
+import com.retailsvc.http.spec.Operation;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+public final class Router {
+
+  public record Match(Operation operation, Map<String, String> pathParameters) {}
+
+  private final Map<HttpMethod, Map<String, Operation>> exact = new EnumMap<>(HttpMethod.class);
+  private final Map<HttpMethod, List<Operation>> templated = new EnumMap<>(HttpMethod.class);
+
+  public Router(List<Operation> operations) {
+    for (HttpMethod m : HttpMethod.values()) {
+      exact.put(m, new LinkedHashMap<>());
+      templated.put(m, new ArrayList<>());
+    }
+    for (Operation op : operations) {
+      if (op.path().parameterNames().isEmpty()) {
+        exact.get(op.method()).put(op.path().raw(), op);
+      } else {
+        templated.get(op.method()).add(op);
+      }
+    }
+  }
+
+  public Optional<Match> match(HttpMethod method, String path) {
+    Operation hit = exact.get(method).get(path);
+    if (hit != null) return Optional.of(new Match(hit, Map.of()));
+    for (Operation op : templated.get(method)) {
+      Optional<Map<String, String>> params = op.path().match(path);
+      if (params.isPresent()) return Optional.of(new Match(op, params.get()));
+    }
+    return Optional.empty();
+  }
+
+  public Set<HttpMethod> allowedMethods(String path) {
+    EnumSet<HttpMethod> out = EnumSet.noneOf(HttpMethod.class);
+    for (HttpMethod m : HttpMethod.values()) {
+      if (exact.get(m).containsKey(path)) {
+        out.add(m);
+        continue;
+      }
+      for (Operation op : templated.get(m)) {
+        if (op.path().match(path).isPresent()) {
+          out.add(m);
+          break;
+        }
+      }
+    }
+    return out;
+  }
+}

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

@@ -0,0 +1,50 @@
+package com.retailsvc.http.internal;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.retailsvc.http.spec.HttpMethod;
+import com.retailsvc.http.spec.Operation;
+import com.retailsvc.http.spec.PathTemplate;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import org.junit.jupiter.api.Test;
+
+class RouterTest {
+  private Operation op(String id, HttpMethod m, String path) {
+    return new Operation(id, m, PathTemplate.compile(path), Optional.empty(), List.of(), Map.of());
+  }
+
+  @Test
+  void exactPathMatchByMethod() {
+    Router r =
+        new Router(List.of(op("a", HttpMethod.GET, "/users"), op("b", HttpMethod.POST, "/users")));
+    assertThat(r.match(HttpMethod.GET, "/users").orElseThrow().operation().operationId())
+        .isEqualTo("a");
+    assertThat(r.match(HttpMethod.POST, "/users").orElseThrow().operation().operationId())
+        .isEqualTo("b");
+  }
+
+  @Test
+  void templatedPathExtractsParam() {
+    Router r = new Router(List.of(op("g", HttpMethod.GET, "/users/{id}")));
+    Router.Match m = r.match(HttpMethod.GET, "/users/42").orElseThrow();
+    assertThat(m.operation().operationId()).isEqualTo("g");
+    assertThat(m.pathParameters()).containsEntry("id", "42");
+  }
+
+  @Test
+  void unknownPathReturnsEmpty() {
+    Router r = new Router(List.of(op("g", HttpMethod.GET, "/users")));
+    assertThat(r.match(HttpMethod.GET, "/orders")).isEmpty();
+  }
+
+  @Test
+  void allowedMethodsForKnownPath() {
+    Router r =
+        new Router(List.of(op("a", HttpMethod.GET, "/users"), op("b", HttpMethod.POST, "/users")));
+    assertThat(r.allowedMethods("/users"))
+        .containsExactlyInAnyOrder(HttpMethod.GET, HttpMethod.POST);
+    assertThat(r.allowedMethods("/missing")).isEmpty();
+  }
+}