Data loading (batching) for sync apps

[pylipp]

I'm looking for a way (or work-around) for data-loading (batching) in sync web apps (in our case, we're restricted to use sync because the ORM peewee does not support async). We're hitting a bottlenecks for infamous queries like

query { 
  blogposts(count: N) {
    author { id }
  }
}

which results in N calls to fetch author information from the DB that could be batched.

I've found related discussions here and here.

1. Regarding the Python promise library, I'm uncertain whether to use it: it hasn't received any updates in 2.5 years. Also I don't know how child resolvers can deal with a Promise returned from a parent resolver.
2. @rafalp In the spectrum forum you mention it's possible to "preload root_value by introspecting the query", can you elaborate on how this would concretely work?
3. Maybe anyone has different advice on how to achieve batching in sync apps (or maybe it's sufficient to wrap our ORM calling code in "asyncify" decorators) or asgiref.sync_to_async)? Or is async-only the most powerful to go?

FWIW, here are some pages that I dug out researching for using dataloaders in sync apps:

• using promise-dataloader in graphene, comments then show how to integrate aiodataloader
• using aiodataloader in sync apps with graphql-core

[pylipp]

I found a way to integrate aiodataloader in my WSGI flask app like so:

# routes.py
import asyncio
from ariadne import graphql
from flask import Flask, request, jsonify
from .loaders import AuthorLoader
from .schema import full_api_schema

app = Flask(__name__)
# omitting database config with peewee via playhouse.flask_utils

@app.route("/graphql", methods=["POST"])
def graphql_server():
    # Start async event loop, required for DataLoader construction, cf.
    # https://github.com/graphql-python/graphql-core/issues/71#issuecomment-620106364
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

    # Create DataLoaders and persist them for the time of processing the request
    context = {"author_loader": AuthorLoader()}

    success, result = loop.run_until_complete(
        graphql(
            full_api_schema,
            data=request.get_json(),
            context_value=context,
        )
    )

    status_code = 200 if success else 400
    return jsonify(result), status_code


# loaders.py
from aiodataloader import DataLoader
from .author import Author  # peewee model definition

class AuthorLoader(DataLoader):
    async def batch_load_fn(self, keys):
        authors = {a.id: a for a in Author.select()}
        return [authors.get(i) for i in keys]


# resolvers.py
from ariadne import ObjectType

blogpost = ObjectType("Blogpost")

@blogpost.field("author")
def resolve_blogpost_author(blogpost_obj, info):
    return info.context["author_loader"].load(blogpost_obj.id)

[rafalp]

For the record, there's now a dataloaders reference for Ariadne that documents both async and sync dataloaders: https://ariadnegraphql.org/docs/dataloaders

[shoelessness]

@rafalp It's worth noting that graphql-sync-dataloaders does not actually implement the "Chaining dataloaders" functionality as documented.

e.g. this will throw with 'SyncFuture' object has no attribute 'then'

    return info.context["user_loader"].load(
        message["u_id"]
    ).then(
        return_user_if_not_banned
    )

Related issues:

• New release? jkimbo/graphql-sync-dataloaders#16
• 'SyncFuture' object has no attribute 'then' jkimbo/graphql-sync-dataloaders#9