Merge pull request #236 from python-ellar/resolver_refactor

fix: Unified route function resolvers

Author: eadwinCode

ellar/common/interfaces/context.py

@@ -3,7 +3,6 @@
 
 from ellar.common.constants import empty_receive
 from ellar.common.types import T, TReceive, TScope, TSend
-from ellar.di import injectable, request_scope
 from starlette.requests import empty_send
 from starlette.responses import Response
 
@@ -40,7 +39,6 @@ def get_client(self) -> "WebSocket":
         """Returns WebSocket instance"""
 
 
-@injectable(scope=request_scope)
 class IHostContext(ABC, metaclass=ABCMeta):
     @abstractmethod
     def get_service_provider(self) -> "EllarInjector":
@@ -75,7 +73,6 @@ def user(self, value: t.Any) -> None:
         """Sets user identity"""
 
 
-@injectable(scope=request_scope)
 class IExecutionContext(IHostContext, ABC):
     @abstractmethod
     def get_handler(self) -> t.Callable:
@@ -136,8 +133,8 @@ def create_context_type(self, context: IHostContext) -> T:
 
 
 class IHTTPConnectionContextFactory(SubHostContextFactory[IHTTPHostContext], ABC):
-    context_typ: t.Type[IHTTPHostContext]
+    """HttpContext Factory Interface"""
 
 
 class IWebSocketContextFactory(SubHostContextFactory[IWebSocketHostContext], ABC):
-    context_type: t.Type[IWebSocketHostContext]
+    """WebsocketContext Factory Interface"""

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,27 +29,43 @@
     IRouteParameterResolver,
     SystemParameterResolver,
 )
+from ..resolvers.base import ResolverResult
 from .extra_args import ExtraEndpointArg
 from .factory import get_parameter_field
 from .resolver_generators import (
     BulkArgsResolverGenerator,
+    CookieResolverGenerator,
     FormArgsResolverGenerator,
     PathArgsResolverGenerator,
     QueryHeaderResolverGenerator,
 )
 
-BULK_RESOLVERS = {
+__BULK_RESOLVERS__ = {
     str(params.FormFieldInfo): FormArgsResolverGenerator,
     str(params.PathFieldInfo): PathArgsResolverGenerator,
     str(params.QueryFieldInfo): QueryHeaderResolverGenerator,
     str(params.HeaderFieldInfo): QueryHeaderResolverGenerator,
+    str(params.CookieFieldInfo): CookieResolverGenerator,
 }
 
 
+def add_get_resolver_generator(
+    param: t.Type[params.ParamFieldInfo],
+    resolver_gen: t.Type[BulkArgsResolverGenerator],
+) -> None:
+    """
+    Add a custom Bulk resolver generator a custom route function parameter field type
+    :param param:
+    :param resolver_gen:
+    :return:
+    """
+    __BULK_RESOLVERS__[str(param)] = resolver_gen  # pragma: no cover
+
+
 def get_resolver_generator(
     param: params.ParamFieldInfo,
 ) -> t.Type[BulkArgsResolverGenerator]:
-    return BULK_RESOLVERS.get(str(type(param)), BulkArgsResolverGenerator)
+    return __BULK_RESOLVERS__.get(str(type(param)), BulkArgsResolverGenerator)
 
 
 def get_annotation_type_and_default(
@@ -318,27 +333,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] = []
-
-        await self.resolve_body(ctx, values, errors)
+    async def resolve_dependencies(self, *, ctx: IExecutionContext) -> ResolverResult:
+        body_resolver = await self.resolve_body(ctx)
 
-        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,24 +381,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"""
-
-    def __deepcopy__(
-        self, memodict: t.Optional[t.Dict] = None
-    ) -> "EndpointArgsModel":  # pragma: no cover
-        if memodict is None:
-            memodict = {}
-        return self.__copy__(memodict)
-
-    def __copy__(
-        self, memodict: t.Optional[t.Dict] = None
-    ) -> "EndpointArgsModel":  # pragma: no cover
-        if memodict is None:
-            memodict = {}
-        return self
+        return ResolverResult({}, [], {})
 
     def build_body_field(self) -> None:  # pragma: no cover
         raise NotImplementedError

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,
@@ -16,7 +17,6 @@
     is_scalar_sequence_field,
 )
 
-from .. import params
 from .factory import get_parameter_field
 
 
@@ -53,7 +53,7 @@ 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):
+        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"
@@ -103,6 +103,9 @@ def generate_resolvers(self, body_field_class: t.Type[FieldInfo]) -> 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 {},
@@ -132,6 +135,15 @@ def validate(self, field_name: str, field: ModelField) -> None:
             )
 
 
+class CookieResolverGenerator(BulkArgsResolverGenerator):
+    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"
+            )
+
+
 class FormArgsResolverGenerator(QueryHeaderResolverGenerator):
     def generate_resolvers(self, body_field_class: t.Type[FieldInfo]) -> None:
         super().generate_resolvers(body_field_class=body_field_class)
@@ -140,13 +152,7 @@ def generate_resolvers(self, body_field_class: t.Type[FieldInfo]) -> None:
         ] = True
 
 
-class PathArgsResolverGenerator(BulkArgsResolverGenerator):
-    def validate(self, field_name: str, field: ModelField) -> None:
-        if not is_scalar_field(field=field):
-            raise ImproperConfiguration(
-                "Path params must be of one of the supported types. Only primitive types"
-            )
-
+class PathArgsResolverGenerator(CookieResolverGenerator):
     def get_parameter_field(
         self,
         field_name: str,

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"""