default resolver for Query

hi , im trying to create resolver for my Types . … should i always first define resolver for RootQuery Field ?

my Code:

from ariadne import QueryType, make_executable_schema, ObjectType
from ariadne.asgi import GraphQL

type_defs = """
    type Query {
        user: User
    }
    type User {
        username: String
        fullname: String
    }
"""


query = QueryType()
user = ObjectType('User')

@query.field('user')
def resolve_user(_,info,**kwargs):
    return 'something'

@user.field("username")
def resolve_username(_, info, **kwargs):
    request = info.context["request"]
    user_agent = request.headers.get("user-agent", "guest")
    return "Hello, %s!" % user_agent

schema = make_executable_schema(type_defs, [query,user])
app = GraphQL(schema, debug=True)

the resolve_username is not working when i remove resolve_user th binded to Query and also resolve_username doesnt work when i just pass the resolve_user

needed more Examples for Modularization in Doc .

[patrys]

@salvador-immortal That’s how GraphQL works: if any of the parent resolvers (in your case the user resolver on the Query type) returns NULL, query resolution won’t go any deeper. You have to either define a user resolver or provide a root_value that includes a value for the user field (so the default resolver returns it).

In your case, the logic should probably live in the Query.user resolver and not in the User.username resolver. Consider:

query = QueryType()

@query.field('user')
def resolve_user(_, info, **kwargs):
    request = info.context["request"]
    user_agent = request.headers.get("user-agent", "guest")
    username = "Hello, %s!" % user_agent
    return {
        "username": username,
        "fullName": "whatever",
    }

In this case, you can skip defining any resolvers for the User type as the default resolver will see a matching key in the dictionary returned by resolve_user and use it when username is requested.

[patrys]

In a large application, you’d typically define resolvers, data loaders, and other helpers in their own specific modules and import their particular lists of resolvers and type definitions in one place where you combine the schema. You can also use the extend type ... syntax to add the module-specific fields to different types (including Query).