fastapi-rtk 1.0.9__tar.gz → 1.0.10__tar.gz

{fastapi_rtk-1.0.9 → fastapi_rtk-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 1.0.9
+Version: 1.0.10
 Summary: A package that provides a set of tools to build a FastAPI application with a Class-Based CRUD API.
 Project-URL: Homepage, https://codeberg.org/datatactics/fastapi-rtk
 Project-URL: Issues, https://codeberg.org/datatactics/fastapi-rtk/issues

fastapi_rtk-1.0.10/fastapi_rtk/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.10"

{fastapi_rtk-1.0.9 → fastapi_rtk-1.0.10}/fastapi_rtk/cli/commands/security.py

@@ -238,7 +238,7 @@ async def _check_roles(name: str, create: bool = False):
         if not role:
             if not create:
                 raise Exception(f"Role {name} does not exist")
-            await g.current_app.security.create_role(name=name, session=session)
+            await g.current_app.sm.create_role(name=name, session=session)
 
 
 async def _create_user(
@@ -255,7 +255,7 @@ async def _create_user(
     """
     if role:
         await _check_roles(role, create=create_role)
-    return await g.current_app.security.create_user(
+    return await g.current_app.sm.create_user(
         email=email,
         username=username,
         password=password,
@@ -269,8 +269,8 @@ async def _reset_password(email_or_username: str, password: str):
     """
     Reset user password.
     """
-    user = await g.current_app.security.get_user(email_or_username)
-    return await g.current_app.security.reset_password(user, password)
+    user = await g.current_app.sm.get_user(email_or_username)
+    return await g.current_app.sm.reset_password(user, password)
 
 
 async def export_data(
@@ -281,7 +281,7 @@ async def export_data(
     """
     Export data.
     """
-    data = await g.current_app.security.export_data(data, type)
+    data = await g.current_app.sm.export_data(data, type)
     with open(file_path, "w") as f:
         f.write(data)
 
@@ -290,4 +290,4 @@ async def _cleanup():
     """
     Cleanup unused permissions from apis and roles.
     """
-    await g.current_app.security.cleanup()
+    await g.current_app.sm.cleanup()

{fastapi_rtk-1.0.9 → fastapi_rtk-1.0.10}/fastapi_rtk/db.py

@@ -121,6 +121,7 @@ class UserDatabase(SQLAlchemyUserDatabase[UP, ID]):
             raise NotImplementedError()
 
         await safe_call(self.session.refresh(user))
+        await user.load("oauth_accounts")
         oauth_account = self.oauth_account_table(**create_dict)
         self.session.add(oauth_account)
         user.oauth_accounts.append(oauth_account)

{fastapi_rtk-1.0.9 → fastapi_rtk-1.0.10}/fastapi_rtk/dependencies.py

@@ -85,7 +85,7 @@ def current_permissions(api: BaseApi):
     """
 
     async def current_permissions_depedency(_=Depends(_ensure_roles)):
-        sm = g.current_app.security
+        sm = g.current_app.sm
         api_name = api.__class__.__name__
         permissions = set[str]()
         db_role_ids = list[int]()
@@ -154,10 +154,10 @@ def has_access_dependency(
 
     async def check_permission():
         _ensure_roles(ErrorCode.PERMISSION_DENIED)
+        sm = g.current_app.sm
 
         # First, check built-in roles (avoiding unnecessary DB queries)
         # This also covers the case for API and permission name with pipes
-        sm = g.current_app.security
         if any(
             sm.has_access_in_builtin_roles(
                 role.name, api.__class__.__name__, permission
@@ -178,8 +178,9 @@ def has_access_dependency(
             )
 
         api_name = api.__class__.__name__
-        exist_query = (
-            sqlalchemy.select(Permission)
+        stmt = (
+            sqlalchemy.select(sqlalchemy.literal(True))
+            .select_from(Permission)
             .join(PermissionApi)
             .join(PermissionApi.roles)
             .join(Api)
@@ -188,11 +189,10 @@ def has_access_dependency(
                 Permission.name == permission,
                 Role.id.in_(db_role_ids),
             )
-            .exists()
-        )
-        result: bool = await smart_run(
-            db.current_session.scalar, sqlalchemy.select(exist_query)
+            .limit(1)
         )
+        result = await smart_run(db.current_session.scalar, stmt)
+        result = bool(result)
         if result:
             return
 

{fastapi_rtk-1.0.9 → fastapi_rtk-1.0.10}/fastapi_rtk/fastapi_react_toolkit.py

@@ -54,7 +54,7 @@ from .security.sqla.apis import (
 from .security.sqla.models import Api, Permission, PermissionApi, Role
 from .security.sqla.security_manager import SecurityManager
 from .setting import Setting
-from .utils import deep_merge, multiple_async_contexts, safe_call, smart_run
+from .utils import deep_merge, lazy, multiple_async_contexts, safe_call, smart_run
 from .version import __version__
 
 __all__ = ["FastAPIReactToolkit"]
@@ -161,7 +161,11 @@ class FastAPIReactToolkit:
     # Public attributes
     apis: list[ModelRestApi] = None
     initialized = False
-    security: SecurityManager = None
+    sm: SecurityManager = None
+    security: SecurityManager = lazy(lambda self: self.sm)
+    """
+    Old attribute for `sm`, kept for backward compatibility.
+    """
     started = False
     """
     Indicates whether the application has been started.
@@ -217,7 +221,7 @@ class FastAPIReactToolkit:
         """
         g.current_app = self
         self.apis = []
-        self.security = SecurityManager(self)
+        self.sm = SecurityManager(self)
 
         # Database configuration
         self.create_tables = create_tables
@@ -430,30 +434,30 @@ class FastAPIReactToolkit:
                 session, roles, permission_apis
             )
             if self.cleanup:
-                await self.security.cleanup()
+                await self.sm.cleanup()
             logger.info("DATABASE INITIALIZED")
 
     async def _insert_permissions(self, session: SQLASession):
         permissions = self.total_permissions() + [
-            x[1] for x in self.security.get_api_permission_tuples_from_builtin_roles()
+            x[1] for x in self.sm.get_api_permission_tuples_from_builtin_roles()
         ]
         permissions = list(dict.fromkeys(permissions))
-        return await self.security.create_permissions(permissions, session=session)
+        return await self.sm.create_permissions(permissions, session=session)
 
     async def _insert_apis(self, session: SQLASession):
         apis = [api.__class__.__name__ for api in self.apis] + [
-            x[0] for x in self.security.get_api_permission_tuples_from_builtin_roles()
+            x[0] for x in self.sm.get_api_permission_tuples_from_builtin_roles()
         ]
         apis = list(dict.fromkeys(apis))
-        return await self.security.create_apis(apis, session=session)
+        return await self.sm.create_apis(apis, session=session)
 
     async def _insert_roles(self, session: SQLASession):
-        roles = self.security.get_roles_from_builtin_roles()
+        roles = self.sm.get_roles_from_builtin_roles()
         if g.admin_role and g.admin_role not in roles:
             roles.append(g.admin_role)
         if g.public_role and g.public_role not in roles:
             roles.append(g.public_role)
-        return await self.security.create_roles(roles, session=session)
+        return await self.sm.create_roles(roles, session=session)
 
     async def _associate_permission_with_api(
         self,
@@ -482,7 +486,7 @@ class FastAPIReactToolkit:
         for (
             api_name,
             perm_name,
-        ) in self.security.get_api_permission_tuples_from_builtin_roles():
+        ) in self.sm.get_api_permission_tuples_from_builtin_roles():
             if (perm_name, api_name) in added_permission_api:
                 continue
             permission = permission_map[perm_name]
@@ -490,7 +494,7 @@ class FastAPIReactToolkit:
             permission_api_tuples.append((permission, api_obj))
             added_permission_api.add((permission.name, api_obj.name))
 
-        return await self.security.associate_list_of_permission_with_api(
+        return await self.sm.associate_list_of_permission_with_api(
             permission_api_tuples, session=session
         )
 
@@ -510,7 +514,7 @@ class FastAPIReactToolkit:
         for (
             role_name,
             role_api_permissions,
-        ) in self.security.get_role_and_api_permission_tuples_from_builtin_roles():
+        ) in self.sm.get_role_and_api_permission_tuples_from_builtin_roles():
             for api_name, permission_name in role_api_permissions:
                 role = role_map[role_name]
                 permission_api = permission_api_map[(permission_name, api_name)]
@@ -528,7 +532,7 @@ class FastAPIReactToolkit:
             ]:
                 role_permission_api_tuples.append((admin_role, permission_api))
 
-        await self.security.associate_list_of_role_with_permission_api(
+        await self.sm.associate_list_of_role_with_permission_api(
             role_permission_api_tuples, session=session
         )
 

{fastapi_rtk-1.0.9 → fastapi_rtk-1.0.10}/fastapi_rtk/security/sqla/apis.py

@@ -164,7 +164,7 @@ class UsersApi(ModelRestApi):
                 col.required = False
 
     async def post_add(self, item, params):
-        await g.current_app.security.update_user(
+        await g.current_app.sm.update_user(
             user_update={"password": item.password},
             user=item,
             session=params.session,
@@ -173,7 +173,7 @@ class UsersApi(ModelRestApi):
 
     async def post_update(self, item, params):
         if params.body.password:
-            await g.current_app.security.update_user(
+            await g.current_app.sm.update_user(
                 user_update={"password": params.body.password},
                 user=item,
                 session=params.session,

{fastapi_rtk-1.0.9 → fastapi_rtk-1.0.10}/fastapi_rtk/security/sqla/models.py

@@ -76,12 +76,16 @@ class PermissionApi(Model):
     api_id: Mapped[int] = mapped_column(
         Integer, ForeignKey(f"{API_TABLE}.id"), name=view_menu_id, nullable=False
     )
-    api: Mapped["Api"] = relationship("Api", back_populates="permissions")
+    api: Mapped["Api"] = relationship(
+        "Api", back_populates="permissions", lazy="joined"
+    )
 
     permission_id: Mapped[int] = mapped_column(
         Integer, ForeignKey(f"{PERMISSION_TABLE}.id"), nullable=False
     )
-    permission: Mapped["Permission"] = relationship("Permission", back_populates="apis")
+    permission: Mapped["Permission"] = relationship(
+        "Permission", back_populates="apis", lazy="joined"
+    )
 
     roles: Mapped[list["Role"]] = relationship(
         "Role", secondary=assoc_permission_api_role, back_populates="permissions"

fastapi_rtk-1.0.9/fastapi_rtk/_version.py

@@ -1 +0,0 @@
-__version__ = "1.0.9"