AWS Compute Blog
Support for multi-value parameters in Amazon API Gateway
This post is courtesy of Akash Jain, Partner Solutions Architect – AWS
The new multi-value parameter support feature for Amazon API Gateway allows you to pass multiple values for the same key in the header and query string as part of your API request. It also allows you to pass multi-value headers in the API response to implement things like sending multiple Set-Cookie headers.
As part of this feature, AWS added two new keys:
- multiValueQueryStringParameters—Used in the API Gateway request to support a multi-valued parameter in the query string.
- multiValueHeaders—Used in both the request and response to support multi-valued headers.
In this post, I walk you through examples for using this feature by extending the PetStore API. You add pet search functionality to the PetStore API and then add personalization by setting the language and UI theme cookies.
The following AWS CloudFormation stack creates all resources for both examples. The stack:
- Creates the extended PetStore API represented using the OpenAPI 3.0 standard.
- Creates three AWS Lambda functions. One each for implementing the pet search, get user profile, and set user profile functionality.
- Creates two IAM roles. The Lambda function assumes one and API Gateway assumes the other to call the Lambda function.
- Deploys the PetStore API to Staging.
Add pet search functionality to the PetStore API
As part of adding the search feature, I demonstrate how you can use multiValueQueryStringParameters for sending and retrieving multi-valued parameters in a query string.
Use the PetStore example API available in the API Gateway console and create a /search resource type under the /pets resource type with GET (read) access. Then, configure the GET method to use AWS Lambda proxy integration.
The CloudFormation stack launched earlier gives you the PetStore API staging endpoint as an output that you can use for testing the search functionality. Assume that the user has an interface to enter the pet types for searching and wants to search for “dog” and “fish.” The pet search API request looks like the following where the petType parameter is multi-valued:
https://xxxx.execute-api.us-east-1.amazonaws.com/staging/pets/search?petType=dog&petType=fish
When you invoke the pet search API action, you get a successful response with both the dog and fish details:
[
{
"id": 11212,
"type": "dog",
"price": 249.99
},
{
"id": 31231
"type": "fish",
"price": 0.99
}
]Processing multi-valued query string parameters
Here’s how the multi-valued parameter petType with value “petType=dog&petType=fish” gets processed by API Gateway. To demonstrate, here’s the input event sent by API Gateway to the Lambda function. The log details follow. As it was a long input, a few keys have been removed for brevity.
There is a new key, multiValueQueryStringParameters, available in the input event. This key is added as part of the multi-value parameter feature to retain multiple values for the same parameter in the query string.
Before this change, API Gateway used to retain only the last value and drop everything else for a multi-valued parameter. You can see the original behavior in the queryStringParameters parameter in the above input, where only the “fish” value is retained.
Accessing the new multiValueQueryStringParameters key in a Lambda function
Use the new multiValueQueryStringParameters key available in the event context of the Lambda function to retrieve the multi-valued query string parameter petType that you passed in the query string of the search API request. You can use that value for searching pets. Retrieve the parameter values from the event context by parsing the event event.multiValueQueryStringParameters.petType.
exports.handler = (event, context, callback) => {
//Log the input event
console.log(event)
//Extract multi-valued parameter from input
var petTypes = event.multiValueQueryStringParameters.petType;
//call search pets functionality
var searchResults = searchPets(petTypes)
const response = {
statusCode: 200,
body: searchResults
};
callback(null, response);
};The multiValueQueryStringParameters key is present in the input request regardless of whether the request contains keys with multiple values. You don’t have to change your APIs to enable this feature, unless you are using a key of the same name as multiValueQueryStringParameters.
Add personalization
Here’s how the newly added multiValueHeaders key is useful for sending cookies with multiple Set-Cookie headers in an API response.
Personalize the Pet Store web application by setting a user-specific theme and language settings. Usually, web developers use cookies to store this kind of information. To accomplish this, send cookies that store theme and language information as part of the API response. The browser then stores them and the web application uses them to get the required information.
To set the cookies, you need the new API resources /users and /profiles, with read and write access in the PetStore API. Then, configure the GET and POST methods of the /profile resource to use AWS Lambda proxy integration. The CloudFormation stack that you launched earlier has already created the necessary resources.
Invoke the POST profile API call with the following request body. It is passing the user preferences for language and theme and returning the Set-Cookie headers:
https://XXXXXX.execute-api.us-east-1.amazonaws.com/staging/users/profile
The request body looks like the following:
{
"userid" : 123456456,
"preferences" : {"language":"en-US", "theme":"blue moon"}
}You get a successful response with the “200 OK” status code and two Set-Cookie headers for setting the language and theme cookies.
Passing multiple Set-Cookie headers in the response
The following code example is the setUserProfile Lambda function code that processes the input request and sends the language and theme cookies:
exports.handler = (event, context, callback) => {
//Get the request body
var requestBody = JSON.parse(event.body);
//Retrieve the language and theme values
var language = requestBody.preferences.language;
var theme = requestBody.preferences.theme;
const response = {
isBase64Encoded: true,
statusCode: 200,
multiValueHeaders : {"Set-Cookie": [`language=${language}`, `theme=${theme}`]},
body: JSON.stringify('User profile set successfully')
};
callback(null, response);
};You can see the newly added multiValueHeaders key passes multiple cookies as a list in the response. The multiValueHeaders header is translated to multiple Set-Cookie headers by API Gateway and appears to the API client as the following:
Set-Cookie →language=en-US
Set-Cookie →theme=blue moon
You can also pass the header key along with the multiValueHeaders key. In that case, API Gateway merges the multiValueHeaders and headers maps while processing the integration response into a single Map<String, List<String>> value. If the same key-value pair is sent in both, it isn’t duplicated.
Retrieving the headers from the request
If you use the Postman tool (or something similar) to invoke the GET profile API call, you can send cookies as part of the request. The theme and language cookie that you set above in the POST /profile API request can now be sent as part of the GET /profile request.
https://xxx.execute-api.us-east-1.amazonaws.com/staging/users/profile
You get the following response with the details of the user preferences:
{
"userId": 12343,
"preferences": {
"language": "en-US",
"theme": "beige"
}
}When you log the input event of the getUserProfile Lambda function, you can see both newly added keys multiValueQueryStringParameters and multiValueHeaders. These keys are present in the event context of the Lambda function regardless of whether there is a value. You can retrieve the value by parsing the event context event.multiValueHeaders.Cookie.
HTTP proxy integration
For the API Gateway HTTP proxy integration, the headers and query string are proxied to the downstream HTTP call in the same way that they are invoked. The newly added keys aren’t present in the request or response. For example, the petType parameter from the search API goes as a list to the HTTP endpoint.
Similarly, for setting multiple Set-Cookie headers, you can set them the way that you would usually. For Node.js, it looks like the following:
res.setHeader("Set-Cookie", ["theme=beige", "language=en-US"]);Mapping requests and responses for new keys
For mapping requests, you can access new keys by parsing the method request like method.request.multivaluequerystring.<KeyName> and method.request.multivalueheader.<HeaderName>. For mapping responses, you would parse the integration response like integration.response.multivalueheaders.<HeaderName>.
For example, the following is the search pet API request example:
curl https://{hostname}/pets/search?petType=dog&petType=fish \
-H 'cookie: language=en-US' \
-H 'cookie: theme=beige'The new request mapping looks like the following:
"requestParameters" : {
"integration.request.querystring.petType" : "method.request.multivaluequerystring.petType",
"integration.request.header.cookie" : "method.request.multivalueheader.cookie"
}The new response mapping looks like the following:
"responseParameters" : {
"method.response.header.Set-Cookie" : "integration.response.multivalueheaders.Set-Cookie",
...
}For more information, see Set up Lambda Proxy Integrations in API Gateway.
Cleanup
To avoid incurring ongoing charges for the resources that you’ve used, delete the CloudFormation stack that you created earlier.
Conclusion
Multi-value parameter support enables you to pass multi-valued parameters in the query string and multi-valued headers as part of your API response. Both the multiValueQueryStringParameters and multiValueHeaders keys are present in the input request to Lambda function regardless of whether there is a value. These keys are also accessible for mapping requests and responses.