Alternative way to bind methods

[swstephe]

I was using "Strawberry" for GraphQL, which is "code-first". Then I tried Ariadne, and I liked the fact it was "schema-first", but got bogged down in no longer being able to map resolver functions declaratively.

I eventually came up with this simple function:

def bind(path: str | None = None, type_defs: str | None = None):
    if type_defs is None:
        type_defs = load_schema_from_path(path)

    def wrapper(cls):
        bindables = []
        for sub_name, sub_class in cls.__dict__.items():
            if not sub_name.startswith("_") and inspect.isclass(sub_class):
                if sub_name == 'Query':
                    obj = QueryType()
                else:
                    obj = ObjectType(sub_name)
                for method_name, method in sub_class.__dict__.items():
                    if not method_name.startswith("_"):
                        obj.set_field(method_name, getattr(sub_class, method_name))
                bindables.append(obj)
        cls.binding = make_executable_schema(type_defs, *bindables)
        return cls
    return wrapper

Then I only need to write some nested classes with a decorator, (in this example, "users" is a dictionary of usernames, "posts" is a list of comments per user:

@bind("schema.graphql")
class Schema:     # represents the schema, but the name isn't important
    binding: GraphQLSchema

    class User:
        def posts(root, *_):
            return list(
                {"id": id} | post
                for id, post in posts.items()
                if post["user_id"] == root["id"]
            )

    class Query:
        def user(*_, id: int):
            if id in users:
                return {"id": id, "username": users[id]}

        def users(*_):
            return [{"id": id, "username": username} for id, username in users.items()]

Then I can create my app with:

app = GraphQL(Schema.binding, debug=True)

Is this approach useful for others? I don't have to remember all those types and function calls. The argument to bind is the path to a schema file, but you can also do "type_defs=gql(...)" to use GraphQL inline as a string.

[swstephe]

I just realized if I replace, staticmethod(method) with getattr(sub_class, method_name) I can get rid of all those @staticmethod declarations and it still works.

[pkucmus]

How about this:

class UserType(ObjectType):
    __schema__ = gql(
        """
        type User {
            posts: [Post]!
        }
        """
    )
    __requires__ = [PostType]  # PostType TBD
    
    def resolve_posts(root, *_):
        return list(
            {"id": id} | post
            for id, post in posts.items()
            if post["user_id"] == root["id"]
        )

class Query(ObjectType):
    __schema__ = gql(
        """
        type Query {
            user: User!
            users: [User]!
        }
        """
    )
	__requires__ = [UserType]

    @staticmethod
    def resolve_user(*_, id: int):
        if id in users:
             return {"id": id, "username": users[id]}

    @staticmethod
    def resolve_users(*_):
        return [{"id": id, "username": username} for id, username in users.items()]

This is already possible with https://github.com/mirumee/ariadne-graphql-modules