wellapi 0.10.2__tar.gz → 0.10.4__tar.gz

{wellapi-0.10.2 → wellapi-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wellapi
-Version: 0.10.2
+Version: 0.10.4
 Summary: A simple web framework for aws lambda
 Author-email: romayuhym <romayuhym@gmail.com>
 Requires-Python: >=3.12

{wellapi-0.10.2 → wellapi-0.10.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wellapi"
-version = "0.10.2"
+version = "0.10.4"
 description = "A simple web framework for aws lambda"
 readme = "README.md"
 authors = [

{wellapi-0.10.2 → wellapi-0.10.4}/src/wellapi/dependencies/utils.py

@@ -907,11 +907,13 @@ def get_typed_return_annotation(call: Callable[..., Any]) -> Any:
 def _get_flat_fields_from_params(fields: List[ModelField]) -> List[ModelField]:
     if not fields:
         return fields
-    first_field = fields[0]
-    if len(fields) == 1 and lenient_issubclass(first_field.type_, BaseModel):
-        fields_to_extract = get_cached_model_fields(first_field.type_)
-        return fields_to_extract
-    return fields
+    flat_fields: List[ModelField] = []
+    for field in fields:
+        if lenient_issubclass(field.type_, BaseModel):
+            flat_fields.extend(get_cached_model_fields(field.type_))
+        else:
+            flat_fields.append(field)
+    return flat_fields
 
 
 def get_flat_params(dependant: Dependant) -> List[ModelField]:

{wellapi-0.10.2 → wellapi-0.10.4}/src/wellapi/routing.py

@@ -9,7 +9,7 @@ from pydantic.main import IncEx
 from wellapi.convertors import CONVERTOR_TYPES
 from wellapi.datastructures import Default, DefaultPlaceholder
 from wellapi.dependencies.models import Dependant, ModelField
-from wellapi.dependencies.utils import solve_dependencies
+from wellapi.dependencies.utils import get_flat_dependant, solve_dependencies
 from wellapi.exceptions import (
     HTTPException,
     RequestValidationError,
@@ -100,33 +100,37 @@ def get_request_handler(
     else:
         actual_response_class = response_class
 
+    has_body_params = bool(get_flat_dependant(dependant).body_params)
+
     @functools.wraps(dependant.call)
     def app(request: RequestAPIGateway) -> ResponseAPIGateway:
         response: ResponseAPIGateway | None = None
-        try:
-            body: Any = request.json()
-        except json.JSONDecodeError as e:
-            validation_error = RequestValidationError(
-                [
-                    {
-                        "type": "json_invalid",
-                        "loc": ("body", e.pos),
-                        "msg": "JSON decode error",
-                        "input": {},
-                        "ctx": {"error": e.msg},
-                    }
-                ],
-                body=e.doc,
-            )
-            raise validation_error from e
-        except HTTPException:
-            # If a middleware raises an HTTPException, it should be raised again
-            raise
-        except Exception as e:
-            http_error = HTTPException(
-                status_code=400, detail="There was an error parsing the body"
-            )
-            raise http_error from e
+        body: Any = None
+        if has_body_params:
+            try:
+                body = request.json()
+            except json.JSONDecodeError as e:
+                validation_error = RequestValidationError(
+                    [
+                        {
+                            "type": "json_invalid",
+                            "loc": ("body", e.pos),
+                            "msg": "JSON decode error",
+                            "input": {},
+                            "ctx": {"error": e.msg},
+                        }
+                    ],
+                    body=e.doc,
+                )
+                raise validation_error from e
+            except HTTPException:
+                # If a middleware raises an HTTPException, it should be raised again
+                raise
+            except Exception as e:
+                http_error = HTTPException(
+                    status_code=400, detail="There was an error parsing the body"
+                )
+                raise http_error from e
         errors: list[Any] = []
         solved_result = solve_dependencies(
             request=request,

wellapi-0.10.4/tests/test_request_handler_body.py

@@ -0,0 +1,39 @@
+"""Non-JSON request bodies must reach handlers that declare no body params."""
+
+from typing import Annotated
+
+import pytest
+
+from wellapi import Body, WellApi
+from wellapi.exceptions import RequestValidationError
+from wellapi.models import RequestAPIGateway
+
+
+def _make_request(api_gateway_event, body: str) -> RequestAPIGateway:
+    event = api_gateway_event | {"httpMethod": "POST", "body": body}
+    return RequestAPIGateway.create_request_from_event(event)
+
+
+def test_non_json_body_reaches_handler_without_body_params(api_gateway_event):
+    app = WellApi()
+
+    @app.post("/relay")
+    def relay(request: RequestAPIGateway) -> dict:
+        return {"raw": request.raw_event.body}
+
+    lam = next(lambda_ for lambda_ in app.lambdas if lambda_.name == "relay")
+    response = lam.app(_make_request(api_gateway_event, "code=abc&state=x%2Fy"))
+
+    assert response.statusCode == 200
+
+
+def test_invalid_json_with_body_params_still_rejected(api_gateway_event):
+    app = WellApi()
+
+    @app.post("/strict")
+    def strict(name: Annotated[str, Body(embed=True)]) -> dict:
+        return {"name": name}
+
+    lam = next(lambda_ for lambda_ in app.lambdas if lambda_.name == "strict")
+    with pytest.raises(RequestValidationError):
+        lam.app(_make_request(api_gateway_event, "not json"))