Parent not available on nested resolver

[bartenra]

Say we have the following schema:

type OrganizationUser {
    name: String!
    organization: Organization!
}

type Organization {
    name: String!
    owner: OrganizationUser!
}

type Query {
    organizations: [Organization!]!
}

See comment in resolve_owner.

@query.field("organizations")
def resolve_organizations(parent, info: GraphQLResolveInfo):  
    def resolve_owner(info: GraphQLResolveInfo):
        # here info.parent_type == Organization, but the parent is inaccessible
        return {
            "name": "Sundar Pichai",
            "organization": None  # missing for demo
        }
    
    return [{
        "name": "Google",
        "owner": resolve_owner
    }]

I wonder why parent is not available on nested resolvers. Is this a bug in Ariadne or a limitation of graphql-core?

[rafalp]

resolve_organizations is root resolver, so its obj argument is None by default. This behavior is mentioned at the beginning or resolves documentation:

If the resolver is a root resolver (it belongs to the field defined on Query, Mutation or Subscription) and the GraphQL server implementation doesn't explicitly define value for this field, the value of this argument will be None.

resolve_organizations should retrieve organizations list from suitable place: database, config or 3rd party API.

Also returning resolve_owner as part of field looks wrong here. Why can't you embed this data directly and then use resolver on owner field to complete data resolution process?

[bartenra]

I understand that parent is None in this case. Let me try to explain what I was surprised about.

When implementing resolvers with Typescript, each returned field can be a value of that type or a resolver function itself. With Ariadne you can also pass a function, but it doesn't have the same signature as a resolver because parent is missing.

The alternative approach we are taking now is that we define a OrganizationObjectType and add register a resolver for owner for it with @organization.field("owner"). Is that what you mean with your suggestion? I think that being able to define nested resolvers would be cleaner than having to register them separately in a lot of cases.

[rafalp]

I think that being able to define nested resolvers would be cleaner than having to register them separately in a lot of cases.

@organization.field("owner") is right way to do. Trying to do it all in single resolver may look tempting, but its an anti-pattern that ties fields resolution logic to single parent resolver and results errors when GraphQL node becomes available through multiple fields:

type Query {
    users: [User!]!
    posts: [Post!]!
}

type User {
  id: ID
  name: String
  group: Group
}

type Group {
  id: ID
  name: String
  admin: Boolean
}

type Post {
  id: ID
  poster: User
  text: String
}

How will you resolve group on user? Will you embed group resolver within query's user resolver and post's embed user resolver?

Many thin resolvers is always better than few large ones.