narrow geyser
I'm currently migrating from flask with Flask-SQLAlchemy, and really like how it's easy to hang onto a session that's scoped to each request. The example code I saw on the website all relies on passing the session down from the request handler.
What's the right way to create a class that holds onto the session object and works across requests? I'd love to write code like this:
def add_user(self):
self.session.add(...)
self.session.commit()
calm mountainBOT
tidal narwhal
Well, for a while, SQLAlchemy recommended against using scoped sessions. It looks like they've refined the verbiage to use "flask-sqlalchemy" where this pattern is more prevalent
The way you should do this in litestar is to use advanced-alchemy. The SessionConfig has a provide_session function. https://github.com/jolt-org/advanced-alchemy/blob/main/advanced_alchemy/extensions/litestar/plugins/init/config/asyncio.py#L181
whole pebbleBOT
advanced_alchemy/extensions/litestar/plugins/init/config/asyncio.py line 181
def provide_session(self, state: State, scope: Scope) -> AsyncSession:
Also, the repositories work like this essentially without the need for a scoped session
Here's how to get a session from the SQLAlchey Plugin config:https://github.com/cofin/litestar-fullstack/blob/main/src/app/cli/commands.py#L176
And calling .new on a service without a session will fetch a new one and store in users_service.repository.session: https://github.com/cofin/litestar-fullstack/blob/main/src/app/cli/commands.py#L136
whole pebbleBOT
src/app/cli/commands.py line 176
async with alchemy.get_session() as db_session:
src/app/cli/commands.py line 136
async with UserService.new() as users_service:
That said, I'd still think about whether you need scoped sessions or not
tidal narwhal
The first thing that comes to mind is transaction management is a bit obfuscated.
Secondly, in the context of a web framework, the session is likely meant to be scoped to the request. This still means that the commit/rollback etc still has to be managed each request. This is what the Advanced Alchemy plugin is already doing for you.
That said, the repositories and services do already work with scoped sessions
narrow geyser
So the async with alchemy.get_session() as db_session: line handles getting a session scoped to the active request?
tidal narwhal
So the `async with alchemy.get_session() as db_session:` line handles getting a ...
in a way, this is a way you can use the plugin config to get give you a session outside the context of an active request
whole pebbleBOT
src/app/config/app.py line 28
alchemy = SQLAlchemyAsyncConfig(
so, this configuration will give you a new session for each request that is already injected into the route, as. well as a commit for the transaction on each request if there is no exception raised (in this case, a rollback is issued).
The plugin is added to the app here: https://github.com/cofin/litestar-fullstack/blob/main/src/app/asgi.py#L43
whole pebbleBOT
src/app/asgi.py line 43
plugins.alchemy,
And you can then just use db_session in any of your routes: https://github.com/cofin/litestar-fullstack/blob/main/src/app/domain/system/controllers.py#L45
whole pebbleBOT
src/app/domain/system/controllers.py line 45
settings = get_settings()
this gives you a fresh session each request
I'll do a bit of research to see if there's an easy way to give the option of a scoped session out of the box in AA. But, I can't promise anything.
narrow geyser
Ok, I think I'll try refactoring to get the session for each route through db_session, the advanced alchemy code looks a lot cleaner than the other examples I saw