How to modularize resolvers file?

[Alexander-Trinh]

So for now I have been keeping every query and mutation resolver in one file and then import everything in the views.py like this:
from api.query import query, mutation

However I have been trying to create modules, so I pushed the initial Query initialization to base.py module:

from ariadne import QueryType, MutationType
#establish binder that binds resolvers to schema // alternative query=ObjectType("Query")
query = QueryType()
mutation = MutationType()

And now in my other modules I import those query and mutation vars:

from ..models import Border
from sqlalchemy.exc import IntegrityError
from psycopg2.errors import UniqueViolation
from .. import db
from base import query, mutation

#bind resolver to schema item with query.field
@query.field("listBorders")
def listBorders_resolver(obj, info):
    """Get all countries from database and modify output- resolver"""
    try:
        countries = [border.to_dict() for border in Border.query.all()]
        payload = {
            "success": True,
            "countries": countries
        }
    except Exception as error:
        payload = {
            "success": False,
            "errors": [str(error)]
        }
    return payload

And after creating this directory with modules I tried importing query and mutation to view.py:
from api.query.base import query, mutation
However when I try running queries in playground I get empty lists. So there is probably something wrong with the way I am modularizing the resovlers, could someone guide me how to properply create resolvers in this case?

This is my file strcture:

api
│ models.py
│ init.py
│ schema.graphql
| views.py
└───queries
│ base.py
│ borders.py

[rafalp]

Your resolvers aren't getting registered because you need to import python modules in order for code in them to be executed.

---

As for ideas how to organize your resolvers, I split them in python packages (types, mutations, scalars) and I give each GraphQL type and mutation separate module. I'm then aggregating those resolvers in __init__.py of each of packages, which I in turn import in schema module and pass to make_executable_schema.

Example types dir will contain files like this:

• query.py
• thread.py
• user.py

types/__init__.py will look like this:

from .query import query_type
from .thread import thread_type
from .user import user_type

types = [query_type, thread_type, user_type]

In mutations I put every mutation in separate python module:

• user_register.py
• user_login.py
• thread_post.py
• thread_reply.py
• thread_delete.py

And I aggregate those mutations in __init__.py:

import .user_register
import .user_login
import .thread_post
import .thread_reply
import .thread_delete

mutations = [
    user_register.mutation,
    user_login.mutation,
    thread_post.mutation,
    thread_reply.mutation,
    thread_delete.mutation,
]

I can then create executable schema like this:

from .mutations import mutations
from .types import types

type_defs = ...

schema = make_executable_schema(type_defs, types, mutations)