When connect to an async ORM and use 'login_manager.user_loader', an error occurred

[ockan]

When connect to ab async ORM and use 'login_manager.user_loader', an error occurred
I code

@login_manager.user_loader
async def load_user(user_id):
    return await Users.query.eq_field('user_id', int(user_id) if user_id.isdigit() else 0).one()

@app.route("/")
@roles_required('admin')
def hello():
    return render_template('index/index.html', session=session)

the error:

D:\py\bustapi\env\Lib\site-packages\bustapi\http\request.py:450: RuntimeWarning: coroutine 'load_user' was never awaited
  setattr(req, name, value)
RuntimeWarning: Enable tracemalloc to get the object allocation traceback
sys:1: RuntimeWarning: coroutine 'load_user' was never awaited
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

then, i modify bustapi/auth/login.py as following:

class LoginManager:
    """
    Manages user session authentication.

    Usage:
        login_manager = LoginManager(app)

        @login_manager.user_loader
        def load_user(user_id):
            return User.query.get(user_id)
    """

    def __init__(self, app=None):
        self._app = None
        self._user_loader_callback = None
        self._anonymous_user = AnonUser

        # Session config
        self.session_key = "_user_id"
        self.remember_key = "_remember"
        self.fresh_key = "_fresh"
        self.login_view = None
        self.login_message = "Please log in to access this page."

        if app is not None:
            self.init_app(app)

    async def init_app(self, app) -> None:
        """Initialize with application."""
        self._app = app
        app.extensions["login_manager"] = self

        # Store reference for current_user proxy
        app.login_manager = self

        # Register request hooks
        app.before_request(await self._load_user)

    def user_loader(self, callback: Callable[[str], Any]) -> Callable:
        """
        Decorator to register user loader function.

        @login_manager.user_loader
        def load_user(user_id):
            return User.query.get(user_id)
        """
        self._user_loader_callback = callback
        return callback

    async def _load_user(self) -> None:
        """Load user from session on each request."""
        from ..http.request import request, session

        # Default to anonymous
        request._login_user = self._anonymous_user()

        if not session:
            return

        user_id = session.get(self.session_key)
        if user_id is None:
            return

        if self._user_loader_callback is None:
            return

        # Load user via callback
        user = await self._user_loader_callback(user_id)
        if user is not None:
            request._login_user = user
            request._login_fresh = session.get(self.fresh_key, False)

it works and no error.

[GrandpaEJ]

Hi @ockan! You are absolutely correct. The currently doesn't correctly await async user loaders, and we need to ensure the request hooks are also properly awaited in the async lifecycle. I am working on an implementation plan to support this properly. Thank you for providing the fix example!

[GrandpaEJ]

Hello! We've implemented a full async overhaul for the request lifecycle hooks and user loader to address the issue you reported.

Key changes:

• Async User Loader: 'LoginManager' now correctly awaits async 'user_loader' callbacks.
• Async Hooks: Full support for 'async def' in 'before_request', 'after_request', and 'teardown_request'.
• Event Loop Isolation: Added a dedicated background event loop via 'async_to_sync' to prevent loop conflicts with async ORMs.
• Testing: Added 'session_transaction' to 'BustTestClient' for easier authentication testing.

These changes are included in the latest commit. You can now use async database calls in your user loader without event loop issues.

Happy coding!