Fixed issue with parsing repeated query parameters in URL

Author: mr-fatalyst

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to FastOpenAPI are documented in this file.
 
 FastOpenAPI follows the [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format.
 
+## [0.7.0] - Unreleased
+
+### Fixed
+- Fixed issue with parsing repeated query parameters in URL.
+
 ## [0.6.0] – 2025‑04‑16
 
 ### Added

fastopenapi/base_router.py

@@ -436,40 +436,93 @@ def render_redoc_ui(openapi_json_url: str) -> str:
         </html>
         """
 
+    @staticmethod
+    def _resolve_pydantic_model(model_class, params, param_name):
+        """Resolving parameters for a Pydantic model"""
+        try:
+            params_copy = params.copy()
+
+            if hasattr(model_class, "model_fields"):
+                for field_name, field_info in model_class.model_fields.items():
+                    if (
+                        field_name in params_copy
+                        and not isinstance(params_copy[field_name], list)
+                        and hasattr(field_info, "annotation")
+                        and typing.get_origin(field_info.annotation) is list
+                    ):
+                        params_copy[field_name] = [params_copy[field_name]]
+
+            return model_class(**params_copy)
+        except Exception as e:
+            raise ValidationError(
+                f"Validation error for parameter '{param_name}'", str(e)
+            )
+
+    @staticmethod
+    def _resolve_list_param(param_name, value, annotation):
+        """Resolving a list-type parameter"""
+        args = typing.get_args(annotation)
+        try:
+            if args:
+                return [args[0](value)]
+            else:
+                return [value]
+        except Exception as e:
+            type_name = args[0].__name__ if args else "value"
+            raise BadRequestError(
+                f"Error parsing parameter '{param_name}' as list item. "
+                f"Must be a valid {type_name}",
+                str(e),
+            )
+
+    @staticmethod
+    def _resolve_scalar_param(param_name, value, annotation):
+        """Resolving a scalar parameter"""
+        try:
+            return annotation(value)
+        except Exception as e:
+            type_name = getattr(annotation, "__name__", str(annotation))
+            raise BadRequestError(
+                f"Error parsing parameter '{param_name}'. "
+                f"Must be a valid {type_name}",
+                str(e),
+            )
+
     @staticmethod
     def resolve_endpoint_params(
         endpoint: Callable, all_params: dict, body: dict
     ) -> dict:
+        """Main method for resolving endpoint parameters"""
         sig = inspect.signature(endpoint)
         kwargs = {}
+
         for name, param in sig.parameters.items():
             annotation = param.annotation
             is_required = param.default is inspect.Parameter.empty
+
             if isinstance(annotation, type) and issubclass(annotation, BaseModel):
-                try:
-                    params = body if body else all_params
-                    kwargs[name] = annotation(**params)
-                except Exception as e:
-                    # Use 422 for Pydantic model validation errors
-                    raise ValidationError(
-                        f"Validation error for parameter '{name}'", str(e)
-                    )
-            else:
-                if name in all_params:
-                    try:
-                        kwargs[name] = annotation(all_params[name])
-                    except Exception as e:
-                        # Use 400 for type conversion errors
-                        raise BadRequestError(
-                            f"Error parsing parameter '{name}'. "
-                            f"Must be a valid {annotation.__name__}",
-                            str(e),
-                        )
-                elif not is_required:
-                    kwargs[name] = param.default
-                else:
-                    # Missing a required parameter is 400
+                kwargs[name] = BaseRouter._resolve_pydantic_model(
+                    annotation, body if body else all_params, name
+                )
+                continue
+
+            if name not in all_params:
+                if is_required:
                     raise BadRequestError(f"Missing required parameter: '{name}'")
+                kwargs[name] = param.default
+                continue
+
+            origin = typing.get_origin(annotation)
+
+            if origin is list and not isinstance(all_params[name], list):
+                kwargs[name] = BaseRouter._resolve_list_param(
+                    name, all_params[name], annotation
+                )
+            else:
+                kwargs[name] = BaseRouter._resolve_scalar_param(
+                    name, all_params[name], annotation
+                )
+
         return kwargs
 
     @property

fastopenapi/routers/aiohttp.py

@@ -17,7 +17,10 @@ async def _aiohttp_view(cls, request: web.Request, router, endpoint: Callable):
         """
         Handle request routing and parameter resolution for AioHttp
         """
-        query_params = dict(request.query)
+        query_params = {}
+        for key in request.query:
+            values = request.query.getall(key)
+            query_params[key] = values[0] if len(values) == 1 else values
         body = {}
         try:
             body_bytes = await request.read()

fastopenapi/routers/falcon.py

@@ -76,7 +76,14 @@ async def handle(req, resp, **path_params):
     async def _handle_request(self, endpoint, req, resp, **path_params):
         meta = getattr(endpoint, "__route_meta__", {})
         status_code = meta.get("status_code", 200)
-        all_params = {**dict(req.params), **path_params}
+        all_params = {**path_params}
+        for key in req.params.keys():
+            values = (
+                req.params.getall(key)
+                if hasattr(req.params, "getall")
+                else [req.params.get(key)]
+            )
+            all_params[key] = values[0] if len(values) == 1 else values
         body = await self._read_body(req)
         try:
             kwargs = self.resolve_endpoint_params(endpoint, all_params, body)

fastopenapi/routers/flask.py

@@ -14,7 +14,10 @@ def add_route(self, path: str, method: str, endpoint: Callable):
 
             def view_func(**path_params):
                 json_data = request.get_json(silent=True) or {}
-                query_params = request.args.to_dict()
+                query_params = {}
+                for key in request.args:
+                    values = request.args.getlist(key)
+                    query_params[key] = values[0] if len(values) == 1 else values
                 all_params = {**query_params, **path_params}
                 body = json_data
                 try:

fastopenapi/routers/quart.py

@@ -14,7 +14,10 @@ def add_route(self, path: str, method: str, endpoint: Callable):
 
             async def view_func(**path_params):
                 json_data = await request.get_json(silent=True) or {}
-                query_params = request.args.to_dict()
+                query_params = {}
+                for key in request.args:
+                    values = request.args.getlist(key)
+                    query_params[key] = values[0] if len(values) == 1 else values
                 all_params = {**query_params, **path_params}
                 body = json_data
                 try:

fastopenapi/routers/sanic.py

@@ -16,9 +16,10 @@ def add_route(self, path: str, method: str, endpoint: Callable):
         sanic_path = re.sub(r"{(\w+)}", r"<\1>", path)
 
         async def view_func(request, **path_params):
-            query_params = {
-                k: (v[0] if isinstance(v, list) else v) for k, v in request.args.items()
-            }
+            query_params = {}
+            for k, v in request.args.items():
+                values = request.args.getall(k)
+                query_params[k] = values[0] if len(values) == 1 else values
             json_body = request.json or {}
             all_params = {**query_params, **path_params}
             body = json_body

fastopenapi/routers/starlette.py

@@ -17,7 +17,10 @@ def __init__(self, app: Starlette = None, **kwargs):
 
     @classmethod
     async def _starlette_view(cls, request, router, endpoint):
-        query_params = dict(request.query_params)
+        query_params = {}
+        for key in request.query_params:
+            values = request.query_params.getlist(key)
+            query_params[key] = values[0] if len(values) == 1 else values
         body = {}
         try:
             body_bytes = await request.body()

fastopenapi/routers/tornado.py

@@ -42,9 +42,10 @@ async def handle_request(self):
             self.send_error(405)
             return
 
-        query_params = {
-            k: self.get_query_argument(k) for k in self.request.query_arguments
-        }
+        query_params = {}
+        for key in self.request.query_arguments:
+            values = self.get_query_arguments(key)
+            query_params[key] = values[0] if len(values) == 1 else values
 
         all_params = {**self.path_kwargs, **query_params}
         body = getattr(self, "json_body", {})