Allow generateParameterMap to optionally decode query params (for ALB requests)

Author: jpfennelly

aws-serverless-java-container-core/src/main/java/com/amazonaws/serverless/proxy/internal/servlet/AwsHttpServletRequest.java

@@ -584,7 +584,7 @@ private void addPart(Map<String, List<Part>> params, String fieldName, Part newP
 
     protected String[] getQueryParamValues(MultiValuedTreeMap<String, String> qs, String key, boolean isCaseSensitive) {
         List<String> value = getQueryParamValuesAsList(qs, key, isCaseSensitive);
-        if (value == null){
+        if (value == null) {
             return null;
         }
         return value.toArray(new String[0]);
@@ -607,39 +607,57 @@ protected List<String> getQueryParamValuesAsList(MultiValuedTreeMap<String, Stri
     }
 
     protected Map<String, String[]> generateParameterMap(MultiValuedTreeMap<String, String> qs, ContainerConfig config) {
+    	return generateParameterMap(qs, config, false);
+    }
+    
+    protected Map<String, String[]> generateParameterMap(MultiValuedTreeMap<String, String> qs, ContainerConfig config, boolean decodeQueryParams) {
         Map<String, String[]> output;
 
         Map<String, List<String>> formEncodedParams = getFormUrlEncodedParametersMap();
 
         if (qs == null) {
             // Just transform the List<String> values to String[]
-            output = formEncodedParams.entrySet().stream()
+            return formEncodedParams.entrySet().stream()
                 .collect(Collectors.toMap(Map.Entry::getKey, (e) -> e.getValue().toArray(new String[0])));
-        } else {
-            Map<String, List<String>> queryStringParams;
-            if (config.isQueryStringCaseSensitive()) {
-                queryStringParams = qs;
-            } else {
-                // If it's case insensitive, we check the entire map on every parameter
-                queryStringParams = qs.entrySet().stream().parallel().collect(
-                    Collectors.toMap(
-                        Map.Entry::getKey,
-                        e -> getQueryParamValuesAsList(qs, e.getKey(), false)
-                    ));
-            }
-
-            // Merge formEncodedParams and queryStringParams Maps
-            output = Stream.of(formEncodedParams, queryStringParams).flatMap(m -> m.entrySet().stream())
-                .collect(
-                    Collectors.toMap(
-                        Map.Entry::getKey,
-                        e -> e.getValue().toArray(new String[0]),
-                        // If a parameter is in both Maps, we merge the list of values (and ultimately transform to String[])
-                        (formParam, queryParam) -> Stream.of(formParam, queryParam).flatMap(Stream::of).toArray(String[]::new)
-                    ));
-
         }
 
+    	// decode all keys and values in map
+    	final MultiValuedTreeMap<String, String> decodedQs = new MultiValuedTreeMap<String, String>();
+    	if (decodeQueryParams) {
+    		for (Map.Entry<String, List<String>> entry : qs.entrySet()) {
+    			String k = decodeValueIfEncoded(entry.getKey());
+    			List<String> v = getQueryParamValuesAsList(qs, entry.getKey(), false).stream()
+						.map(AwsHttpServletRequest::decodeValueIfEncoded)
+						.collect(Collectors.toList());
+    			// addAll in case map has 2 keys that are identical once decoded
+    			decodedQs.addAll(k, v);
+			}
+    	} else {
+    		decodedQs.putAll(qs);
+    	}
+    	
+    	Map<String, List<String>> queryStringParams;
+        if (config.isQueryStringCaseSensitive()) {
+            queryStringParams = decodedQs;
+        } else {
+            // If it's case insensitive, we check the entire map on every parameter
+            queryStringParams = decodedQs.entrySet().stream().collect(
+                Collectors.toMap(
+                    Map.Entry::getKey,
+                    e -> getQueryParamValuesAsList(decodedQs, e.getKey(), false)
+                ));
+        }
+
+        // Merge formEncodedParams and queryStringParams Maps
+        output = Stream.of(formEncodedParams, queryStringParams).flatMap(m -> m.entrySet().stream())
+            .collect(
+                Collectors.toMap(
+                    Map.Entry::getKey,
+                    e -> e.getValue().toArray(new String[0]),
+                    // If a parameter is in both Maps, we merge the list of values (and ultimately transform to String[])
+                    (formParam, queryParam) -> Stream.of(formParam, queryParam).flatMap(Stream::of).toArray(String[]::new)
+                ));
+
         return output;
     }
 

aws-serverless-java-container-core/src/test/java/com/amazonaws/serverless/proxy/internal/servlet/AwsHttpServletRequestTest.java

@@ -331,6 +331,23 @@ void parameterMapWithEncodedParams_generateParameterMap_validQuery() {
         assertTrue(paramMap.size() == 2);
     }
 
+    @Test
+    void parameterMapWithEncodedParams_alb_generateParameterMap_validQuery() {
+        AwsProxyHttpServletRequest request = new AwsProxyHttpServletRequest(encodedQueryStringAlb, mockContext, null, config);
+
+        Map<String, String[]> paramMap = null;
+        try {
+            paramMap = request.generateParameterMap(request.getAwsProxyRequest().getMultiValueQueryStringParameters(), config, true);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail("Could not generate parameter map");
+        }
+
+        assertArrayEquals(new String[]{"two"}, paramMap.get("one"));
+        assertArrayEquals(new String[]{"{\"name\":\"faisal\"}"}, paramMap.get("json"));
+        assertTrue(paramMap.size() == 2);
+    }
+
     @Test
     void parameterMapWithMultipleValues_generateParameterMap_validQuery() {
         AwsProxyHttpServletRequest request = new AwsProxyHttpServletRequest(multipleParams, mockContext, null, config);