feat(async): add support for async sessions

graphene_sqlalchemy/fields.py

@@ -3,6 +3,8 @@
 from functools import partial
 
 from promise import Promise, is_thenable
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm.query import Query
 
 from graphene import NonNull
@@ -11,7 +13,7 @@
 from graphql_relay import connection_from_array_slice
 
 from .batching import get_batch_resolver
-from .utils import EnumValue, get_query
+from .utils import EnumValue, get_query, get_session
 
 
 class UnsortedSQLAlchemyConnectionField(ConnectionField):
@@ -26,9 +28,7 @@ def type(self):
         assert issubclass(nullable_type, SQLAlchemyObjectType), (
             "SQLALchemyConnectionField only accepts SQLAlchemyObjectType types, not {}"
         ).format(nullable_type.__name__)
-        assert (
-            nullable_type.connection
-        ), "The type {} doesn't have a connection".format(
+        assert nullable_type.connection, "The type {} doesn't have a connection".format(
             nullable_type.__name__
         )
         assert type_ == nullable_type, (
@@ -46,9 +46,15 @@ def get_query(cls, model, info, **args):
         return get_query(model, info.context)
 
     @classmethod
-    def resolve_connection(cls, connection_type, model, info, args, resolved):
+    async def resolve_connection(cls, connection_type, model, info, args, resolved):
+        session = get_session(info.context)
         if resolved is None:
-            resolved = cls.get_query(model, info, **args)
+            if isinstance(session, AsyncSession):
+                resolved = (
+                    await session.scalars(cls.get_query(model, info, **args))
+                ).all()
+            else:
+                resolved = cls.get_query(model, info, **args)
         if isinstance(resolved, Query):
             _len = resolved.count()
         else:
@@ -111,7 +117,11 @@ def __init__(self, type_, *args, **kwargs):
 
     @classmethod
     def get_query(cls, model, info, sort=None, **args):
-        query = get_query(model, info.context)
+        session = get_session(info.context)
+        if isinstance(session, AsyncSession):
+            query = select(model)
+        else:
+            query = get_query(model, info.context)
         if sort is not None:
             if not isinstance(sort, list):
                 sort = [sort]
@@ -148,7 +158,11 @@ def wrap_resolve(self, parent_resolver):
     def from_relationship(cls, relationship, registry, **field_kwargs):
         model = relationship.mapper.entity
         model_type = registry.get_type_for_model(model)
-        return cls(model_type.connection, resolver=get_batch_resolver(relationship), **field_kwargs)
+        return cls(
+            model_type.connection,
+            resolver=get_batch_resolver(relationship),
+            **field_kwargs,
+        )
 
 
 def default_connection_field_factory(relationship, registry, **field_kwargs):
@@ -163,17 +177,17 @@ def default_connection_field_factory(relationship, registry, **field_kwargs):
 
 def createConnectionField(type_, **field_kwargs):
     warnings.warn(
-        'createConnectionField is deprecated and will be removed in the next '
-        'major version. Use SQLAlchemyObjectType.Meta.connection_field_factory instead.',
+        "createConnectionField is deprecated and will be removed in the next "
+        "major version. Use SQLAlchemyObjectType.Meta.connection_field_factory instead.",
         DeprecationWarning,
     )
     return __connectionFactory(type_, **field_kwargs)
 
 
 def registerConnectionFieldFactory(factoryMethod):
     warnings.warn(
-        'registerConnectionFieldFactory is deprecated and will be removed in the next '
-        'major version. Use SQLAlchemyObjectType.Meta.connection_field_factory instead.',
+        "registerConnectionFieldFactory is deprecated and will be removed in the next "
+        "major version. Use SQLAlchemyObjectType.Meta.connection_field_factory instead.",
         DeprecationWarning,
     )
     global __connectionFactory
@@ -182,8 +196,8 @@ def registerConnectionFieldFactory(factoryMethod):
 
 def unregisterConnectionFieldFactory():
     warnings.warn(
-        'registerConnectionFieldFactory is deprecated and will be removed in the next '
-        'major version. Use SQLAlchemyObjectType.Meta.connection_field_factory instead.',
+        "registerConnectionFieldFactory is deprecated and will be removed in the next "
+        "major version. Use SQLAlchemyObjectType.Meta.connection_field_factory instead.",
         DeprecationWarning,
     )
     global __connectionFactory

graphene_sqlalchemy/tests/conftest.py

@@ -1,5 +1,6 @@
 import pytest
 from sqlalchemy import create_engine
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
 from sqlalchemy.orm import sessionmaker
 
 import graphene
@@ -8,8 +9,6 @@
 from ..registry import reset_global_registry
 from .models import Base, CompositeFullName
 
-test_db_url = 'sqlite://'  # use in-memory database for tests
-
 
 @pytest.fixture(autouse=True)
 def reset_registry():
@@ -22,13 +21,42 @@ def convert_composite_class(composite, registry):
         return graphene.Field(graphene.Int)
 
 
+@pytest.fixture(params=[False, True])
+def async_session(request):
+    return request.param
+
+
+@pytest.fixture
+def test_db_url(async_session: bool):
+    if async_session:
+        return "sqlite+aiosqlite://"
+    else:
+        return "sqlite://"
+
+
+@pytest.mark.asyncio
 @pytest.fixture(scope="function")
-def session_factory():
-    engine = create_engine(test_db_url)
-    Base.metadata.create_all(engine)
+async def session_factory(async_session: bool, test_db_url: str):
+    if async_session:
+        engine = create_async_engine(test_db_url)
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        yield sessionmaker(bind=engine, class_=AsyncSession, expire_on_commit=False)
+        await engine.dispose()
+    else:
+        engine = create_engine(test_db_url)
+        Base.metadata.create_all(engine)
+        yield sessionmaker(bind=engine, expire_on_commit=False)
+        # SQLite in-memory db is deleted when its connection is closed.
+        # https://www.sqlite.org/inmemorydb.html
+        engine.dispose()
 
-    yield sessionmaker(bind=engine)
 
+@pytest.fixture(scope="function")
+async def sync_session_factory():
+    engine = create_engine("sqlite://")
+    Base.metadata.create_all(engine)
+    yield sessionmaker(bind=engine, expire_on_commit=False)
     # SQLite in-memory db is deleted when its connection is closed.
     # https://www.sqlite.org/inmemorydb.html
     engine.dispose()

graphene_sqlalchemy/tests/models.py

@@ -15,8 +15,8 @@
 
 
 class HairKind(enum.Enum):
-    LONG = 'long'
-    SHORT = 'short'
+    LONG = "long"
+    SHORT = "short"
 
 
 Base = declarative_base()
@@ -64,9 +64,15 @@ class Reporter(Base):
     last_name = Column(String(30), doc="Last name")
     email = Column(String(), doc="Email")
     favorite_pet_kind = Column(PetKind)
-    pets = relationship("Pet", secondary=association_table, backref="reporters", order_by="Pet.id")
-    articles = relationship("Article", backref="reporter")
-    favorite_article = relationship("Article", uselist=False)
+    pets = relationship(
+        "Pet",
+        secondary=association_table,
+        backref="reporters",
+        order_by="Pet.id",
+        lazy="joined",
+    )
+    articles = relationship("Article", backref="reporter", lazy="joined")
+    favorite_article = relationship("Article", uselist=False, lazy="joined")
 
     @hybrid_property
     def hybrid_prop_with_doc(self):
@@ -137,7 +143,7 @@ class ShoppingCartItem(Base):
     id = Column(Integer(), primary_key=True)
 
     @hybrid_property
-    def hybrid_prop_shopping_cart(self) -> List['ShoppingCart']:
+    def hybrid_prop_shopping_cart(self) -> List["ShoppingCart"]:
         return [ShoppingCart(id=1)]
 
 
@@ -192,11 +198,17 @@ def hybrid_prop_list_date(self) -> List[datetime.date]:
 
     @hybrid_property
     def hybrid_prop_nested_list_int(self) -> List[List[int]]:
-        return [self.hybrid_prop_list_int, ]
+        return [
+            self.hybrid_prop_list_int,
+        ]
 
     @hybrid_property
     def hybrid_prop_deeply_nested_list_int(self) -> List[List[List[int]]]:
-        return [[self.hybrid_prop_list_int, ], ]
+        return [
+            [
+                self.hybrid_prop_list_int,
+            ],
+        ]
 
     # Other SQLAlchemy Instances
     @hybrid_property
@@ -216,15 +228,15 @@ def hybrid_prop_unsupported_type_tuple(self) -> Tuple[str, str]:
     # Self-references
 
     @hybrid_property
-    def hybrid_prop_self_referential(self) -> 'ShoppingCart':
+    def hybrid_prop_self_referential(self) -> "ShoppingCart":
         return ShoppingCart(id=1)
 
     @hybrid_property
-    def hybrid_prop_self_referential_list(self) -> List['ShoppingCart']:
+    def hybrid_prop_self_referential_list(self) -> List["ShoppingCart"]:
         return [ShoppingCart(id=1)]
 
     # Optional[T]
 
     @hybrid_property
-    def hybrid_prop_optional_self_referential(self) -> Optional['ShoppingCart']:
+    def hybrid_prop_optional_self_referential(self) -> Optional["ShoppingCart"]:
         return None