How to add a decorator to a resolver

[rmorshea]

I would like to add an extra decorator to my resolver like this:

def decorator(function):
    def wrapper(*args, **kwargs):
        # do something
        return function(*args, **kwargs)
    return wrapper

query_type = QueryType()

@query_type.field("something")
@decorator
def my_resolver(source, info, some_parameter):
    ...

The problem is that in doing this Ariadne is no longer able to discern the fact that my resolver needs some_parameter. What is the best way to achieve this effect. More specifically, my decorator extracts information from the info object and passes that into my_resolver instead. Something like:

def extract_context(function):
    def wrapper(_, info, *args, **kwargs):
        return function(load_context(info["context"]), *args, **kwargs)
    return wrapper

query_type = QueryType()

@query_type.field("something")
@extract_context
def my_resolver(context, some_parameter):
    ...

I want this because in every resolver function we write we have to load_context(info["context"]) which is very tedious.

[rafalp]

Hey!

Is there a reason why you are writing load_context(info["context"]) in every resolver? GraphQL's context_value argument takes callable that can do additional initialization of context for your app.

I'm using plenty of decorators for resolvers in my projects and case of some_parameter not working has never occured to me. What kind of error are you getting?

[rmorshea]

For my own understanding though, where does this interpretation of resolver function arguments happen? I tried looking through the source of this project and graphql but was unable to find where this occurs.

[rafalp]

resolver function arguments happen

This happens in graphql library, but its not as simple as passing **kwargs to a function. There's few middle steps where query arguments are extracted from parsed query's AST, then taken for literals or pulled from variables, parsed via GraphQL scalar's before finally being passed to resolver functions. So no single "here" point exists for this AFAIR.

[rafalp]

Can you provide minimal repro? Eg. single python file that has Query type with single field hello(name: String): String returning string and resolver set with your abstraction that returns, eg, $"hello {name}"? That will let me debug this on my side quickly.

[rmorshea]

I'm unable to reproduce. I don't really see what's different though. I guess I'll post back if I figure it out?

[rmorshea]

Nevermind, it had to do with the argument order? Here's the new working decorator:

def _make_field_decorator(
    object_type: ObjectType,
) -> Callable[[str], Callable[[Resolver], Resolver]]:
    """Return a customized ``object_type_field`` decorator

    Instead of passing a :class:`Context` instead of :class:`GraphQLResolveInfo`

    Example:
        .. code-block::

            something_type = ObjectType("Something")
            something_type_field = _make_field_decorator(object_type)

            @something_type_field
            def resolve_something(context, *args, **kwargs):
                async with context.async_session() as session:
                    ... # do something
    """

    def decorator(name: str) -> Callable[[Resolver], Resolver]:
        def setup(resolver: Resolver) -> Resolver:
            if isinstance(object_type, QueryType):
                @object_type.field(name)
                @wraps(resolver)
                def wrapper(_: Any, info: GraphQLResolveInfo, *args: Any, **kwargs: Any) -> Any:
                    return resolver(info_context(info), *args, **kwargs)
            else:
                @object_type.field(name)
                @wraps(resolver)
                def wrapper(*args, **kwargs: Any) -> Any:
                    info: GraphQLResolveInfo = args[-1]
                    return resolver(info_context(info), *args[:-1], **kwargs)

            return wrapper

        return setup

    return decorator