I would like to use my own ExecutionContext instance

[arjen-ag5]

Hello all,

The reason I want this is to be able to open a database connection in a resolver, then yield a result and once all its sub fields are resolved I want to close the database connection for example. So:

def resolve_a_field(*_):
    db = open_connection()
    yield Connection(db)
    db.close()

To this I have overriden the ExecutionContext like this:

class MyExecutionContext(ExecutionContext):
    def complete_value(self, return_type: GraphQLOutputType, field_nodes: List[FieldNode], info: GraphQLResolveInfo,
                       path: Path, result: Any) -> AwaitableOrValue[Any]:

        if isgenerator(result):
            completed = self.complete_value(
                return_type, field_nodes, info, path, next(result)
            )
            try:
                result.send(completed)
            except StopIteration as e:
                if len(e.args) == 1:
                    completed = e.value

            return completed

        return super().complete_value(return_type, field_nodes, info, path, result)

Currently I hacked the GraphQL instance to accept the parameter execution_context_class and pass it all the way down. What's best practice here or shall I create a pull request for this?

[rafalp]

Hey!

This looks very contrived. Can you explain why you are unable to open database connection outside of query executor and close it once execution completes?

Either way having execution_context option on asgi.GraphQL and wsgi.GraphQL won't hurt and I'm open to PRs adding this to ariadne and ariadne docs.

[arjen-ag5]

Thanks for getting back.

Different branches in the graph could request data from different sources. I do not always need to open a database connection. Opening it beforehand could be waste if it isn't queried anyway.

I could create a lazy initializing value holder for the database connection, or gRPC client... Just wondering if others ran in the same situation and it there's a common practice

[rafalp]

Did you measure if there's performance penalty from opening DB connection? Standard approach is to open bunch connections on application's start and then request/resolver is picking free connection from the pool when needed.