fastapi-sqla 3.3.1__py3-none-any.whl → 3.4.2__py3-none-any.whl

fastapi_sqla/async_sqla.py

@@ -3,12 +3,13 @@ from contextlib import asynccontextmanager
 from typing import Annotated
 
 import structlog
-from fastapi import Depends, Request
+from fastapi import Depends, Request, Response
 from fastapi.responses import PlainTextResponse
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncEngine
 from sqlalchemy.ext.asyncio import AsyncSession as SqlaAsyncSession
 from sqlalchemy.orm.session import sessionmaker
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
 from fastapi_sqla import aws_aurora_support, aws_rds_iam_support
 from fastapi_sqla.sqla import _DEFAULT_SESSION_KEY, Base, new_engine
@@ -88,9 +89,7 @@ async def open_session(
         await session.close()
 
 
-async def add_session_to_request(
-    request: Request, call_next, key: str = _DEFAULT_SESSION_KEY
-):
+class AsyncSessionMiddleware:
     """Middleware which injects a new sqla async session into every request.
 
     Handles creation of session, as well as commit, rollback, and closing of session.
@@ -108,36 +107,58 @@ async def add_session_to_request(
         async def get_users(session: fastapi_sqla.AsyncSession):
             return await session.execute(...) # use your session here
     """
-    async with open_session(key) as session:
-        setattr(request.state, f"{_ASYNC_REQUEST_SESSION_KEY}_{key}", session)
-        response = await call_next(request)
-
-        is_dirty = bool(session.dirty or session.deleted or session.new)
-
-        # try to commit after response, so that we can return a proper 500 response
-        # and not raise a true internal server error
-        if response.status_code < 400:
-            try:
-                await session.commit()
-            except Exception:
-                logger.exception("commit failed, returning http error")
-                response = PlainTextResponse(
-                    content="Internal Server Error", status_code=500
-                )
-
-        if response.status_code >= 400:
-            # If ever a route handler returns an http exception, we do not want the
-            # session opened by current context manager to commit anything in db.
-            if is_dirty:
-                # optimistically only log if there were uncommitted changes
-                logger.warning(
-                    "http error, rolling back possibly uncommitted changes",
-                    status_code=response.status_code,
-                )
-            # since this is no-op if session is not dirty, we can always call it
-            await session.rollback()
 
-    return response
+    def __init__(self, app: ASGIApp, key: str = _DEFAULT_SESSION_KEY) -> None:
+        self.app = app
+        self.key = key
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        async with open_session(self.key) as session:
+            request = Request(scope=scope, receive=receive, send=send)
+            setattr(request.state, f"{_ASYNC_REQUEST_SESSION_KEY}_{self.key}", session)
+
+            async def send_wrapper(message: Message) -> None:
+                if message["type"] != "http.response.start":
+                    return await send(message)
+
+                response: Response | None = None
+                status_code = message["status"]
+                is_dirty = bool(session.dirty or session.deleted or session.new)
+
+                # try to commit after response, so that we can return a proper 500
+                # and not raise a true internal server error
+                if status_code < 400:
+                    try:
+                        await session.commit()
+                    except Exception:
+                        logger.exception("commit failed, returning http error")
+                        status_code = 500
+                        response = PlainTextResponse(
+                            content="Internal Server Error", status_code=500
+                        )
+
+                if status_code >= 400:
+                    # If ever a route handler returns an http exception,
+                    # we do not want the current session to commit anything in db.
+                    if is_dirty:
+                        # optimistically only log if there were uncommitted changes
+                        logger.warning(
+                            "http error, rolling back possibly uncommitted changes",
+                            status_code=status_code,
+                        )
+                    # since this is no-op if the session is not dirty,
+                    # we can always call it
+                    await session.rollback()
+
+                if response:
+                    return await response(scope, receive, send)
+
+                return await send(message)
+
+            await self.app(scope, receive, send_wrapper)
 
 
 class AsyncSessionDependency:

fastapi_sqla/base.py

@@ -36,13 +36,9 @@ def setup_middlewares(app: FastAPI):
     engines = {key: sqla.new_engine(key) for key in engine_keys}
     for key, engine in engines.items():
         if not _is_async_dialect(engine):
-            app.middleware("http")(
-                functools.partial(sqla.add_session_to_request, key=key)
-            )
+            app.add_middleware(sqla.SessionMiddleware, key=key)
         else:
-            app.middleware("http")(
-                functools.partial(async_sqla.add_session_to_request, key=key)
-            )
+            app.add_middleware(async_sqla.AsyncSessionMiddleware, key=key)
 
 
 @deprecated(
@@ -54,16 +50,12 @@ def setup(app: FastAPI):
     for key, engine in engines.items():
         if not _is_async_dialect(engine):
             app.add_event_handler("startup", functools.partial(sqla.startup, key=key))
-            app.middleware("http")(
-                functools.partial(sqla.add_session_to_request, key=key)
-            )
+            app.add_middleware(sqla.SessionMiddleware, key=key)
         else:
             app.add_event_handler(
                 "startup", functools.partial(async_sqla.startup, key=key)
             )
-            app.middleware("http")(
-                functools.partial(async_sqla.add_session_to_request, key=key)
-            )
+            app.add_middleware(async_sqla.AsyncSessionMiddleware, key=key)
 
 
 def _get_engine_keys() -> set[str]:

fastapi_sqla/sqla.py

@@ -5,7 +5,7 @@ from contextlib import contextmanager
 from typing import Annotated
 
 import structlog
-from fastapi import Depends, Request
+from fastapi import Depends, Request, Response
 from fastapi.concurrency import contextmanager_in_threadpool
 from fastapi.responses import PlainTextResponse
 from sqlalchemy import engine_from_config, text
@@ -13,6 +13,7 @@ from sqlalchemy.engine import Engine
 from sqlalchemy.ext.declarative import DeferredReflection
 from sqlalchemy.orm.session import Session as SqlaSession
 from sqlalchemy.orm.session import sessionmaker
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
 from fastapi_sqla import aws_aurora_support, aws_rds_iam_support
 
@@ -110,9 +111,7 @@ def open_session(key: str = _DEFAULT_SESSION_KEY) -> Generator[SqlaSession, None
         session.close()
 
 
-async def add_session_to_request(
-    request: Request, call_next, key: str = _DEFAULT_SESSION_KEY
-):
+class SessionMiddleware:
     """Middleware which injects a new sqla session into every request.
 
     Handles creation of session, as well as commit, rollback, and closing of session.
@@ -130,39 +129,60 @@ async def add_session_to_request(
         def get_users(session: fastapi_sqla.Session):
             return session.execute(...) # use your session here
     """
-    async with contextmanager_in_threadpool(open_session(key)) as session:
-        setattr(request.state, f"{_REQUEST_SESSION_KEY}_{key}", session)
-
-        response = await call_next(request)
-
-        is_dirty = bool(session.dirty or session.deleted or session.new)
-
-        loop = asyncio.get_running_loop()
-
-        # try to commit after response, so that we can return a proper 500 response
-        # and not raise a true internal server error
-        if response.status_code < 400:
-            try:
-                await loop.run_in_executor(None, session.commit)
-            except Exception:
-                logger.exception("commit failed, returning http error")
-                response = PlainTextResponse(
-                    content="Internal Server Error", status_code=500
-                )
-
-        if response.status_code >= 400:
-            # If ever a route handler returns an http exception, we do not want the
-            # session opened by current context manager to commit anything in db.
-            if is_dirty:
-                # optimistically only log if there were uncommitted changes
-                logger.warning(
-                    "http error, rolling back possibly uncommitted changes",
-                    status_code=response.status_code,
-                )
-            # since this is no-op if session is not dirty, we can always call it
-            await loop.run_in_executor(None, session.rollback)
-
-    return response
+
+    def __init__(self, app: ASGIApp, key: str = _DEFAULT_SESSION_KEY) -> None:
+        self.app = app
+        self.key = key
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        async with contextmanager_in_threadpool(open_session(self.key)) as session:
+            request = Request(scope=scope, receive=receive, send=send)
+            setattr(request.state, f"{_REQUEST_SESSION_KEY}_{self.key}", session)
+
+            async def send_wrapper(message: Message) -> None:
+                if message["type"] != "http.response.start":
+                    return await send(message)
+
+                response: Response | None = None
+                status_code = message["status"]
+                is_dirty = bool(session.dirty or session.deleted or session.new)
+
+                loop = asyncio.get_running_loop()
+
+                # try to commit after response, so that we can return a proper 500
+                # and not raise a true internal server error
+                if status_code < 400:
+                    try:
+                        await loop.run_in_executor(None, session.commit)
+                    except Exception:
+                        logger.exception("commit failed, returning http error")
+                        status_code = 500
+                        response = PlainTextResponse(
+                            content="Internal Server Error", status_code=status_code
+                        )
+
+                if status_code >= 400:
+                    # If ever a route handler returns an http exception,
+                    # we do not want the current session to commit anything in db.
+                    if is_dirty:
+                        # optimistically only log if there were uncommitted changes
+                        logger.warning(
+                            "http error, rolling back possibly uncommitted changes",
+                            status_code=status_code,
+                        )
+                    # since this is no-op if the session is not dirty,
+                    # we can always call it
+                    await loop.run_in_executor(None, session.rollback)
+
+                if response:
+                    return await response(scope, receive, send)
+
+                return await send(message)
+
+            await self.app(scope, receive, send_wrapper)
 
 
 class SessionDependency:

{fastapi_sqla-3.3.1.dist-info → fastapi_sqla-3.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-sqla
-Version: 3.3.1
+Version: 3.4.2
 Summary: SQLAlchemy extension for FastAPI with support for pagination, asyncio, SQLModel, and pytest, ready for production.
 Home-page: https://github.com/dialoguemd/fastapi-sqla
 License: MIT
@@ -38,15 +38,15 @@ Provides-Extra: aws-rds-iam
 Provides-Extra: psycopg2
 Provides-Extra: pytest-plugin
 Provides-Extra: sqlmodel
-Requires-Dist: alembic (>=1.4.3,<2.0.0) ; extra == "pytest-plugin"
-Requires-Dist: asyncpg (>=0.28.0,<0.29.0) ; extra == "asyncpg"
-Requires-Dist: boto3 (>=1.24.74,<2.0.0) ; extra == "aws-rds-iam"
-Requires-Dist: deprecated (>=1.2,<2.0)
+Requires-Dist: alembic (>=1.4.3,<2) ; extra == "pytest-plugin"
+Requires-Dist: asyncpg (>=0.28.0,<0.30.0) ; extra == "asyncpg"
+Requires-Dist: boto3 (>=1.24.74,<2) ; extra == "aws-rds-iam"
+Requires-Dist: deprecated (>=1.2,<2)
 Requires-Dist: fastapi (>=0.95.1,<0.112)
-Requires-Dist: psycopg2 (>=2.8.6,<3.0.0) ; extra == "psycopg2"
+Requires-Dist: psycopg2 (>=2.8.6,<3) ; extra == "psycopg2"
 Requires-Dist: pydantic (>=1,<3)
 Requires-Dist: sqlalchemy (>=1.3,<3)
-Requires-Dist: sqlmodel (>=0.0.14,<0.0.15) ; extra == "sqlmodel"
+Requires-Dist: sqlmodel (>=0.0.14,<0.0.21) ; extra == "sqlmodel"
 Requires-Dist: structlog (>=20,<25)
 Project-URL: Repository, https://github.com/dialoguemd/fastapi-sqla
 Description-Content-Type: text/markdown

{fastapi_sqla-3.3.1.dist-info → fastapi_sqla-3.4.2.dist-info}/RECORD

@@ -1,16 +1,16 @@
 fastapi_sqla/__init__.py,sha256=RRkwo9xZzidQ-k3BRXfqT0jtWm8d08w94XuOLteFCdU,1221
 fastapi_sqla/_pytest_plugin.py,sha256=IQUlj-O874Sfuth254LBrEBGCrwH3rNHST9OMZl2pIk,5411
 fastapi_sqla/async_pagination.py,sha256=3DHGUjvrpkbWMIc_BEX4GvM-_PTcn62K9z48ucTJlH0,3164
-fastapi_sqla/async_sqla.py,sha256=7SXRH3DMsQvpjCQdvCBEjQhDZ4-cPAg175MlgNVBnCg,5888
+fastapi_sqla/async_sqla.py,sha256=L5tHuYgHMpmSdGAsgxs30K7joVmMX-06NYJ7E5WaoUo,6865
 fastapi_sqla/aws_aurora_support.py,sha256=4dxLKOqDccgLwFqlz81L6f4HzrOXMZkY7Zuf4t_310U,838
 fastapi_sqla/aws_rds_iam_support.py,sha256=Uw-XaiwShMMWYKCvlSqXoxvtKMblCAvbCZ1m6BYVpJk,1257
-fastapi_sqla/base.py,sha256=8XHIKO8sBOmnRvCsOYRWhg5Y-XYqobM5DypeIMvJTFs,2501
+fastapi_sqla/base.py,sha256=40lov7wREct4q4rfXiKjlwsjFC9iFE0eDq-ghiJwGgY,2279
 fastapi_sqla/models.py,sha256=-B1xwINpTc9rEQd3KYHEC1s5s7jdVQkJ6Gy6xpmT13c,1108
 fastapi_sqla/pagination.py,sha256=1gfIGcmt1OFspbRgtJ8AZOZdFd14DGRc4FkDgyh5bJ8,4517
 fastapi_sqla/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastapi_sqla/sqla.py,sha256=irHuZaun027o9WJrdcZPavCN2vXNHupCWYhU5Dx-AqE,6348
-fastapi_sqla-3.3.1.dist-info/LICENSE,sha256=8G0-nWLqi3xRYRrtRlTE8n1mkYJcnCRoZGUhv6ZE29c,1064
-fastapi_sqla-3.3.1.dist-info/METADATA,sha256=fBq_qZ1JGhyzpjZGr30nYp4tgFNI4QvPIY26WvPdRi8,20994
-fastapi_sqla-3.3.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fastapi_sqla-3.3.1.dist-info/entry_points.txt,sha256=haa0EueKcRo8-AlJTpHBMn08wMBiULNGA53nkvaDWj0,53
-fastapi_sqla-3.3.1.dist-info/RECORD,,
+fastapi_sqla/sqla.py,sha256=3mIGdYmyOUZaClJiHCoaZpUlzbJilH2lrMzoc2gjZN0,7335
+fastapi_sqla-3.4.2.dist-info/LICENSE,sha256=8G0-nWLqi3xRYRrtRlTE8n1mkYJcnCRoZGUhv6ZE29c,1064
+fastapi_sqla-3.4.2.dist-info/METADATA,sha256=XvIQHj0EyUYlDZI9nLHa2Jn5Ta7dH2d_ngdbKXImTxU,20980
+fastapi_sqla-3.4.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fastapi_sqla-3.4.2.dist-info/entry_points.txt,sha256=haa0EueKcRo8-AlJTpHBMn08wMBiULNGA53nkvaDWj0,53
+fastapi_sqla-3.4.2.dist-info/RECORD,,