rest ordering

Author: pcrespov

packages/models-library/src/models_library/rest_ordering.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Any, ClassVar
 
-from models_library.utils.json_serialization import json_dumps
+from models_library.utils.json_serialization import json_dumps, json_loads
 from pydantic import BaseModel, Field, Json, validator
 
 from .basic_types import IDStr
@@ -17,7 +17,10 @@ class OrderBy(BaseModel):
     field: IDStr = Field(..., description="field name identifier")
     direction: OrderDirection = Field(
         default=OrderDirection.ASC,
-        description="As [A,B,C,...] if ASC or [Z,Y,X, ...] if DESC",
+        description=(
+            f"As [A,B,C,...] if `{OrderDirection.ASC.value}`"
+            f" or [Z,Y,X, ...] if `{OrderDirection.DESC.value}`"
+        ),
     )
 
     class Config:
@@ -45,46 +48,61 @@ def create_order_by_query_model_classes(
 
     assert default_order_by.field in sortable_fields  # nosec
 
-    field_options_msg = "|".join(sorted(sortable_fields))
-    direction_options_msg = "|".join(sorted(OrderDirection))
+    msg_field_options = "|".join(sorted(sortable_fields))
+    msg_direction_options = "|".join(sorted(OrderDirection))
+    order_by_example: dict[str, Any] = OrderBy.Config.schema_extra["example"]
 
-    class _OrderBy(OrderBy):
-        field: IDStr = Field(
-            ..., description=OrderBy.__fields__["field"].field_info.description
-        )
+    class _JsonOrderBy(OrderBy):
         direction: OrderDirection = Field(
             default=default_order_by.direction
             if override_direction_default
             else OrderBy.__fields__["direction"].default,
             description=OrderBy.__fields__["direction"].field_info.description,
         )
 
+        @classmethod
+        def __modify_schema__(cls, field_schema: dict[str, Any]) -> None:
+            # openapi.json schema is corrected here
+            field_schema.update(
+                type="string",
+                format="json-string",
+                default=json_dumps(default_order_by),
+                example=json_dumps(order_by_example),
+                title="Order By",
+            )
+
         @validator("field", allow_reuse=True)
         @classmethod
         def _check_if_sortable_field(cls, v):
             if v not in sortable_fields:
                 msg = (
                     f"We do not support ordering by provided field '{v}'. "
-                    f"Fields supported are {field_options_msg}."
+                    f"Fields supported are {msg_field_options}."
                 )
                 raise ValueError(msg)
             return v
 
     description = (
-        f"Order by field ({field_options_msg}) and direction ({direction_options_msg}). "
+        f"Order by field ({msg_field_options}) and direction ({msg_direction_options}). "
         f"The default sorting order is '{default_order_by.direction.value}' on '{default_order_by.field}'."
     )
-    example: dict[str, Any] = OrderBy.Config.schema_extra["example"]
 
-    class _OrderByQueryParams(BaseOrderByQueryParams):
+    class _RequestValidatorModel(BaseOrderByQueryParams):
         # Used in rest handler for verification
-        order_by: _OrderBy = Field(
+        order_by: _JsonOrderBy = Field(
             default=default_order_by,
             description=description,
-            example=example,
         )
 
-    class _OrderByQueryJsonParams(BaseModel):
+        @validator("order_by", allow_reuse=True, pre=True)
+        @classmethod
+        def _pre_parse_if_json(cls, v):
+            if isinstance(v, str):
+                # can raise a JsonEncoderError(TypeError)
+                return json_loads(v)
+            return v
+
+    class _OpenapiModel(BaseModel):
         # Used to produce nice openapi.json specs
         order_by: Json = Field(
             default=json_dumps(default_order_by),
@@ -95,7 +113,10 @@ class _OrderByQueryJsonParams(BaseModel):
         @classmethod
         def _validate_json_content(cls, v):
             if v:
-                _OrderByQueryParams(order_by=v)
+                _RequestValidatorModel(order_by=v)
             return v
 
-    return _OrderByQueryParams, _OrderByQueryJsonParams
+        class Config:
+            schema_extra: ClassVar[dict[str, Any]] = {"title": "Order By Parameters"}
+
+    return _RequestValidatorModel, _OpenapiModel

packages/models-library/tests/test_rest_ordering.py

@@ -159,7 +159,7 @@ def test_order_by_query_model_class__openapi():
     print(OrderByQueryParamsModelOAS.schema_json(indent=1))
 
     assert OrderByQueryParamsModelOAS.schema() == {
-        "title": "_OrderByQueryJsonParams",
+        "title": "Order By Parameters",
         "type": "object",
         "properties": {
             "order_by": {

packages/service-library/tests/aiohttp/test_requests_validation.py

@@ -3,22 +3,30 @@
 # pylint: disable=unused-variable
 
 import json
-from typing import Callable
+from collections.abc import Callable
 from uuid import UUID
 
 import pytest
 from aiohttp import web
-from aiohttp.test_utils import TestClient
+from aiohttp.test_utils import TestClient, make_mocked_request
 from faker import Faker
+from models_library.rest_ordering import (
+    OrderBy,
+    OrderDirection,
+    create_order_by_query_model_classes,
+)
 from models_library.utils.json_serialization import json_dumps
-from pydantic import BaseModel, Extra, Field
+from pydantic import BaseModel, Field
 from servicelib.aiohttp import status
 from servicelib.aiohttp.requests_validation import (
+    RequestParams,
+    StrictRequestParams,
     parse_request_body_as,
     parse_request_headers_as,
     parse_request_path_parameters_as,
     parse_request_query_parameters_as,
 )
+from yarl import URL
 
 RQT_USERID_KEY = f"{__name__}.user_id"
 APP_SECRET_KEY = f"{__name__}.secret"
@@ -30,7 +38,7 @@ def jsonable_encoder(data):
     return json.loads(json_dumps(data))
 
 
-class MyRequestContext(BaseModel):
+class MyRequestContext(RequestParams):
     user_id: int = Field(alias=RQT_USERID_KEY)
     secret: str = Field(alias=APP_SECRET_KEY)
 
@@ -39,31 +47,24 @@ def create_fake(cls, faker: Faker):
         return cls(user_id=faker.pyint(), secret=faker.password())
 
 
-class MyRequestPathParams(BaseModel):
+class MyRequestPathParams(StrictRequestParams):
     project_uuid: UUID
 
-    class Config:
-        extra = Extra.forbid
-
     @classmethod
     def create_fake(cls, faker: Faker):
         return cls(project_uuid=faker.uuid4())
 
 
-class MyRequestQueryParams(BaseModel):
+class MyRequestQueryParams(RequestParams):
     is_ok: bool = True
     label: str
 
-    def as_params(self, **kwargs) -> dict[str, str]:
-        data = self.dict(**kwargs)
-        return {k: f"{v}" for k, v in data.items()}
-
     @classmethod
     def create_fake(cls, faker: Faker):
         return cls(is_ok=faker.pybool(), label=faker.word())
 
 
-class MyRequestHeadersParams(BaseModel):
+class MyRequestHeadersParams(RequestParams):
     user_agent: str = Field(alias="X-Simcore-User-Agent")
     optional_header: str | None = Field(default=None, alias="X-Simcore-Optional-Header")
 
@@ -359,3 +360,22 @@ async def test_parse_request_with_invalid_headers_params(
             ],
         }
     }
+
+
+def test_parse_request_query_parameters_as_with_order_by_query_models():
+
+    OrderByModel, _ = create_order_by_query_model_classes(
+        sortable_fields={"modified", "name"}, default_order_by=OrderBy(field="name")
+    )
+
+    expected = OrderBy(field="name", direction=OrderDirection.ASC)
+
+    url = URL("/test").with_query(order_by=expected.json())
+
+    request = make_mocked_request("GET", path=f"{url}")
+
+    query_params = parse_request_query_parameters_as(OrderByModel, request)
+    assert query_params.order_by == expected
+
+    assert OrderByModel.schema()["properties"]["order_by"]["type"] == "string"
+    assert OrderByModel.schema()["properties"]["order_by"]["format"] == "json-string"