api-dock 0.6.0__tar.gz → 0.7.0__tar.gz

{api_dock-0.6.0 → api_dock-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api_dock
-Version: 0.6.0
+Version: 0.7.0
 Summary: A flexible API gateway that allows you to proxy requests to multiple remote APIs and Databases
 Author-email: Brookie Guzder-Williams <bguzder-williams@berkeley.edu>
 License-Expression: BSD-3-Clause
@@ -218,6 +218,7 @@ remotes:
 settings:
   add_trailing_slash: true              # Auto-add trailing slash to paths (default: true)
   follow_protocol_downgrades: false     # Allow HTTPS->HTTP redirects (default: false)
+  timeout: 10                           # Upstream request timeout in seconds (default: 10)
 ```
 
 ### HTTP behavior Settings
@@ -228,6 +229,8 @@ The optional `settings` section controls HTTP behavior:
 
 - **`follow_protocol_downgrades`** (default: `false`): Control how HTTP redirects are handled. When `false` (recommended), HTTPS→HTTP redirects are blocked for security. When `true`, allows following redirects that downgrade from HTTPS to HTTP (not recommended for production).
 
+- **`timeout`** (default: `10`): Upstream request timeout in seconds, applied to both the streaming and buffered proxy paths. Raise it for slow upstreams (e.g. large aggregation queries) that would otherwise return a 502 on timeout. Set to `null` or `false` to disable the timeout entirely (not recommended — a stalled upstream can hold the connection open indefinitely).
+
 ---
 
 ## Remote Configurations
@@ -463,6 +466,34 @@ GET /db/users
 # SQL: SELECT * FROM users WHERE height < 200
 ```
 
+### Repeated Parameters with `multivalue_sql`
+
+A query parameter key can appear more than once in the URL (e.g. `?recording_id=1&recording_id=4`). Add a `multivalue_sql` template alongside `sql` to handle this: when **more than one** value is passed for the key, `multivalue_sql` is used instead of `sql`, and `{{param}}` expands to a parenthesized, quote-escaped SQL value list suitable for an `IN` clause.
+
+Behavior is unchanged when `multivalue_sql` is absent, and when only a single value is passed the normal `sql` template is used.
+
+```yaml
+routes:
+  - route: detections
+    sql: SELECT [[detections]].* FROM [[detections]]
+    query_params:
+      - recording_id:
+          sql: "[[detections]].recording_id = {{recording_id}}"            # single value
+          multivalue_sql: "[[detections]].recording_id IN {{recording_id}}"  # 2+ values
+      - scientific_name:
+          sql: "[[detections]].scientific_name = '{{scientific_name}}'"
+```
+
+```bash
+GET /db/detections?recording_id=4&scientific_name=Gryllus%20fultoni
+# SQL: SELECT detections.* FROM detections
+#      WHERE detections.recording_id = '4' AND detections.scientific_name = 'Gryllus fultoni'
+
+GET /db/detections?recording_id=4&recording_id=1&scientific_name=Gryllus%20fultoni
+# SQL: SELECT detections.* FROM detections
+#      WHERE detections.recording_id IN ('4', '1') AND detections.scientific_name = 'Gryllus fultoni'
+```
+
 ### Sorting and Pagination with `sql_append`
 
 Use `sql_append` to append clauses *after* the WHERE clause — for `ORDER BY`, `LIMIT`, `OFFSET`, etc. Fragments are appended in the order they appear in the YAML config, so **the YAML order must match valid SQL order** (ORDER BY before LIMIT before OFFSET).
@@ -1170,8 +1201,6 @@ pixi run python scripts/hello_world.py
 
 ---
 
----
-
 # Development
 
 ## Publishing a Release
@@ -1183,11 +1212,11 @@ pixi run python scripts/hello_world.py
 
 # 2. Commit everything
 git add -A
-git commit -m "v0.6.0: proxy passthrough fixes, cookie injection"
+git commit -m "v0.6.1: stream proxy responses (fix large-response 502 + content-encoding)"
 
 # 3. Tag and push
-git tag v0.6.0
-git push origin main v0.6.0
+git tag v0.6.1
+git push origin main v0.6.1
 
 # 4. Build the wheel (requires the `dev` pixi environment)
 rm -rf dist/
@@ -1197,21 +1226,19 @@ pixi run -e dev python -m build --wheel
 ls dist/*.whl
 
 # 5. Create GitHub release with the wheel attached
-gh release create v0.6.0 dist/api_dock-0.6.0-py3-none-any.whl \
-    --title "v0.6.0" --notes "$(cat <<'EOF'
+gh release create v0.6.1 dist/api_dock-0.6.1-py3-none-any.whl \
+    --title "v0.6.1" --notes "$(cat <<'EOF'
 * new features
-    - Cookie injection: dict entries in the `cookies` list inject server-side cookies into upstream requests, with `env:MY_VAR` env var support and literal value support
+    - Remote proxy responses are now streamed (FastAPI) — upstream bytes are piped to the client as they arrive instead of being buffered fully in memory
+    - New `timeout` setting (default 10s) for the upstream request; set to `null`/`false` to disable
 * bug fixes
-    - Binary responses (image, audio) no longer corrupted — raw bytes passed through with correct content-type
-    - 3xx redirects returned to client when `follow_redirects: false` (previously followed internally, doubling egress)
-    - Upstream response headers (Cache-Control, ETag, Last-Modified, etc.) now forwarded to client
-    - Upstream 4xx/5xx error bodies passed through verbatim (previously wrapped/swallowed)
-    - JSON responses no longer re-serialized — raw bytes returned as-is, preserving exact upstream payload
+    - Large upstream responses no longer return 502 — streamed via `StreamingResponse` instead of reading the whole body into memory
+    - `Content-Encoding` (gzip/br/deflate) is now preserved on compressed responses — raw bytes are streamed via `aiter_raw()` so the header stays valid and the client can decompress
+    - Slow upstreams (e.g. large aggregation queries) no longer 502 at httpx's hardcoded 5s default — the timeout is now configurable via the `timeout` setting
 * cleanup / other improvements
-    - Added `ProxyResponse` typed dataclass as the return contract for `map_route()` and `map_database_route()`
-    - Added test suite (38 tests covering proxy pipeline and cookie injection)
-    - Removed broken root `__init__.py` that caused pytest import conflicts
-    - Bumped cryptography dependency to >=48.0.0,<49.0.0
+    - Added `PreparedRequest` dataclass and split route validation/resolution into `RouteMapper.prepare_remote_request()`; the FastAPI adapter issues the streaming HTTP call
+    - `map_route()` (buffered) retained for the Flask/sync path
+    - Added streaming test coverage (`TestStreamUpstream`, plus `prepare_remote_request` and streaming-header tests) — 53 tests total
 EOF
 )"
 

{api_dock-0.6.0 → api_dock-0.7.0}/README.md

@@ -179,6 +179,7 @@ remotes:
 settings:
   add_trailing_slash: true              # Auto-add trailing slash to paths (default: true)
   follow_protocol_downgrades: false     # Allow HTTPS->HTTP redirects (default: false)
+  timeout: 10                           # Upstream request timeout in seconds (default: 10)
 ```
 
 ### HTTP behavior Settings
@@ -189,6 +190,8 @@ The optional `settings` section controls HTTP behavior:
 
 - **`follow_protocol_downgrades`** (default: `false`): Control how HTTP redirects are handled. When `false` (recommended), HTTPS→HTTP redirects are blocked for security. When `true`, allows following redirects that downgrade from HTTPS to HTTP (not recommended for production).
 
+- **`timeout`** (default: `10`): Upstream request timeout in seconds, applied to both the streaming and buffered proxy paths. Raise it for slow upstreams (e.g. large aggregation queries) that would otherwise return a 502 on timeout. Set to `null` or `false` to disable the timeout entirely (not recommended — a stalled upstream can hold the connection open indefinitely).
+
 ---
 
 ## Remote Configurations
@@ -424,6 +427,34 @@ GET /db/users
 # SQL: SELECT * FROM users WHERE height < 200
 ```
 
+### Repeated Parameters with `multivalue_sql`
+
+A query parameter key can appear more than once in the URL (e.g. `?recording_id=1&recording_id=4`). Add a `multivalue_sql` template alongside `sql` to handle this: when **more than one** value is passed for the key, `multivalue_sql` is used instead of `sql`, and `{{param}}` expands to a parenthesized, quote-escaped SQL value list suitable for an `IN` clause.
+
+Behavior is unchanged when `multivalue_sql` is absent, and when only a single value is passed the normal `sql` template is used.
+
+```yaml
+routes:
+  - route: detections
+    sql: SELECT [[detections]].* FROM [[detections]]
+    query_params:
+      - recording_id:
+          sql: "[[detections]].recording_id = {{recording_id}}"            # single value
+          multivalue_sql: "[[detections]].recording_id IN {{recording_id}}"  # 2+ values
+      - scientific_name:
+          sql: "[[detections]].scientific_name = '{{scientific_name}}'"
+```
+
+```bash
+GET /db/detections?recording_id=4&scientific_name=Gryllus%20fultoni
+# SQL: SELECT detections.* FROM detections
+#      WHERE detections.recording_id = '4' AND detections.scientific_name = 'Gryllus fultoni'
+
+GET /db/detections?recording_id=4&recording_id=1&scientific_name=Gryllus%20fultoni
+# SQL: SELECT detections.* FROM detections
+#      WHERE detections.recording_id IN ('4', '1') AND detections.scientific_name = 'Gryllus fultoni'
+```
+
 ### Sorting and Pagination with `sql_append`
 
 Use `sql_append` to append clauses *after* the WHERE clause — for `ORDER BY`, `LIMIT`, `OFFSET`, etc. Fragments are appended in the order they appear in the YAML config, so **the YAML order must match valid SQL order** (ORDER BY before LIMIT before OFFSET).
@@ -1131,8 +1162,6 @@ pixi run python scripts/hello_world.py
 
 ---
 
----
-
 # Development
 
 ## Publishing a Release
@@ -1144,11 +1173,11 @@ pixi run python scripts/hello_world.py
 
 # 2. Commit everything
 git add -A
-git commit -m "v0.6.0: proxy passthrough fixes, cookie injection"
+git commit -m "v0.6.1: stream proxy responses (fix large-response 502 + content-encoding)"
 
 # 3. Tag and push
-git tag v0.6.0
-git push origin main v0.6.0
+git tag v0.6.1
+git push origin main v0.6.1
 
 # 4. Build the wheel (requires the `dev` pixi environment)
 rm -rf dist/
@@ -1158,21 +1187,19 @@ pixi run -e dev python -m build --wheel
 ls dist/*.whl
 
 # 5. Create GitHub release with the wheel attached
-gh release create v0.6.0 dist/api_dock-0.6.0-py3-none-any.whl \
-    --title "v0.6.0" --notes "$(cat <<'EOF'
+gh release create v0.6.1 dist/api_dock-0.6.1-py3-none-any.whl \
+    --title "v0.6.1" --notes "$(cat <<'EOF'
 * new features
-    - Cookie injection: dict entries in the `cookies` list inject server-side cookies into upstream requests, with `env:MY_VAR` env var support and literal value support
+    - Remote proxy responses are now streamed (FastAPI) — upstream bytes are piped to the client as they arrive instead of being buffered fully in memory
+    - New `timeout` setting (default 10s) for the upstream request; set to `null`/`false` to disable
 * bug fixes
-    - Binary responses (image, audio) no longer corrupted — raw bytes passed through with correct content-type
-    - 3xx redirects returned to client when `follow_redirects: false` (previously followed internally, doubling egress)
-    - Upstream response headers (Cache-Control, ETag, Last-Modified, etc.) now forwarded to client
-    - Upstream 4xx/5xx error bodies passed through verbatim (previously wrapped/swallowed)
-    - JSON responses no longer re-serialized — raw bytes returned as-is, preserving exact upstream payload
+    - Large upstream responses no longer return 502 — streamed via `StreamingResponse` instead of reading the whole body into memory
+    - `Content-Encoding` (gzip/br/deflate) is now preserved on compressed responses — raw bytes are streamed via `aiter_raw()` so the header stays valid and the client can decompress
+    - Slow upstreams (e.g. large aggregation queries) no longer 502 at httpx's hardcoded 5s default — the timeout is now configurable via the `timeout` setting
 * cleanup / other improvements
-    - Added `ProxyResponse` typed dataclass as the return contract for `map_route()` and `map_database_route()`
-    - Added test suite (38 tests covering proxy pipeline and cookie injection)
-    - Removed broken root `__init__.py` that caused pytest import conflicts
-    - Bumped cryptography dependency to >=48.0.0,<49.0.0
+    - Added `PreparedRequest` dataclass and split route validation/resolution into `RouteMapper.prepare_remote_request()`; the FastAPI adapter issues the streaming HTTP call
+    - `map_route()` (buffered) retained for the Flask/sync path
+    - Added streaming test coverage (`TestStreamUpstream`, plus `prepare_remote_request` and streaming-header tests) — 53 tests total
 EOF
 )"
 

{api_dock-0.6.0 → api_dock-0.7.0}/api_dock/config.py

@@ -670,25 +670,29 @@ def find_route_mapping(full_route: str, method: str, remote_config: Dict[str, An
 
 
 def filter_remote_query_params(
-    query_params: Dict[str, str],
+    query_params: Dict[str, Any],
     route: str,
     method: str,
     remote_config: Dict[str, Any]
-) -> Dict[str, str]:
+) -> Dict[str, Any]:
     """Filter query parameters based on remote config settings.
 
     Checks for a route-level query_params setting first, then falls back
     to the top-level remote config query_params. If neither exists, all
     params are passed through unchanged (backward compatible).
 
+    Filtering is by key only, so values may be strings or lists of strings
+    (the latter forwarding repeated keys such as ?id=1&id=2 intact).
+
     Args:
-        query_params: Original query parameters from the request.
+        query_params: Original query parameters from the request. Values may be
+            strings or lists of strings.
         route: The actual route path (e.g., "users/123").
         method: HTTP method (e.g., "GET", "POST").
         remote_config: Remote configuration dictionary.
 
     Returns:
-        Filtered query parameters dictionary.
+        Filtered query parameters dictionary (value types preserved).
     """
     routes = remote_config.get("routes", [])
 

{api_dock-0.6.0 → api_dock-0.7.0}/api_dock/example_api_dock_config/config.yaml

@@ -14,6 +14,7 @@ databases:
 settings:
   add_trailing_slash: false   # Set true to auto-append trailing slash to proxied paths
   follow_redirects: true      # Set false to pass 3xx redirects through to the client
+  timeout: 10                 # Upstream request timeout (seconds); null/false to disable
 
 # Global route restrictions — applied to all remotes unless overridden per-remote.
 # Uncomment to block DELETE on every remote:

{api_dock-0.6.0 → api_dock-0.7.0}/api_dock/example_api_dock_config/databases/example_db.yaml

@@ -20,6 +20,13 @@ routes:
       - category:
           sql: "[[items]].category = '{{category}}'"
 
+      # Repeated param — add multivalue_sql to support ?id=1&id=2. When more than
+      # one value is passed, multivalue_sql is used and {{id}} expands to a
+      # parenthesized value list (e.g. ('1', '2')) for use with IN.
+      - id:
+          sql: "[[items]].id = {{id}}"
+          multivalue_sql: "[[items]].id IN {{id}}"
+
       # Sorting — sql_append clauses are appended after the WHERE clause in YAML order.
       - sort:
           sql_append: ORDER BY {{sort}} {{direction}}

api_dock-0.7.0/api_dock/fast_api.py

@@ -0,0 +1,265 @@
+"""
+
+Main FastAPI Application for API Dock
+
+Core FastAPI application that handles routing to remote APIs and serves config data.
+
+License: BSD 3-Clause
+
+"""
+
+#
+# IMPORTS
+#
+import json
+import httpx
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, Response, StreamingResponse
+from typing import Any, Dict, Optional
+
+from api_dock.route_mapper import collect_multi_query_params, HOP_BY_HOP_HEADERS, RouteMapper
+from api_dock.types import PreparedRequest, ProxyResponse
+
+
+#
+# CONSTANTS
+#
+# Headers excluded when forwarding a streaming (raw-byte) upstream response.
+# Derived from route_mapper.HOP_BY_HOP_HEADERS but keeps content-encoding:
+# aiter_raw() yields the upstream's compressed bytes unchanged, so the
+# Content-Encoding header still describes the body correctly and must reach the
+# client so it can decompress. (The buffered map_route() path strips it instead,
+# because httpx decompresses there and the header would otherwise be wrong.)
+_STREAMING_EXCLUDED_HEADERS: frozenset = HOP_BY_HOP_HEADERS - frozenset({"content-encoding"})
+
+
+#
+# PUBLIC
+#
+def create_app(config_path: Optional[str] = None) -> FastAPI:
+    """Create and configure the FastAPI application.
+
+    Args:
+        config_path: Path to main config file. If None, uses default.
+
+    Returns:
+        Configured FastAPI application.
+    """
+    route_mapper = RouteMapper(config_path)
+
+    metadata = route_mapper.get_config_metadata()
+
+    app = FastAPI(
+        title=metadata.get("name", "API Dock"),
+        description=metadata.get("description", "API wrapper using configuration files"),
+        version="0.1.0"
+    )
+
+    app.state.route_mapper = route_mapper
+
+    _add_main_routes(app, route_mapper)
+    _add_remote_routes(app, route_mapper)
+    _add_error_handlers(app)
+
+    return app
+
+
+#
+# INTERNAL
+#
+def _add_main_routes(app: FastAPI, route_mapper: RouteMapper) -> None:
+    """Add main API routes to the FastAPI app.
+
+    Args:
+        app: FastAPI application instance.
+        route_mapper: RouteMapper instance.
+    """
+
+    @app.get("/")
+    async def get_meta() -> Dict[str, Any]:
+        """Return metadata from main config."""
+        return route_mapper.get_config_metadata()
+
+
+def _add_remote_routes(app: FastAPI, route_mapper: RouteMapper) -> None:
+    """Add remote API proxy routes to the FastAPI app.
+
+    Args:
+        app: FastAPI application instance.
+        route_mapper: RouteMapper instance.
+    """
+
+    @app.api_route("/{remote_name}/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
+    async def proxy_to_remote(remote_name: str, path: str, request: Request) -> Response:
+        """Proxy requests to remote APIs or databases.
+
+        Database routes are handled with a buffered response. Remote API routes
+        are streamed: upstream bytes are piped to the client as they arrive via
+        StreamingResponse, avoiding buffering large bodies in memory. Raw bytes
+        are forwarded via aiter_raw() so any upstream content-encoding (gzip,
+        br, deflate) is preserved end-to-end with the correct Content-Encoding
+        header.
+
+        Args:
+            remote_name: Name of the remote API or database.
+            path: The path to proxy to the remote API or query from database.
+            request: The incoming request.
+
+        Returns:
+            Response from the upstream with original status, headers, and body.
+        """
+        cookies = dict(request.cookies) if request.cookies else {}
+
+        if remote_name in route_mapper.database_names:
+            proxy_resp = await route_mapper.map_database_route(
+                database_name=remote_name,
+                path=path,
+                query_params=dict(request.query_params),
+                cookies=cookies,
+                multi_query_params=collect_multi_query_params(
+                    request.query_params.multi_items()
+                ),
+            )
+            return Response(
+                content=proxy_resp.content,
+                status_code=proxy_resp.status_code,
+                headers=proxy_resp.headers,
+                media_type=proxy_resp.content_type,
+            )
+
+        body = None
+        if request.method in ["POST", "PUT", "PATCH"]:
+            body = await request.body()
+
+        prepared = await route_mapper.prepare_remote_request(
+            remote_name=remote_name,
+            path=path,
+            method=request.method,
+            headers=dict(request.headers),
+            body=body,
+            query_params=dict(request.query_params),
+            cookies=cookies,
+            multi_query_params=collect_multi_query_params(
+                request.query_params.multi_items()
+            ),
+        )
+
+        if isinstance(prepared, ProxyResponse):
+            return Response(
+                content=prepared.content,
+                status_code=prepared.status_code,
+                headers=prepared.headers,
+                media_type=prepared.content_type,
+            )
+
+        return await _stream_upstream(prepared)
+
+
+def _add_error_handlers(app: FastAPI) -> None:
+    """Add custom error handlers to return JSON responses.
+
+    Args:
+        app: FastAPI application instance.
+    """
+
+    @app.exception_handler(404)
+    async def not_found_handler(request: Request, exc):
+        """Return JSON response for 404 errors."""
+        return JSONResponse(content={"error": "Not found"}, status_code=404)
+
+    @app.exception_handler(405)
+    async def method_not_allowed_handler(request: Request, exc):
+        """Return JSON response for 405 errors."""
+        return JSONResponse(content={"error": "Method not allowed"}, status_code=405)
+
+    @app.exception_handler(500)
+    async def internal_error_handler(request: Request, exc):
+        """Return JSON response for 500 errors."""
+        return JSONResponse(content={"error": "Internal server error"}, status_code=500)
+
+
+def _filter_streaming_response_headers(headers: Dict[str, str]) -> Dict[str, str]:
+    """Strip headers that must not be forwarded in a streaming response.
+
+    Like route_mapper._filter_response_headers but preserves content-encoding.
+    When streaming raw bytes via aiter_raw(), compressed bytes pass through
+    unchanged, so Content-Encoding correctly describes the response body.
+
+    Args:
+        headers: Raw headers from the upstream httpx response.
+
+    Returns:
+        Filtered dict containing only headers safe to forward.
+    """
+    return {
+        key: value
+        for key, value in headers.items()
+        if key.lower() not in _STREAMING_EXCLUDED_HEADERS
+    }
+
+
+async def _stream_upstream(prepared: PreparedRequest) -> Response:
+    """Stream a prepared upstream request back to the client.
+
+    Opens an httpx streaming connection, reads response status and headers,
+    then returns a StreamingResponse that pipes raw bytes to the client as
+    they arrive. Uses aiter_raw() so compressed content (gzip, br, deflate)
+    passes through unchanged with its Content-Encoding header intact.
+
+    If the upstream connection itself fails (before any bytes are received),
+    a plain 502 or 500 Response is returned instead.
+
+    Args:
+        prepared: Resolved upstream request from RouteMapper.prepare_remote_request().
+
+    Returns:
+        StreamingResponse on successful upstream connection,
+        or plain Response on 502/500 if the connection cannot be established.
+    """
+    client = httpx.AsyncClient(
+        follow_redirects=prepared.follow_redirects, timeout=prepared.timeout
+    )
+    req = client.build_request(
+        method=prepared.method,
+        url=prepared.url,
+        headers=prepared.headers,
+        params=prepared.params,
+        cookies=prepared.cookies,
+        content=prepared.body,
+    )
+    try:
+        upstream = await client.send(req, stream=True)
+    except httpx.RequestError as exc:
+        await client.aclose()
+        return Response(
+            content=json.dumps({"error": f"Error connecting to remote API: {str(exc)}"}).encode(),
+            status_code=502,
+            media_type="application/json",
+        )
+    except Exception as exc:
+        await client.aclose()
+        return Response(
+            content=json.dumps({"error": f"Internal server error: {str(exc)}"}).encode(),
+            status_code=500,
+            media_type="application/json",
+        )
+
+    async def _generate():
+        try:
+            async for chunk in upstream.aiter_raw():
+                yield chunk
+        finally:
+            await upstream.aclose()
+            await client.aclose()
+
+    headers = _filter_streaming_response_headers(dict(upstream.headers))
+    return StreamingResponse(
+        _generate(),
+        status_code=upstream.status_code,
+        headers=headers,
+        media_type=upstream.headers.get("content-type", "application/octet-stream"),
+    )
+
+
+# Default app instance
+app = create_app()

{api_dock-0.6.0 → api_dock-0.7.0}/api_dock/flask_api.py

@@ -15,7 +15,7 @@ import asyncio
 from flask import Flask, jsonify, request, Response as FlaskResponse
 from typing import Any, Dict, Optional
 
-from api_dock.route_mapper import RouteMapper
+from api_dock.route_mapper import collect_multi_query_params, RouteMapper
 
 
 #
@@ -126,6 +126,9 @@ def _handle_proxy(route_mapper: RouteMapper, remote_name: str, path: str) -> Fla
                 path=path,
                 query_params=dict(request.args),
                 cookies=cookies,
+                multi_query_params=collect_multi_query_params(
+                    request.args.items(multi=True)
+                ),
             )
         )
     else:
@@ -141,6 +144,9 @@ def _handle_proxy(route_mapper: RouteMapper, remote_name: str, path: str) -> Fla
             body=body,
             query_params=dict(request.args),
             cookies=cookies,
+            multi_query_params=collect_multi_query_params(
+                request.args.items(multi=True)
+            ),
         )
 
     response = FlaskResponse(