Light, fluffy, and always free - The AWS Local Emulator alternative
fix(apigateway): route greedy resources below a path parameter (#6690)
Mario Toffia7ca109b595ed
diff --git a/docs/services/api-gateway.md b/docs/services/api-gateway.mdindex 8012fffb59..6e2d839370 100644--- a/docs/services/api-gateway.md+++ b/docs/services/api-gateway.md@@ -397,6 +397,12 @@ A greedy resource captures only the path segments after its parent. For example,`/api/v1/auth/signup/{proxy}` forwards the prefix once. Greedy parameter names otherthan `proxy` are supported, including in `integration.request.path.*` mappings.+A greedy resource may sit below ordinary path parameters: `/catalog/{kind}/{name+}` serves+`/catalog/scopes/a/b` with `kind` set to `scopes` and `name` to `a/b`. When several resources+match a request, they are ranked as on AWS: more literal segments first, then more segments+before the greedy parameter, then the resource whose literal comes first at the first position+where they differ. A resource that does not declare the request's method yields to the next one.+REST `HTTP_PROXY` and `HTTP` integrations also accept `context.*` sources in header, queryand path parameter mappings. Supported request fields are `accountId`, `apiId`, `deploymentId`,`httpMethod`, `path` (including the stage), `protocol`, `requestId`, `resourceId`, `resourcePath`,diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.javaindex 362571ceb9..0ff13511a0 100644--- a/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayExecuteController.java@@ -434,7 +434,7 @@ public class ApiGatewayExecuteController {ApiGatewayResource matched = null;MethodConfig method = null;- // Candidates are ordered exact, then parameterised, then greedy. AWS picks the most+ // Candidates are ordered most specific first (see matchResources). AWS picks the most// specific resource that can serve the method, so one declaring methods but not this// one yields to a less specific sibling that declares it: /users/me carrying only PATCH// does not hide GET /users/{userId}, and /devices carrying only POST falls through to@@ -4257,55 +4257,28 @@ public class ApiGatewayExecuteController {}/**- * Finds all matching resources for {@code requestPath}, sorted by specificity.- * Priority: exact match > template path match (e.g. /items/{id}) > proxy+ wildcard.+ * Finds all matching resources for {@code requestPath}, most specific first.+ *+ * <p>Ranked as measured on AWS, with exact, parameterised and greedy resources in one list:+ * more literal segments first, then more segments before any greedy parameter, then the+ * resource whose literal sits further left at the first position where the two differ. So+ * {@code /s/b/{proxy+}} beats {@code /s/{x}/{y}} for {@code /s/b/c}, and+ * {@code /a/{x}/c/{z+}} beats {@code /a/b/{proxy+}} for {@code /a/b/c/d}.*/List<ApiGatewayResource> matchResources(List<ApiGatewayResource> resources, String requestPath) {+ String[] rParts = requestPath.split("/", -1);List<ApiGatewayResource> matches = new ArrayList<>();- // 1. Exact matchfor (ApiGatewayResource r : resources) {- if (requestPath.equals(r.getPath())) {+ if (r.getPath() != null && pathMatches(r.getPath(), rParts)) {matches.add(r);}}- // 2. Template path match — /items/{id} matches /items/anything- for (ApiGatewayResource r : resources) {- if (r.getPath() != null && r.getPath().contains("{") && greedyParentPrefix(r.getPath()) == null) {- if (pathMatchesTemplate(r.getPath(), requestPath)) {- matches.add(r);- }- }- }- // 3. Greedy wildcard: {proxy+}, or any other {name+}, matches longest parent prefix- // Requires at least one path segment after the parent prefix (except root /{proxy+})- List<ApiGatewayResource> proxyMatches = new ArrayList<>();- for (ApiGatewayResource r : resources) {- String parentPrefix = greedyParentPrefix(r.getPath());- if (parentPrefix == null) continue;- // Root /{proxy+} matches everything including /- if ("/".equals(parentPrefix)) {- proxyMatches.add(r);- continue;- }- // Non-root proxy+ requires at least one char after the prefix- if (requestPath.startsWith(parentPrefix)- && requestPath.length() > parentPrefix.length()) {- proxyMatches.add(r);- }- }- // Sort proxy matches by parentPrefix length descending- proxyMatches.sort((r1, r2) -> {- String p1 = greedyParentPrefix(r1.getPath());- String p2 = greedyParentPrefix(r2.getPath());- return Integer.compare(p2.length(), p1.length());- });- matches.addAll(proxyMatches);+ matches.sort(ApiGatewayExecuteController::compareSpecificity);return matches;}/**- * Finds the best-matching resource for {@code requestPath}.- * Priority: exact match > template path match (e.g. /items/{id}) > proxy+ wildcard.+ * Finds the best-matching resource for {@code requestPath}, the first of {@link #matchResources}.*/ApiGatewayResource matchResource(List<ApiGatewayResource> resources, String requestPath) {List<ApiGatewayResource> matches = matchResources(resources, requestPath);@@ -4313,18 +4286,51 @@ public class ApiGatewayExecuteController {}/**- * Returns true if {@code requestPath} matches the template path (e.g. {@code /items/{id}}).- * Segments wrapped in {@code {}} match any single path segment.+ * True when every segment before any greedy parameter matches: a literal matches itself, a+ * {@code {param}} any one segment. A greedy resource then needs a non-empty remainder, except+ * the root {@code /{proxy+}}, which also serves {@code /}; any other resource needs no more+ * segments.*/- private boolean pathMatchesTemplate(String templatePath, String requestPath) {- String[] tParts = templatePath.split("/", -1);- String[] rParts = requestPath.split("/", -1);- if (tParts.length != rParts.length) return false;- for (int i = 0; i < tParts.length; i++) {- if (tParts[i].startsWith("{") && tParts[i].endsWith("}")) continue; // wildcard segment- if (!tParts[i].equals(rParts[i])) return false;+ private static boolean pathMatches(String resourcePath, String[] rParts) {+ String[] fixed = fixedSegments(resourcePath);+ boolean greedy = greedyParentPrefix(resourcePath) != null;+ if (greedy ? rParts.length < fixed.length : rParts.length != fixed.length) {+ return false;}- return true;+ for (int i = 0; i < fixed.length; i++) {+ if (!isPathParameter(fixed[i]) && !fixed[i].equals(rParts[i])) {+ return false;+ }+ }+ return !greedy || fixed.length == 1+ || !String.join("/", Arrays.copyOfRange(rParts, fixed.length, rParts.length)).isEmpty();+ }++ private static int compareSpecificity(ApiGatewayResource a, ApiGatewayResource b) {+ String[] fa = fixedSegments(a.getPath());+ String[] fb = fixedSegments(b.getPath());+ int order = Long.compare(literalCount(fb), literalCount(fa));+ if (order == 0) {+ order = Integer.compare(fb.length, fa.length);+ }+ for (int i = 0; order == 0 && i < fa.length; i++) {+ order = Boolean.compare(isPathParameter(fa[i]), isPathParameter(fb[i]));+ }+ return order;+ }++ /** The segments of {@code resourcePath} before its greedy parameter, or all of them. */+ private static String[] fixedSegments(String resourcePath) {+ String[] parts = resourcePath.split("/", -1);+ return greedyParentPrefix(resourcePath) == null ? parts : Arrays.copyOf(parts, parts.length - 1);+ }++ private static long literalCount(String[] segments) {+ return Arrays.stream(segments).filter(s -> !isPathParameter(s)).count();+ }++ private static boolean isPathParameter(String segment) {+ return segment.startsWith("{") && segment.endsWith("}");}/**@@ -4389,13 +4395,16 @@ public class ApiGatewayExecuteController {/*** Extracts named path parameters from a matched template path.* Given template {@code /items/{id}} and request {@code /items/item-1}, returns {@code {id=item-1}}.+ * A greedy template such as {@code /catalog/{kind}/{name+}} also yields the parameters before+ * its greedy one from a longer request: {@code {kind=scopes}} for {@code /catalog/scopes/a/b}.*/private Map<String, String> extractPathParams(String templatePath, String requestPath) {Map<String, String> params = new HashMap<>();if (templatePath == null || requestPath == null) return params;String[] tParts = templatePath.split("/", -1);String[] rParts = requestPath.split("/", -1);- if (tParts.length != rParts.length) return params;+ boolean greedy = greedyParentPrefix(templatePath) != null;+ if (greedy ? rParts.length < tParts.length : tParts.length != rParts.length) return params;for (int i = 0; i < tParts.length; i++) {String t = tParts[i];if (t.startsWith("{") && t.endsWith("}")) {diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayGreedyPathParameterIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayGreedyPathParameterIntegrationTest.javaindex dd1f6533d1..d2975ef7d9 100644--- a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayGreedyPathParameterIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayGreedyPathParameterIntegrationTest.java@@ -39,7 +39,7 @@ class ApiGatewayGreedyPathParameterIntegrationTest {}@Test @Order(2)- void setupAssetsGreedyResource() {+ void setupGreedyResources() {String rootId = given().when().get("/restapis/" + apiId + "/resources").then()@@ -94,6 +94,38 @@ class ApiGatewayGreedyPathParameterIntegrationTest {+ "/methods/ANY/integration/responses/200").then().statusCode(201);++ // /v1/admin/catalog/{kind} lists, /v1/admin/catalog/{kind}/{name+} serves one item+ String catalogId = createResource(createResource(createResource(rootId, "v1"), "admin"), "catalog");+ String kindId = createResource(catalogId, "{kind}");+ mockEcho(kindId, "{\"matched\":\"catalog-list\",\"kind\":\"$input.params('kind')\"}");+ mockEcho(createResource(kindId, "{name+}"), "{\"matched\":\"catalog-item\","+ + "\"kind\":\"$input.params('kind')\",\"name\":\"$input.params('name')\"}");+ }++ private static String createResource(String parentId, String pathPart) {+ return given()+ .contentType(ContentType.JSON)+ .body("{\"pathPart\":\"" + pathPart + "\"}")+ .when().post("/restapis/" + apiId + "/resources/" + parentId)+ .then()+ .statusCode(201)+ .extract().path("id");+ }++ private static void mockEcho(String resourceId, String responseTemplate) {+ String method = "/restapis/" + apiId + "/resources/" + resourceId + "/methods/GET";+ given().contentType(ContentType.JSON).body("{\"authorizationType\":\"NONE\"}")+ .when().put(method).then().statusCode(201);+ given().contentType(ContentType.JSON).body("{\"responseParameters\":{}}")+ .when().put(method + "/responses/200").then().statusCode(201);+ given().contentType(ContentType.JSON)+ .body("{\"type\":\"MOCK\",\"requestTemplates\":{\"application/json\":\"{\\\"statusCode\\\": 200}\"}}")+ .when().put(method + "/integration").then().statusCode(201);+ given().contentType(ContentType.JSON)+ .body("{\"selectionPattern\":\"\",\"responseTemplates\":{\"application/json\":\""+ + responseTemplate.replace("\"", "\\\"") + "\"}}")+ .when().put(method + "/integration/responses/200").then().statusCode(201);}@Test @Order(3)@@ -161,6 +193,29 @@ class ApiGatewayGreedyPathParameterIntegrationTest {.body("message", equalTo("Missing Authentication Token"));}+ @Test @Order(8)+ void greedyResourceBelowAPathParameterReceivesBothParameters() {+ // Used to fall through to the no-match 403: the greedy matcher compared the request with+ // the literal text "/v1/admin/catalog/{kind}/", which no real path starts with.+ given()+ .when().get("/execute-api/" + apiId + "/test/v1/admin/catalog/scopes/teos/sur-df")+ .then()+ .statusCode(200)+ .body("matched", equalTo("catalog-item"))+ .body("kind", equalTo("scopes"))+ .body("name", equalTo("teos/sur-df"));+ }++ @Test @Order(9)+ void parentResourceStillServesItsOwnPath() {+ given()+ .when().get("/execute-api/" + apiId + "/test/v1/admin/catalog/scopes")+ .then()+ .statusCode(200)+ .body("matched", equalTo("catalog-list"))+ .body("kind", equalTo("scopes"));+ }+@Test @Order(99)void cleanup() {given().when().delete("/restapis/" + apiId).then().statusCode(202);diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayProxyMatchTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayProxyMatchTest.javaindex c37d0890a1..65bebbe1d8 100644--- a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayProxyMatchTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewayProxyMatchTest.java@@ -220,6 +220,77 @@ class ApiGatewayProxyMatchTest {assertNull(ctrl.matchResource(resources, "/items/1/sub"));}+ // ──────────────────────────── greedy below a path parameter ────────────────────────────+ // Measured on AWS: every matching resource, exact, parameterised or greedy, is ranked by its+ // literal segments, then by its segments before the greedy parameter, then by the leftmost+ // literal. A greedy resource is no longer special-cased behind every parameterised one.++ @Test+ void greedyResourceBelowAPathParameterMatches() {+ ApiGatewayResource list = resource("r1", "root", "{kind}", "/v1/admin/catalog/{kind}");+ ApiGatewayResource item = resource("r2", "r1", "{name+}", "/v1/admin/catalog/{kind}/{name+}");+ List<ApiGatewayResource> resources = List.of(item, list);++ assertSame(item, ctrl.matchResource(resources, "/v1/admin/catalog/scopes/teos/sur-df"));+ assertSame(item, ctrl.matchResource(resources, "/v1/admin/catalog/scopes/teos"));+ assertSame(list, ctrl.matchResource(resources, "/v1/admin/catalog/scopes"));+ assertNull(ctrl.matchResource(List.of(item), "/v1/admin/catalog/scopes/"));+ assertNull(ctrl.matchResource(List.of(item), "/v1/admin/other/scopes/teos"));+ }++ @Test+ void moreLiteralSegmentsWinAcrossParameterisedAndGreedyResources() {+ ApiGatewayResource greedy = resource("r1", "root", "{proxy+}", "/s/b/{proxy+}");+ ApiGatewayResource template = resource("r2", "root", "{y}", "/s/{x}/{y}");+ ApiGatewayResource deepTemplate = resource("r3", "root", "{v}", "/s/{x}/{y}/{z}/{v}");+ List<ApiGatewayResource> resources = List.of(template, deepTemplate, greedy);++ assertSame(greedy, ctrl.matchResource(resources, "/s/b/c"));+ assertSame(greedy, ctrl.matchResource(resources, "/s/b/c/d/e"));+ assertSame(template, ctrl.matchResource(resources, "/s/a/c"));+ }++ @Test+ void moreLiteralSegmentsBeatADeeperGreedyParent() {+ ApiGatewayResource shallow = resource("r1", "root", "{proxy+}", "/q/b/{proxy+}");+ ApiGatewayResource deep = resource("r2", "root", "{p+}", "/q/{x}/{y}/{p+}");+ ApiGatewayResource early = resource("r3", "root", "{p+}", "/m/b/{y}/{z}/{p+}");+ ApiGatewayResource late = resource("r4", "root", "{q+}", "/m/{x}/c/d/{q+}");+ List<ApiGatewayResource> resources = List.of(deep, shallow, early, late);++ assertSame(shallow, ctrl.matchResource(resources, "/q/b/c/d"));+ assertSame(deep, ctrl.matchResource(resources, "/q/a/c/d"));+ assertSame(late, ctrl.matchResource(resources, "/m/b/c/d/e"));+ }++ @Test+ void deeperGreedyParentWinsAtEqualLiteralSegments() {+ ApiGatewayResource nested = resource("r1", "root", "{y+}", "/a/{x}/{y+}");+ ApiGatewayResource literal = resource("r2", "root", "{proxy+}", "/a/b/{proxy+}");+ ApiGatewayResource deeper = resource("r3", "root", "{z+}", "/a/{x}/c/{z+}");+ List<ApiGatewayResource> resources = List.of(nested, literal, deeper);++ assertSame(nested, ctrl.matchResource(resources, "/a/one/two/three"));+ assertSame(literal, ctrl.matchResource(resources, "/a/b/c"));+ assertEquals(List.of(deeper, literal, nested), ctrl.matchResources(resources, "/a/b/c/d"));+ }++ @Test+ void leftmostLiteralBreaksATie() {+ ApiGatewayResource leftLiteral = resource("r1", "root", "{p+}", "/n/b/{y}/{p+}");+ ApiGatewayResource rightLiteral = resource("r2", "root", "{q+}", "/n/{x}/c/{q+}");++ assertSame(leftLiteral, ctrl.matchResource(List.of(rightLiteral, leftLiteral), "/n/b/c/d"));+ assertSame(leftLiteral, ctrl.matchResource(List.of(leftLiteral, rightLiteral), "/n/b/c/d"));+ }++ @Test+ void pathParameterMatchesAnEmptySegment() {+ ApiGatewayResource template = resource("r1", "root", "two", "/a/{x}/two");++ assertSame(template, ctrl.matchResource(List.of(template), "/a//two"));+ }+// ──────────────────────────── trailing-slash preservation (#1557) ────────────────────────────@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ProxyEventPathParametersTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ProxyEventPathParametersTest.javaindex a906e3d3ab..6014c106ee 100644--- a/src/test/java/io/github/hectorvent/floci/services/apigateway/ProxyEventPathParametersTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ProxyEventPathParametersTest.java@@ -112,4 +112,14 @@ class ProxyEventPathParametersTest {assertEquals(List.of("rest"), keysOf(pp));assertEquals("img/logo.png", pp.get("rest").asText());}++ @Test+ void greedyResourceBelowAPathParameterReceivesBothParameters() throws Exception {+ JsonNode pp = pathParametersFor("/v1/admin/catalog/scopes/teos/sur-df",+ "/v1/admin/catalog/{kind}/{name+}");++ assertEquals(List.of("kind", "name"), keysOf(pp));+ assertEquals("scopes", pp.get("kind").asText());+ assertEquals("teos/sur-df", pp.get("name").asText());+ }}