refactored route function resolvers

Author: eadwinCode

ellar/common/params/args/base.py

@@ -12,7 +12,6 @@
 from ellar.common.interfaces import IExecutionContext
 from ellar.pydantic import (
     BaseModel,
-    ErrorWrapper,
     FieldInfo,
     ModelField,
     evaluate_forwardref,
@@ -30,6 +29,7 @@
     IRouteParameterResolver,
     SystemParameterResolver,
 )
+from ..resolvers.base import ResolverResult
 from .extra_args import ExtraEndpointArg
 from .factory import get_parameter_field
 from .resolver_generators import (
@@ -318,27 +318,21 @@ def _add_to_model(self, *, field: ModelField, key: t.Optional[str] = None) -> No
             field_info.create_resolver(model_field=field)
         )
 
-    async def resolve_dependencies(
-        self, *, ctx: IExecutionContext
-    ) -> t.Tuple[t.Dict[str, t.Any], t.List[ErrorWrapper]]:
-        values: t.Dict[str, t.Any] = {}
-        errors: t.List[ErrorWrapper] = []
+    async def resolve_dependencies(self, *, ctx: IExecutionContext) -> ResolverResult:
+        body_resolver = await self.resolve_body(ctx)
 
-        await self.resolve_body(ctx, values, errors)
-
-        if not errors:
+        if body_resolver and not body_resolver.errors:
             for parameter_resolver in self._route_models:
-                value_, value_errors = await parameter_resolver.resolve(ctx=ctx)
-                if value_:
-                    values.update(value_)
-                if value_errors:
+                res = await parameter_resolver.resolve(ctx=ctx)
+                if res.data:
+                    body_resolver.data.update(res.data)
+                if res.errors:
                     _errors = (
-                        value_errors
-                        if isinstance(value_errors, list)
-                        else [value_errors]
+                        res.errors if isinstance(res.errors, list) else [res.errors]
                     )
-                    errors += _errors
-        return values, errors
+                    body_resolver.errors.extend(_errors)
+                body_resolver.raw_data.update(res.raw_data)
+        return body_resolver
 
     def compute_extra_route_args(self) -> None:
         self._add_extra_route_args(*self._extra_endpoint_args)
@@ -372,10 +366,9 @@ def _add_extra_route_args(
             )
             self._add_to_model(field=param_field, key=key)
 
-    async def resolve_body(
-        self, ctx: IExecutionContext, values: t.Dict, errors: t.List
-    ) -> None:
+    async def resolve_body(self, ctx: IExecutionContext) -> ResolverResult:
         """Body Resolver Implementation"""
+        return ResolverResult({}, [], {})
 
     def __deepcopy__(
         self, memodict: t.Optional[t.Dict] = None

ellar/common/params/args/request_model.py

@@ -18,6 +18,7 @@
     IRouteParameterResolver,
     RouteParameterModelField,
 )
+from ..resolvers.base import ResolverResult
 from .base import EndpointArgsModel
 from .extra_args import ExtraEndpointArg
 
@@ -166,23 +167,16 @@ def build_body_field(self) -> None:
             final_field = create_model_field(
                 name="body",
                 type_=pydantic_body_model,
-                field_info=body_field_info(**field_info_kwargs),
+                field_info=body_field_info(**field_info_kwargs, ellar_body=True),
             )
             final_field.field_info = t.cast(
                 params.ParamFieldInfo, final_field.field_info
             )
             check_file_field(final_field)
             self.body_resolver = final_field.field_info.create_resolver(final_field)
 
-    async def resolve_body(
-        self, ctx: IExecutionContext, values: t.Dict, errors: t.List
-    ) -> None:
+    async def resolve_body(self, ctx: IExecutionContext) -> ResolverResult:
         if not self.body_resolver:
-            return
-
-        body, errors_ = await self.body_resolver.resolve(ctx=ctx)
-        if errors_:
-            assert isinstance(errors_, list)
-            errors.extend(errors_)
-            return
-        values.update(body)
+            return ResolverResult({}, [], {})
+
+        return await self.body_resolver.resolve(ctx=ctx)

ellar/common/params/args/resolver_generators.py

@@ -6,6 +6,7 @@
     sequence_types,
 )
 from ellar.common.exceptions import ImproperConfiguration
+from ellar.common.params import params
 from ellar.pydantic import (
     BaseModel,
     FieldConstraintsDefaultValues,
@@ -15,8 +16,8 @@
     is_scalar_field,
     is_scalar_sequence_field,
 )
+from ellar.pydantic.utils import is_field_annotation_nullable
 
-from .. import params
 from .factory import get_parameter_field
 
 
@@ -53,11 +54,12 @@ def __init__(self, pydantic_type: ModelField) -> None:
         self.param_field = pydantic_type
 
     def validate(self, field_name: str, field: ModelField) -> None:
-        if not is_scalar_field(field=field):
-            raise ImproperConfiguration(
-                f"field: '{field_name}' with annotation:'{field.type_}' in '{self.param_field.type_}'"
-                f"can't be processed. Field type is not a primitive type"
-            )
+        pass
+        # if not (is_scalar_field(field=field) or is_scalar_sequence_field(field)):
+        #     raise ImproperConfiguration(
+        #         f"field: '{field_name}' with annotation:'{field.type_}' in '{self.param_field.type_}'"
+        #         f"can't be processed. Field type is not a primitive type"
+        #     )
 
     def get_parameter_field(
         self,
@@ -82,6 +84,11 @@ def get_parameter_field(
     def generate_resolvers(self, body_field_class: t.Type[FieldInfo]) -> None:
         resolvers = []
         for k, field in self.pydantic_outer_type.model_fields.items():
+            field.default = (
+                None
+                if is_field_annotation_nullable(field.annotation)
+                else field.default
+            )
             model_field = create_model_field(
                 name=k,
                 type_=field.annotation,  # type:ignore[arg-type]
@@ -90,35 +97,42 @@ def generate_resolvers(self, body_field_class: t.Type[FieldInfo]) -> None:
                 field_info=field,
             )
             self.validate(k, model_field)
+            field_info = model_field.field_info
 
-            convert_underscores = getattr(
-                self.param_field.field_info,
-                "convert_underscores",
-                getattr(
-                    self.param_field.field_info.json_schema_extra,
+            if not isinstance(model_field.field_info, params.ParamFieldInfo):
+                convert_underscores = getattr(
+                    self.param_field.field_info,
                     "convert_underscores",
-                    None,
-                ),
-            )
-
-            keys = dict(
-                FieldConstraintsDefaultValues,
-                **{"convert_underscores": convert_underscores}
-                if convert_underscores
-                else {},
-            )
-
-            attrs = {k: getattr(model_field.field_info, k, v) for k, v in keys.items()}
-
-            model_field, field_info = self.get_parameter_field(
-                k, model_field, attrs, body_field_class
-            )
-            resolver = field_info.create_resolver(model_field=model_field)
+                    getattr(
+                        self.param_field.field_info.json_schema_extra,
+                        "convert_underscores",
+                        None,
+                    ),
+                )
+
+                keys = dict(
+                    FieldConstraintsDefaultValues,
+                    **model_field.field_info.extract_attributes_keys()
+                    if hasattr(model_field.field_info, "extract_attributes_keys")
+                    else {},
+                    **{"convert_underscores": convert_underscores}
+                    if convert_underscores
+                    else {},
+                )
+
+                attrs = {
+                    k: getattr(model_field.field_info, k, v) for k, v in keys.items()
+                }
+
+                model_field, field_info = self.get_parameter_field(
+                    k, model_field, attrs, body_field_class
+                )
+            resolver = field_info.create_resolver(model_field=model_field)  # type:ignore[attr-defined]
             resolvers.append(resolver)
 
         if isinstance(self.param_field.field_info.json_schema_extra, dict):
             self.param_field.field_info.json_schema_extra[MULTI_RESOLVER_KEY] = (
-                resolvers  # type:ignore[assignment]
+                resolvers
             )
 
 

ellar/common/params/args/websocket_model.py

@@ -1,11 +1,12 @@
 import typing as t
 
 from ellar.common.interfaces import IExecutionContext
-from ellar.pydantic import ErrorWrapper, FieldInfo
+from ellar.pydantic import FieldInfo
 from starlette.convertors import Convertor
 
 from .. import params
 from ..resolvers import BaseRouteParameterResolver, WsBodyParameterResolver
+from ..resolvers.base import ResolverResult
 from .base import EndpointArgsModel
 from .extra_args import ExtraEndpointArg
 
@@ -50,15 +51,17 @@ def compute_route_parameter_list(
 
     async def resolve_ws_body_dependencies(
         self, *, ctx: IExecutionContext, body_data: t.Any
-    ) -> t.Tuple[t.Dict[str, t.Any], t.List[ErrorWrapper]]:
+    ) -> ResolverResult:
         values: t.Dict[str, t.Any] = {}
-        errors: t.List[ErrorWrapper] = []
+        errors = []
+        raw_data = {}
         for parameter_resolver in self.body_resolver or []:
             parameter_resolver = t.cast(WsBodyParameterResolver, parameter_resolver)
-            value_, errors_ = await parameter_resolver.resolve(ctx=ctx, body=body_data)
-            if value_:
-                values.update(value_)
-            if errors_:
-                assert isinstance(errors_, list)
-                errors.extend(errors_)
-        return values, errors
+            res = await parameter_resolver.resolve(ctx=ctx, body=body_data)
+            if res.data:
+                values.update(res.data)
+            if res.errors:
+                assert isinstance(res.errors, list)
+                errors.extend(res.errors)
+            raw_data.update({parameter_resolver.model_field.name: res.raw_data})
+        return ResolverResult(values, errors, raw_data)

ellar/common/params/params.py

@@ -15,6 +15,7 @@
     FileParameterResolver,
     FormParameterResolver,
     HeaderParameterResolver,
+    IRouteParameterResolver,
     PathParameterResolver,
     QueryParameterResolver,
     WsBodyParameterResolver,
@@ -67,6 +68,9 @@ def __init__(
         json_schema_extra: t.Union[t.Dict[str, t.Any], None] = None,
         **extra: t.Any,
     ):
+        # identifies a field wrapping many resolvers/field-infos
+        self._ellar_body = extra.pop("ellar_body", False)
+
         self.deprecated = deprecated
         self.include_in_schema = include_in_schema
 
@@ -108,7 +112,9 @@ def __init__(
 
         super().__init__(**init_kwargs)
 
-    def create_resolver(self, model_field: ModelField) -> BaseRouteParameterResolver:
+    def create_resolver(
+        self, model_field: ModelField
+    ) -> t.Union[BaseRouteParameterResolver, IRouteParameterResolver]:
         multiple_resolvers = model_field.field_info.json_schema_extra.pop(  # type:ignore[union-attr]
             MULTI_RESOLVER_KEY, None
         )
@@ -417,7 +423,9 @@ def __init__(
         self.embed = True
         self.media_type = media_type or self.MEDIA_TYPE
 
-    def create_resolver(self, model_field: ModelField) -> BaseRouteParameterResolver:
+    def create_resolver(
+        self, model_field: ModelField
+    ) -> t.Union[BaseRouteParameterResolver, IRouteParameterResolver]:
         multiple_resolvers = model_field.field_info.json_schema_extra.pop(  # type:ignore[union-attr]
             MULTI_RESOLVER_KEY, []
         )

ellar/common/params/resolvers/base.py

@@ -11,6 +11,12 @@
     from ..params import ParamFieldInfo
 
 
+class ResolverResult(t.NamedTuple):
+    data: t.Optional[t.Any]
+    errors: t.Optional[t.List[t.Dict[str, t.Any]]]
+    raw_data: t.Dict[str, t.Any]
+
+
 class RouteParameterModelField(ModelField):
     field_info: "ParamFieldInfo"
 
@@ -20,16 +26,25 @@ class IRouteParameterResolver(ABC, metaclass=ABCMeta):
 
     @abstractmethod
     @t.no_type_check
-    async def resolve(self, *args: t.Any, **kwargs: t.Any) -> t.Tuple:
+    async def resolve(self, *args: t.Any, **kwargs: t.Any) -> ResolverResult:
         """Resolve handle"""
 
+    @abstractmethod
+    @t.no_type_check
+    def create_raw_data(self, data: t.Any) -> t.Dict:
+        """Essential for debugging"""
+
 
 class BaseRouteParameterResolver(IRouteParameterResolver, ABC):
     def __init__(self, model_field: ModelField, *args: t.Any, **kwargs: t.Any) -> None:
         self.model_field: RouteParameterModelField = t.cast(
             RouteParameterModelField, model_field
         )
 
+    def create_raw_data(self, data: t.Any) -> t.Dict:
+        """Essential for debugging"""
+        return {self.model_field.name: data}
+
     def assert_field_info(self) -> None:
         from .. import params
 
@@ -47,11 +62,11 @@ def validate_error_sequence(cls, errors: t.Any) -> t.List[t.Any]:
             return []
         return regenerate_error_with_loc(errors=errors, loc_prefix=())
 
-    async def resolve(self, *args: t.Any, **kwargs: t.Any) -> t.Tuple:
+    async def resolve(self, *args: t.Any, **kwargs: t.Any) -> ResolverResult:
         value_ = await self.resolve_handle(*args, **kwargs)
         return value_
 
     @abstractmethod
     @t.no_type_check
-    async def resolve_handle(self, *args: t.Any, **kwargs: t.Any) -> t.Tuple:
+    async def resolve_handle(self, *args: t.Any, **kwargs: t.Any) -> ResolverResult:
         """resolver action"""