delete global session

Author: joeblackwaslike

src/quart_sqlalchemy/sim/handle.py

@@ -6,10 +6,11 @@
 from datetime import datetime
 
 import sqlalchemy
+import sqlalchemy.orm
 from dependency_injector.wiring import Provide
 from quart import Quart
 
-from quart_sqlalchemy.session import SessionProxy
+from quart_sqlalchemy.session import provide_global_contextual_session
 from quart_sqlalchemy.sim import signals
 from quart_sqlalchemy.sim.logic import LogicComponent
 from quart_sqlalchemy.sim.model import AuthUser
@@ -44,14 +45,15 @@ class InvalidSubstringError(AuthUserBaseError):
 
 class HandlerBase:
     logic: LogicComponent = Provide["logic"]
-    session_factory = SessionProxy()
 
 
 class MagicClientHandler(HandlerBase):
     auth_user_handler: AuthUserHandler = Provide["AuthUserHandler"]
 
+    @provide_global_contextual_session
     def add(
         self,
+        session: sa.orm.Session,
         app_name=None,
         rate_limit_tier=None,
         connect_interop=None,
@@ -68,21 +70,24 @@ def add(
         """
 
         return self.logic.MagicClient.add(
-            self.session_factory(),
+            session,
             app_name=app_name,
             rate_limit_tier=rate_limit_tier,
             connect_interop=connect_interop,
             is_signing_modal_enabled=is_signing_modal_enabled,
             global_audience_enabled=global_audience_enabled,
         )
 
-    def get_by_public_api_key(self, public_api_key):
-        return self.logic.MagicClient.get_by_public_api_key(self.session_factory(), public_api_key)
+    @provide_global_contextual_session
+    def get_by_public_api_key(self, session: sa.orm.Session, public_api_key):
+        return self.logic.MagicClient.get_by_public_api_key(session, public_api_key)
 
-    def get_by_id(self, magic_client_id):
-        return self.logic.MagicClient.get_by_id(self.session_factory(), magic_client_id)
+    @provide_global_contextual_session
+    def get_by_id(self, session: sa.orm.Session, magic_client_id):
+        return self.logic.MagicClient.get_by_id(session, magic_client_id)
 
-    def update_app_name_by_id(self, magic_client_id, app_name):
+    @provide_global_contextual_session
+    def update_app_name_by_id(self, session: sa.orm.Session, magic_client_id, app_name):
         """
         Args:
             magic_client_id (ObjectID|int|str): self explanatory.
@@ -92,36 +97,34 @@ def update_app_name_by_id(self, magic_client_id, app_name):
             None if `magic_client_id` doesn't exist in the db
             app_name if update was successful
         """
-        client = self.logic.MagicClient.update_by_id(
-            self.session_factory(), magic_client_id, app_name=app_name
-        )
+        client = self.logic.MagicClient.update_by_id(session, magic_client_id, app_name=app_name)
 
         if not client:
             return None
 
         return client.app_name
 
-    def update_by_id(self, magic_client_id, **kwargs):
-        client = self.logic.MagicClient.update_by_id(
-            self.session_factory(), magic_client_id, **kwargs
-        )
+    @provide_global_contextual_session
+    def update_by_id(self, session: sa.orm.Session, magic_client_id, **kwargs):
+        client = self.logic.MagicClient.update_by_id(session, magic_client_id, **kwargs)
 
         return client
 
-    def set_inactive_by_id(self, magic_client_id):
+    @provide_global_contextual_session
+    def set_inactive_by_id(self, session: sa.orm.Session, magic_client_id):
         """
         Args:
             magic_client_id (ObjectID|int|str): self explanatory.
 
         Returns:
             None
         """
-        self.logic.MagicClient.update_by_id(
-            self.session_factory(), magic_client_id, is_active=False
-        )
+        self.logic.MagicClient.update_by_id(session, magic_client_id, is_active=False)
 
+    @provide_global_contextual_session
     def get_users_for_client(
         self,
+        session: sa.orm.Session,
         magic_client_id,
         offset=None,
         limit=None,
@@ -131,6 +134,7 @@ def get_users_for_client(
         """
         product_type = get_product_type_by_client_id(magic_client_id)
         auth_users = self.auth_user_handler.get_by_client_id_and_user_type(
+            session,
             magic_client_id,
             product_type,
             offset=offset,
@@ -146,16 +150,18 @@ def get_users_for_client(
 
 
 class AuthUserHandler(HandlerBase):
-    def get_by_session_token(self, session_token):
-        return self.logic.AuthUser.get_by_session_token(self.session_factory(), session_token)
+    @provide_global_contextual_session
+    def get_by_session_token(self, session: sa.orm.Session, session_token):
+        return self.logic.AuthUser.get_by_session_token(session, session_token)
 
+    @provide_global_contextual_session
     def get_or_create_by_email_and_client_id(
         self,
+        session: sa.orm.Session,
         email,
         client_id,
         user_type=EntityType.MAGIC.value,
     ):
-        session = self.session_factory()
         with session.begin_nested():
             auth_user = self.logic.AuthUser.get_by_email_and_client_id(
                 session,
@@ -173,14 +179,15 @@ def get_or_create_by_email_and_client_id(
                 )
         return auth_user
 
+    @provide_global_contextual_session
     def create_verified_user(
         self,
+        session: sa.orm.Session,
         client_id,
         email,
         user_type=EntityType.FORTMATIC.value,
         **kwargs,
     ):
-        session = self.session_factory()
         with session.begin_nested():
             auid = self.logic.AuthUser.add_by_email_and_client_id(
                 session,
@@ -201,52 +208,66 @@ def create_verified_user(
 
         return auth_user
 
-    def get_by_id(self, auth_user_id) -> AuthUser:
-        return self.logic.AuthUser.get_by_id(self.session_factory(), auth_user_id)
+    @provide_global_contextual_session
+    def get_by_id(self, session: sa.orm.Session, auth_user_id) -> AuthUser:
+        return self.logic.AuthUser.get_by_id(session, auth_user_id)
 
+    @provide_global_contextual_session
     def get_by_client_id_and_user_type(
         self,
+        session: sa.orm.Session,
         client_id,
         user_type,
         offset=None,
         limit=None,
     ):
         return self.logic.AuthUser.get_by_client_id_and_user_type(
-            self.session_factory(),
+            session,
             client_id,
             user_type,
             offset=offset,
             limit=limit,
         )
 
-    def exist_by_email_client_id_and_user_type(self, email, client_id, user_type):
+    @provide_global_contextual_session
+    def exist_by_email_client_id_and_user_type(
+        self, session: sa.orm.Session, email, client_id, user_type
+    ):
         return self.logic.AuthUser.exist_by_email_and_client_id(
-            self.session_factory(),
+            session,
             email,
             client_id,
             user_type=user_type,
         )
 
-    def update_email_by_id(self, model_id, email):
-        return self.logic.AuthUser.update_by_id(self.session_factory(), model_id, email=email)
+    @provide_global_contextual_session
+    def update_email_by_id(self, session: sa.orm.Session, model_id, email):
+        return self.logic.AuthUser.update_by_id(session, model_id, email=email)
 
-    def get_by_email_client_id_and_user_type(self, email, client_id, user_type):
+    @provide_global_contextual_session
+    def get_by_email_client_id_and_user_type(
+        self, session: sa.orm.Session, email, client_id, user_type
+    ):
         return self.logic.AuthUser.get_by_email_and_client_id(
-            self.session_factory(),
+            session,
             email,
             client_id,
             user_type,
         )
 
-    def mark_date_verified_by_id(self, model_id):
+    @provide_global_contextual_session
+    def mark_date_verified_by_id(self, session: sa.orm.Session, model_id):
         return self.logic.AuthUser.update_by_id(
-            self.session_factory(),
+            session,
             model_id,
             date_verified=datetime.utcnow(),
         )
 
-    def set_role_by_email_magic_client_id(self, email, magic_client_id, role):
-        session = self.session_factory()
+    @provide_global_contextual_session
+    def set_role_by_email_magic_client_id(
+        self, session: sa.orm.Session, email, magic_client_id, role
+    ):
+        session = session
         auth_user = self.logic.AuthUser.get_by_email_and_client_id(
             session,
             email,
@@ -267,8 +288,9 @@ def set_role_by_email_magic_client_id(self, email, magic_client_id, role):
 
         return self.logic.AuthUser.update_by_id(session, auth_user.id, **{role: True})
 
-    def mark_as_inactive(self, auth_user_id):
-        self.logic.AuthUser.update_by_id(self.session_factory(), auth_user_id, is_active=False)
+    @provide_global_contextual_session
+    def mark_as_inactive(self, session: sa.orm.Session, auth_user_id):
+        self.logic.AuthUser.update_by_id(session, auth_user_id, is_active=False)
 
 
 @signals.auth_user_duplicate.connect
@@ -282,37 +304,42 @@ def handle_duplicate_auth_users(
 
 
 class AuthWalletHandler(HandlerBase):
-    def get_by_id(self, model_id):
-        return self.logic.AuthWallet.get_by_id(self.session_factory(), model_id)
+    @provide_global_contextual_session
+    def get_by_id(self, session: sa.orm.Session, model_id):
+        return self.logic.AuthWallet.get_by_id(session, model_id)
 
-    def get_by_public_address(self, public_address):
-        return self.logic.AuthWallet().get_by_public_address(self.session_factory(), public_address)
+    @provide_global_contextual_session
+    def get_by_public_address(self, session: sa.orm.Session, public_address):
+        return self.logic.AuthWallet().get_by_public_address(session, public_address)
 
+    @provide_global_contextual_session
     def get_by_auth_user_id(
         self,
+        session: sa.orm.Session,
         auth_user_id: ObjectID,
         network: t.Optional[str] = None,
         wallet_type: t.Optional[WalletType] = None,
         **kwargs,
     ) -> t.List[AuthWallet]:
         return self.logic.AuthWallet.get_by_auth_user_id(
-            self.session_factory(),
+            session,
             auth_user_id,
             network=network,
             wallet_type=wallet_type,
             **kwargs,
         )
 
+    @provide_global_contextual_session
     def sync_auth_wallet(
         self,
+        session: sa.orm.Session,
         auth_user_id,
         public_address,
         encrypted_private_address,
         wallet_management_type,
         network: t.Optional[str] = None,
         wallet_type: t.Optional[WalletType] = None,
     ):
-        session = self.session_factory()
         with session.begin_nested():
             existing_wallet = self.logic.AuthWallet.get_by_auth_user_id(
                 session,

src/quart_sqlalchemy/sim/logic.py

@@ -1,4 +1,3 @@
-import inspect
 import logging
 import secrets
 import typing as t
@@ -12,11 +11,8 @@
 from quart_sqlalchemy.sim import signals
 from quart_sqlalchemy.sim.model import AuthUser as auth_user_model
 from quart_sqlalchemy.sim.model import AuthWallet as auth_wallet_model
-from quart_sqlalchemy.sim.model import ConnectInteropStatus
 from quart_sqlalchemy.sim.model import EntityType
 from quart_sqlalchemy.sim.model import MagicClient as magic_client_model
-from quart_sqlalchemy.sim.model import Provenance
-from quart_sqlalchemy.sim.model import WalletType
 from quart_sqlalchemy.sim.repo_adapter import RepositoryLegacyAdapter
 from quart_sqlalchemy.sim.util import ObjectID
 from quart_sqlalchemy.sim.util import one

src/quart_sqlalchemy/sim/views/auth_user.py

@@ -6,7 +6,6 @@
 from dependency_injector.wiring import Provide
 
 from quart_sqlalchemy.framework import QuartSQLAlchemy
-from quart_sqlalchemy.session import set_global_contextual_session
 
 from ..auth import authorized_request
 from ..auth import RequestCredentials
@@ -51,8 +50,7 @@ def get_auth_user(
     credentials: RequestCredentials = Provide["request_credentials"],
 ) -> ResponseWrapper[AuthUserSchema]:
     with db.bind.Session() as session:
-        with set_global_contextual_session(session):
-            auth_user = auth_user_handler.get_by_session_token(credentials.current_user.value)
+        auth_user = auth_user_handler.get_by_session_token(session, credentials.current_user.value)
 
     return ResponseWrapper[AuthUserSchema](data=AuthUserSchema.from_orm(auth_user))
 
@@ -76,12 +74,12 @@ def create_auth_user(
 ) -> ResponseWrapper[CreateAuthUserResponse]:
     with db.bind.Session() as session:
         with session.begin():
-            with set_global_contextual_session(session):
-                client = auth_user_handler.create_verified_user(
-                    email=data.email,
-                    client_id=credentials.current_client.subject.id,
-                    user_type=EntityType.MAGIC.value,
-                )
+            client = auth_user_handler.create_verified_user(
+                session,
+                email=data.email,
+                client_id=credentials.current_client.subject.id,
+                user_type=EntityType.MAGIC.value,
+            )
 
     return ResponseWrapper[CreateAuthUserResponse](
         data=dict(auth_user=AuthUserSchema.from_orm(client))  # type: ignore

src/quart_sqlalchemy/sim/views/auth_wallet.py

@@ -6,7 +6,6 @@
 from quart import g
 
 from quart_sqlalchemy.framework import QuartSQLAlchemy
-from quart_sqlalchemy.session import set_global_contextual_session
 
 from ..auth import authorized_request
 from ..auth import RequestCredentials
@@ -70,15 +69,15 @@ def sync(
 ) -> ResponseWrapper[WalletSyncResponse]:
     with db.bind.Session() as session:
         with session.begin():
-            with set_global_contextual_session(session):
-                wallet = auth_wallet_handler.sync_auth_wallet(
-                    credentials.current_user.subject.id,
-                    data.public_address,
-                    data.encrypted_private_address,
-                    WalletManagementType.DELEGATED.value,
-                    network=web3.network,
-                    wallet_type=data.wallet_type,
-                )
+            wallet = auth_wallet_handler.sync_auth_wallet(
+                session,
+                credentials.current_user.subject.id,
+                data.public_address,
+                data.encrypted_private_address,
+                WalletManagementType.DELEGATED.value,
+                network=web3.network,
+                wallet_type=data.wallet_type,
+            )
 
     return ResponseWrapper[WalletSyncResponse](
         data=dict(