Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(apigateway): support SQS query-protocol integrations (path-style URI) (#1385)

Stas Burnashev31991ac5c361
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.java
index c8d49a12a5..e5a1d7e453 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
@@ -813,6 +813,13 @@ public class ApiGatewayExecuteController {
bodyStr, headerMap, queryMap, pathMap, stageName, httpMethod,
resource.getPath(), requestId, regionResolver.getAccountId(), null);
+ // AWS selects the request template by the *incoming* request Content-Type. Capture it
+ // before parameter mapping runs, since an integration.request.header.Content-Type
+ // override (common for SQS query-protocol integrations) would otherwise clobber it and
+ // misdirect template selection.
+ String incomingContentType = headerMap.getOrDefault("Content-Type",
+ headerMap.getOrDefault("content-type", "application/json"));
+
// Apply request parameter mapping (method.request.* → integration.request.*)
Map<String, String> integrationReqParams = integration.getRequestParameters();
if (integrationReqParams != null && !integrationReqParams.isEmpty()) {
@@ -835,8 +842,6 @@ public class ApiGatewayExecuteController {
// Content-Type negotiation and passthrough behavior
String transformedBody;
Map<String, String> requestTemplates = integration.getRequestTemplates();
- String incomingContentType = headerMap.getOrDefault("Content-Type",
- headerMap.getOrDefault("content-type", "application/json"));
if (requestTemplates != null && !requestTemplates.isEmpty()) {
// Try exact match first, then wildcard fallback
@@ -879,13 +884,23 @@ public class ApiGatewayExecuteController {
transformedBody = bodyStr != null ? bodyStr : "";
}
- // Dispatch to service
+ // Dispatch to service.
+ //
+ // A path-style integration URI (arn:...:{service}:path/...) carries no action: the
+ // rendered template body is the AWS query protocol (form-urlencoded,
+ // "Action=SendMessage&..."). Action-style URIs (arn:...:{service}:action/{Action})
+ // carry the action in the URI and render a JSON body.
Response serviceResponse;
String errorType = null;
String errorMessage = null;
try {
- JsonNode requestJson = objectMapper.readTree(transformedBody);
- serviceResponse = serviceRouter.invoke(target.service(), target.action(), requestJson, region);
+ if (target.action() == null) {
+ MultivaluedMap<String, String> formParams = parseFormUrlEncoded(transformedBody);
+ serviceResponse = serviceRouter.invokeQuery(target.service(), formParams, region);
+ } else {
+ JsonNode requestJson = objectMapper.readTree(transformedBody);
+ serviceResponse = serviceRouter.invoke(target.service(), target.action(), requestJson, region);
+ }
} catch (AwsException e) {
errorType = e.getErrorCode();
errorMessage = e.getMessage();
@@ -1810,6 +1825,27 @@ public class ApiGatewayExecuteController {
return objectMapper.createObjectNode().put("message", message).toString();
}
+ /**
+ * Parses an {@code application/x-www-form-urlencoded} body into a {@link MultivaluedMap},
+ * matching the form parameters an AWS query-protocol handler expects. Both keys and values
+ * are URL-decoded. Parameters without a value (e.g. a bare {@code "Key"}) map to an empty string.
+ */
+ private MultivaluedMap<String, String> parseFormUrlEncoded(String body) {
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ if (body == null || body.isEmpty()) {
+ return params;
+ }
+ for (String pair : body.split("&")) {
+ if (pair.isEmpty()) continue;
+ int eq = pair.indexOf('=');
+ String key = eq >= 0 ? pair.substring(0, eq) : pair;
+ String value = eq >= 0 ? pair.substring(eq + 1) : "";
+ params.add(URLDecoder.decode(key, StandardCharsets.UTF_8),
+ URLDecoder.decode(value, StandardCharsets.UTF_8));
+ }
+ return params;
+ }
+
// ──────────────────────────── Path matching ────────────────────────────
/**
diff --git a/src/main/java/io/github/hectorvent/floci/services/apigateway/AwsServiceRouter.java b/src/main/java/io/github/hectorvent/floci/services/apigateway/AwsServiceRouter.java
index 4d940746e9..d3570d9f5f 100644
--- a/src/main/java/io/github/hectorvent/floci/services/apigateway/AwsServiceRouter.java
+++ b/src/main/java/io/github/hectorvent/floci/services/apigateway/AwsServiceRouter.java
@@ -13,10 +13,12 @@ import io.github.hectorvent.floci.services.kms.KmsJsonHandler;
import io.github.hectorvent.floci.services.secretsmanager.SecretsManagerJsonHandler;
import io.github.hectorvent.floci.services.sns.SnsJsonHandler;
import io.github.hectorvent.floci.services.sqs.SqsJsonHandler;
+import io.github.hectorvent.floci.services.sqs.SqsQueryHandler;
import io.github.hectorvent.floci.services.ssm.SsmJsonHandler;
import io.github.hectorvent.floci.services.stepfunctions.StepFunctionsJsonHandler;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
+import jakarta.ws.rs.core.MultivaluedMap;
import jakarta.ws.rs.core.Response;
import org.jboss.logging.Logger;
@@ -35,6 +37,7 @@ public class AwsServiceRouter {
private final StepFunctionsJsonHandler stepFunctionsHandler;
private final DynamoDbJsonHandler dynamoDbHandler;
private final SqsJsonHandler sqsHandler;
+ private final SqsQueryHandler sqsQueryHandler;
private final SnsJsonHandler snsHandler;
private final EventBridgeHandler eventBridgeHandler;
private final SsmJsonHandler ssmHandler;
@@ -50,6 +53,7 @@ public class AwsServiceRouter {
public AwsServiceRouter(StepFunctionsJsonHandler stepFunctionsHandler,
DynamoDbJsonHandler dynamoDbHandler,
SqsJsonHandler sqsHandler,
+ SqsQueryHandler sqsQueryHandler,
SnsJsonHandler snsHandler,
EventBridgeHandler eventBridgeHandler,
SsmJsonHandler ssmHandler,
@@ -63,6 +67,7 @@ public class AwsServiceRouter {
this.stepFunctionsHandler = stepFunctionsHandler;
this.dynamoDbHandler = dynamoDbHandler;
this.sqsHandler = sqsHandler;
+ this.sqsQueryHandler = sqsQueryHandler;
this.snsHandler = snsHandler;
this.eventBridgeHandler = eventBridgeHandler;
this.ssmHandler = ssmHandler;
@@ -81,8 +86,16 @@ public class AwsServiceRouter {
public record IntegrationTarget(String region, String service, String action) {}
/**
- * Parses an integration URI like
- * {@code arn:aws:apigateway:us-east-1:states:action/StartExecution}.
+ * Parses an integration URI in either of the two forms AWS accepts:
+ *
+ * <ul>
+ * <li><b>action</b> — {@code arn:aws:apigateway:{region}:{service}:action/{Action}}.
+ * The action is encoded in the URI and the request template renders a JSON body.</li>
+ * <li><b>path</b> — {@code arn:aws:apigateway:{region}:{service}:path/{resourcePath}}.
+ * The action is not in the URI; it is carried in the rendered request body
+ * (the AWS query protocol, e.g. {@code Action=SendMessage&...}). For this form
+ * {@link IntegrationTarget#action()} is {@code null}.</li>
+ * </ul>
*
* @return parsed target, or null if the URI format is not recognized
*/
@@ -90,20 +103,27 @@ public class AwsServiceRouter {
if (uri == null || !uri.startsWith("arn:aws:apigateway:")) {
return null;
}
- // arn:aws:apigateway:{region}:{service}:action/{Action}
+ // arn:aws:apigateway:{region}:{service}:{action/{Action}|path/{resourcePath}}
String[] parts = uri.split(":");
if (parts.length < 6) {
return null;
}
String region = parts[3];
String service = parts[4];
- // parts[5] should be "action/{ActionName}"
- String actionPart = parts[5];
- if (!actionPart.startsWith("action/")) {
- return null;
+ // parts[5] is either "action/{ActionName}" or "path/{resourcePath}".
+ // A path may itself contain ':' (rare), so re-join the remainder.
+ String resourceSpec = parts.length > 6
+ ? String.join(":", java.util.Arrays.copyOfRange(parts, 5, parts.length))
+ : parts[5];
+ if (resourceSpec.startsWith("action/")) {
+ String action = resourceSpec.substring("action/".length());
+ return new IntegrationTarget(region, service, action);
+ }
+ if (resourceSpec.startsWith("path/")) {
+ // Action is supplied by the rendered request body (query protocol).
+ return new IntegrationTarget(region, service, null);
}
- String action = actionPart.substring("action/".length());
- return new IntegrationTarget(region, service, action);
+ return null;
}
/**
@@ -143,4 +163,40 @@ public class AwsServiceRouter {
e.getMessage() != null ? e.getMessage() : "Service invocation failed", 500);
}
}
+
+ /**
+ * Dispatches an AWS query-protocol (form-encoded) integration request.
+ *
+ * <p>Used for {@code path/}-style integration URIs whose VTL request template renders an
+ * {@code application/x-www-form-urlencoded} body in the AWS query protocol, e.g.
+ * {@code Action=SendMessage&QueueUrl=...&MessageBody=...}. The {@code Action} parameter
+ * selects the operation, mirroring {@link io.github.hectorvent.floci.core.common.AwsQueryController}.
+ *
+ * @param service the AWS service name from the URI (e.g., "sqs")
+ * @param params the parsed form parameters, including {@code Action}
+ * @param region the AWS region
+ * @return the service response (query-protocol XML)
+ */
+ public Response invokeQuery(String service, MultivaluedMap<String, String> params, String region) {
+ String action = params.getFirst("Action");
+ LOG.debugv("AWS query integration dispatch: {0}:{1} in {2}", service, action, region);
+
+ if (action == null || action.isBlank()) {
+ throw new AwsException("MissingAction",
+ "The request must contain the parameter Action", 400);
+ }
+
+ try {
+ return switch (service) {
+ case "sqs" -> sqsQueryHandler.handle(action, params, region);
+ default -> throw new AwsException("UnknownService",
+ "Unsupported AWS query-protocol service integration: " + service, 400);
+ };
+ } catch (AwsException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new AwsException("InternalError",
+ e.getMessage() != null ? e.getMessage() : "Service invocation failed", 500);
+ }
+ }
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewaySqsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewaySqsIntegrationTest.java
new file mode 100644
index 0000000000..75a1c85bb7
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/apigateway/ApiGatewaySqsIntegrationTest.java
@@ -0,0 +1,171 @@
+package io.github.hectorvent.floci.services.apigateway;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.http.ContentType;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+/**
+ * Integration tests for the API Gateway → SQS AWS integration using the path-style
+ * integration URI ({@code arn:aws:apigateway:{region}:sqs:path/{account}/{queue}}) and an
+ * {@code application/x-www-form-urlencoded} request template that renders the SQS query
+ * protocol ({@code Action=SendMessage&QueueUrl=...&MessageBody=...}).
+ *
+ * <p>This mirrors the canonical AWS recipe for exposing an SQS queue through API Gateway —
+ * the same pattern real services and LocalStack use.
+ */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class ApiGatewaySqsIntegrationTest {
+
+ private static final ObjectMapper mapper = new ObjectMapper();
+ private static final String QUEUE_NAME = "apigw-sqs-test";
+
+ private static String apiId;
+ private static String rootId;
+ private static String resourceId;
+ private static String queueUrl;
+
+ // ──────────────── Setup: SQS queue ────────────────
+
+ @Test @Order(0)
+ void setup_createQueue() {
+ queueUrl = given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "CreateQueue")
+ .formParam("QueueName", QUEUE_NAME)
+ .when().post("/")
+ .then().statusCode(200)
+ .body(containsString("<QueueUrl>"))
+ .extract().xmlPath().getString("CreateQueueResponse.CreateQueueResult.QueueUrl");
+ assertNotNull(queueUrl);
+ }
+
+ // ──────────────── Setup: API Gateway REST API ────────────────
+
+ @Test @Order(1)
+ void setup_createRestApi() {
+ apiId = given()
+ .contentType(ContentType.JSON)
+ .body("{\"name\":\"sqs-integration-test\",\"description\":\"APIGW → SQS\"}")
+ .when().post("/restapis")
+ .then().statusCode(201)
+ .extract().path("id");
+ assertNotNull(apiId);
+ }
+
+ @Test @Order(2)
+ void setup_getRootResource() {
+ rootId = given()
+ .when().get("/restapis/" + apiId + "/resources")
+ .then().statusCode(200)
+ .extract().path("item[0].id");
+ assertNotNull(rootId);
+ }
+
+ @Test @Order(3)
+ void setup_createResource() {
+ resourceId = given()
+ .contentType(ContentType.JSON)
+ .body("{\"pathPart\":\"send\"}")
+ .when().post("/restapis/" + apiId + "/resources/" + rootId)
+ .then().statusCode(201)
+ .extract().path("id");
+ assertNotNull(resourceId);
+ }
+
+ @Test @Order(4)
+ void setup_configureMethod() throws Exception {
+ // POST method, no auth.
+ given()
+ .contentType(ContentType.JSON)
+ .body("{\"authorizationType\":\"NONE\"}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId + "/methods/POST")
+ .then().statusCode(201);
+
+ // AWS integration targeting SQS via the path-style URI. The request template renders
+ // the SQS query protocol; the Content-Type override marks the body form-urlencoded.
+ var integrationNode = mapper.createObjectNode();
+ integrationNode.put("type", "AWS");
+ integrationNode.put("httpMethod", "POST");
+ integrationNode.put("uri", "arn:aws:apigateway:us-east-1:sqs:path/000000000000/" + QUEUE_NAME);
+ integrationNode.put("passthroughBehavior", "NEVER");
+
+ var reqParams = mapper.createObjectNode();
+ reqParams.put("integration.request.header.Content-Type", "'application/x-www-form-urlencoded'");
+ integrationNode.set("requestParameters", reqParams);
+
+ var reqTemplates = mapper.createObjectNode();
+ String vtl = "Action=SendMessage"
+ + "&QueueUrl=$util.urlEncode(\"" + queueUrl + "\")"
+ + "&MessageBody=$util.urlEncode($input.body)";
+ reqTemplates.put("application/json", vtl);
+ integrationNode.set("requestTemplates", reqTemplates);
+
+ given()
+ .contentType(ContentType.JSON)
+ .body(mapper.writeValueAsString(integrationNode))
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId + "/methods/POST/integration")
+ .then().statusCode(201);
+
+ // Default 200 integration response (no response template — pass the SQS XML through).
+ given()
+ .contentType(ContentType.JSON)
+ .body("{\"selectionPattern\":\"\"}")
+ .when().put("/restapis/" + apiId + "/resources/" + resourceId
+ + "/methods/POST/integration/responses/200")
+ .then().statusCode(201);
+ }
+
+ @Test @Order(5)
+ void setup_deployAndCreateStage() {
+ String deploymentId = given()
+ .contentType(ContentType.JSON)
+ .body("{\"description\":\"test\"}")
+ .when().post("/restapis/" + apiId + "/deployments")
+ .then().statusCode(201)
+ .extract().path("id");
+
+ given()
+ .contentType(ContentType.JSON)
+ .body("{\"stageName\":\"test\",\"deploymentId\":\"" + deploymentId + "\"}")
+ .when().post("/restapis/" + apiId + "/stages")
+ .then().statusCode(201);
+ }
+
+ // ──────────────── Test: APIGW → SQS SendMessage ────────────────
+
+ @Test @Order(10)
+ void sqsIntegration_sendMessage() {
+ // The integration returns the SQS query-protocol XML response.
+ given()
+ .contentType(ContentType.JSON)
+ .body("{\"hello\":\"world\"}")
+ .when().post("/execute-api/" + apiId + "/test/send")
+ .then()
+ .statusCode(200)
+ .body(containsString("<SendMessageResponse"))
+ .body(containsString("<MessageId>"))
+ .body(containsString("<MD5OfMessageBody>"));
+ }
+
+ @Test @Order(11)
+ void sqsIntegration_messageLandsOnQueue() {
+ // The body the producer POSTed should be the MessageBody now sitting on the queue.
+ given()
+ .contentType("application/x-www-form-urlencoded")
+ .formParam("Action", "ReceiveMessage")
+ .formParam("QueueUrl", queueUrl)
+ .formParam("MaxNumberOfMessages", "1")
+ .when().post("/")
+ .then().statusCode(200)
+ .body(containsString("<Body>{&quot;hello&quot;:&quot;world&quot;}</Body>"));
+ }
+}