How to store/fetch global data within the resolver

[zhqu1148980644]

I would like to attach my async initialized object(for example a connection pool) in the app, but directly use info.context['request'].app raises Error.

[glennlaughlin]

FWIW - what I did for development purposes was to allocate an AppConfig object with an async callable that sets up the connection pool. In ariadne/asgi.py, when handling a http request, it sets up the context by looking for the (async) callable property. This allows you to execute any awaitable functions from within your AppConfig.

Along the lines of -

class AppConfig:
  _initialized: bool = False

  @property
  def connectionPool(self)->Pool:
    # returns a handle to your connection pool

  async def __call__(self, request: Any)->Any:
    # Initialize your awaitables here
    if not self._initialized 
      try:
        await self.initialize()  # set up your connection pool, cached objects, etc.
      except:  #punt
      else: self._inititialized = True
    return self

if __name__ == '__main__':
  appConfig:AppConfig = AppConfig()
  app = GraphQL(schema, context_value=appConfig)
  uvicorn.run(app)

# resolver.py
@query.field("results")
async def resolve_results(obj, info):
  # access the connection pool through the info.context which is a class object
  connectionH:Connection = await info.context.connectionPool.aquire()
  # ... do stuff
  await info.context.connectionPool.release(connectionH)

All that said, I have yet to find a best practice for setting up the info.context for caching session objects. I haven't tested in detail the above approach and first blush is I'm concerned about how this behaves with a theaded pool / concurrency across sessions. In my mind, AppConfig should be a global singleton object supporting re-entrancy across sessions but that's above my pay grade at the moment.

[zhqu1148980644]

I think this context_value parameter should be documented in the docs since it is quite common in the asyncio world.

[glennlaughlin]

To be fair, it is documented here and here. But I would love to see an example or best practice for using it especially in the context of connection pooling and/or session caches. The above seems to work in my local test environment but in production?

[zhqu1148980644]

Ah, you are right. In my case, I need to initialize an Asynchronous database(motor).

[glennlaughlin]

I use asyncpg with Postgres but the approach should be similar

[rafalp]

Using context value is the worst place for this 😅

Add ASGI framework over Ariadne (like Starlette) and use their hooks for that:

app = Starlette(debug=settings.debug)

app.add_event_handler("startup", cache.connect)
app.add_event_handler("shutdown", cache.disconnect)

app.add_event_handler("startup", database.connect)
app.add_event_handler("shutdown", database.disconnect)

app.add_event_handler("startup", broadcast.connect)
app.add_event_handler("shutdown", broadcast.disconnect)

async def resolve_graphql_context(request: Request) -> GraphQLContext:
    return {
        "request": request,
        "user": await auth_user(request),
    }
    

graphql = GraphQL(public_schema, debug=settings.debug, context_value=resolve_graphql_context)
app.mount("/graphql/", graphql)

[glennlaughlin]

I've been trying to limit my learning curve to the Ariadne/Graphql-core/Python stack. Can you expand on the comment 'worst place for this'? It seems "to work fine in my environment" :)

[rafalp]

You are inventing magic to force context value resolver into role it wasn't designed for. Your code would be far more correct as an ASGI middleware.