How to use resolve in Graphene Relay Node?

[nnluk1010]

How can I use resolve in relay.Node.Field?

I have tried to use resolve in DjangoFilterConnectionField(CategoryNode), and it works.

But it does not work when I use the same resolve function in relay.Node.Field(CategoryNode)

This is my code:

#schema.py
class Query(graphene.ObjectType):
    category = relay.Node.Field(CategoryNode)
    all_categories = DjangoFilterConnectionField(CategoryNode)


    def resolve_category(root, info, **kwargs):
        print("###TESTING resolve_category###")

    def resolve_all_categories(self, info, **kwargs):
        print("###TESTING resolve_all_categories###")

When I call the following GraphQL:

query {
  allCategories {
    edges {
      node {
        name
      }
    }
  }
}

The terminal will return ###TESTING resolve_category###

However, if I call the following GraphQL:

query {
  category(id: "Q2F0ZWdvcnlOb2RlOjE=") {
    id
    name
  }
}

The terminal will not return ###TESTING resolve_category###

[erikwrede]

That's because DjangoFilterConnectionField is a subclass of relay.connection.ConnectionField (=IterableConnectionField), not relay.node.NodeField.
graphene-django's ConnectionFields use the following wrap_resolve logic from graphene.Field to access the parent resolver:

https://github.com/graphql-python/graphene-django/blob/4517e3222499a1aca7c1110204ce5b27d9c911be/graphene_django/fields.py#L246-L255

NodeField's behavior differs. It ignores the parent resolver in wrap_resolve:

graphene/graphene/relay/node.py

Lines 70 to 71 in f09b2e5

	def wrap_resolve(self, parent_resolver):
	return partial(self.node_type.node_resolver, get_type(self.field_type))

As you can see, ConnectionField takes the parent resolver (your custom resolvers in class Query) and calls it in connection_resolver (l.231). Then, it is replaced by a default value if the parent resolver returns None:

https://github.com/graphql-python/graphene-django/blob/4517e3222499a1aca7c1110204ce5b27d9c911be/graphene_django/fields.py#L231-L233

This enables users to define a custom set of edges that is passed to the ConnectionField using a custom resolver, instead of resolving all instances of a certain type. That behavior is not necessary for a NodeField, as it is usually exclusively placed inside of the edges of a connection.

In general, there's little reason to be use the node.NodeField in a top level query instead of a regular graphene.Field when you want to add a resolver in Query. NodeField is useful if you have a resolve_node function in your object type that is implementing the Node interface. If you put your print statement in there, it will behave as you expected. If you don't need that, or don't want to use that in this case, you can just create a regular graphene.Field and your query resolvers will also work as you expected.

[nnluk1010]

Thanks for the answer so much.

As I would like to add the authorize logic in relay.Node.Field only, so I found some solution in https://stackoverflow.com/a/70252461/8879544 and https://stackoverflow.com/a/70967496/8879544.
But I think those solutions do not work as they use resolve in relay.Node.Field.

Maybe I will use regular graphene.Field or the resolve_node function in my object type.

[erikwrede]

It is a good practice to separate auth logic from resolver logic.
A custom middleware could be a good place to start: https://docs.graphene-python.org/en/latest/execution/middleware/#middleware

You can always access the current request using info.context.request. If you have JWT/Cookie based auth, you will be able to resolve the current user from that. Then you can inject that into your context and use the middleware to check if the current user has the right permission for the field he's trying to access.

Maybe this helps (in case you're using graphene-django): https://github.com/flavors/django-graphql-jwt :)

[nnluk1010]

Thanks for the sharing and I will read and study those reference :)

[minh-p]

For future references back to this issue. I'd like to share out that the "info" argument is accessible on DjangoObjectType as it "automatically transforms a Django Model into a ObjectType" (Docs >> Queries & ObjectTypes).

Hence, use what you see on Docs >> Relay >> Nodes.

To "resolve" authenticated queries using django-graphql-jwt, include get_node(cls, info, id) in your relay node.

This is working for me (I made a CustomUser that just uses email without username):

class CustomUserNode(DjangoObjectType):
    class Meta:
        model = CustomUser
        filter_fields = ("id", "email")
        interfaces = (relay.Node, )

    @classmethod
    def get_node(cls, info, id):
        user = info.context.user
        if not user.is_authenticated:
            raise Exception("Authentication credentials were not provided.")
        return user

What my Query looks like:

class Query(ObjectType):
    user = relay.Node.Field(CustomUserNode)
    all_users = DjangoFilterConnectionField(CustomUserNode)

    def resolve_all_users(self, info, **args):
        user = info.context.user
        if not user.is_authenticated or not user.is_superuser:
            raise Exception("You do not have the necessary privilege to access data.")
        return CustomUser.objects.all()

    profile = relay.Node.Field(ProfileNode)
    all_profiles = DjangoFilterConnectionField(ProfileNode)

Hopefully this helps fellow new devs as they are looking at JWT for Django as backend and another tool as frontend (like React/NextJS).

P.S. make sure you're logged out Django Admin page when testing the authorization headers, which somehow I have to explicitly state the middleware in urls.py instead of settings.py under GRAPHENE.