[BUG] Exits stacks can not be unwound with exception details

[agriffin-grow]

Describe the bug
When an exception is raised with a normal (Async)ExitStack used as a context manager (see fastapi), __aexit__ is called with exception details. fastapi_injectable has no way to mirror this behavior, always forcing us to use an ugly workaround (see below)

To Reproduce

from collections.abc import AsyncGenerator
from typing import Annotated

from fastapi import Depends
from fastapi_injectable import cleanup_all_exit_stacks, injectable


async def _get_dbconnection() -> AsyncGenerator[object, None]:
    conn = object()
    try:
        print("yield connection")
        yield conn
    except Exception:
        print("conn.rollback()")
        raise
    else:
        print("conn.commit()")
    finally:
        print("conn.close()")


@injectable()
async def as_dependency(connection: Annotated[object, Depends(_get_dbconnection)]):
    raise Exception("boom")


async def main():
    try:
        await as_dependency()
    except Exception:
        # BUG HERE
        # in the face of an exception, we should be able to call __aexit__ with exception
        # information so that we can properly unwind the exit stack and call rollback() on the
        # dependency
        print("got exception")
    finally:
        await cleanup_all_exit_stacks()


if __name__ == "__main__":
    import asyncio

    asyncio.run(main())

Expected behavior
I want to be able to unwind an exit stack with an error as would happen if it were used as a context manager.

My suggestion is to add an exc: Exception parameter to the _close_stack method such that it calls

if exc:
    await stack.__aexit__(type(exc), exc, exc.__traceback__)
else:
    await stack.aclose()

and plumb it all the way through from the close_exit_stacks methods

Ugly workaround
Looks something like this...

async def _injectable_wrapper(callable):
    scope = InjectableScope()
    await scope.__aenter__()
    try:
        result = callable(*args, **kwargs)
        if asyncio.iscoroutine(result):
            result = await result
        await scope.__aexit__(None, None, None)
        return result
    except Exception as exc:
        await scope.__aexit__(type(exc), exc, exc.__traceback__)
        raise

[agriffin-grow]

Eh I'm not actually even sure calling __aexit__ with exception info is all that's necessary. I tried to hack a fix together, but I might be missing something about how these exit stacks are actually entered

[agriffin-grow]

I believe I have a solution:

Step 1: make resolve_dependencies return the exit stack too

# in main.py
async def resolve_dependencies(
    func: Callable[P, T] | Callable[P, Awaitable[T]],
    *,
    use_cache: bool = True,
    provided_kwargs: dict[str, Any] | None = None,
) -> tuple[dict[str, Any], AsyncExitStack]:
    ...

    return {**resolved, **provided_kwargs}, async_exit_stack

Step 1.5: Use __aexit__ rather than aclose for the fastapi exit stacks in main.py

    async_exit_stack.push_async_exit(fastapi_inner_astack)
    async_exit_stack.push_async_exit(fastapi_function_astack)

Step 2: in the injectable decorator, wrap everything in an async with async_exist_stack:, like so:

        @wraps(target)
        async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
            dependencies, async_exit_stack = await resolve_dependencies(func=target, use_cache=use_cache, provided_kwargs=kwargs)
            async with async_exit_stack:
                return await cast("Callable[..., Coroutine[Any, Any, T]]", target)(*args, **{**dependencies, **kwargs})

I don't actually know what to do with the sync_wrapper in this case though.

[agriffin-grow]

Maybe something like

        @wraps(target)
        def sync_wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
            async def _impl() -> T:
                dependencies, async_exit_stack = await resolve_dependencies(func=target, use_cache=use_cache, provided_kwargs=kwargs)
                async with async_exit_stack:
                    return cast("Callable[..., T]", target)(*args, **{**dependencies, **kwargs})

            return run_coroutine_sync(_impl())