feat: current progress

src/app/domain/accounts/controllers/access.py

@@ -6,24 +6,32 @@
 
 from advanced_alchemy.utils.text import slugify
 from litestar import Controller, Request, Response, get, post
+from litestar.di import Provide
 from litestar.enums import RequestEncodingType
 from litestar.params import Body
 
 from app.domain.accounts import urls
+from app.domain.accounts.deps import provide_users_service
 from app.domain.accounts.guards import auth, requires_active_user
 from app.domain.accounts.schemas import AccountLogin, AccountRegister, User
+from app.domain.accounts.services import RoleService
+from app.lib.deps import create_service_provider
 
 if TYPE_CHECKING:
     from litestar.security.jwt import OAuth2Login
 
     from app.db import models as m
-    from app.domain.accounts.services import RoleService, UserService
+    from app.domain.accounts.services import UserService
 
 
 class AccessController(Controller):
     """User login and registration."""
 
     tags = ["Access"]
+    dependencies = {
+        "users_service": Provide(provide_users_service),
+        "roles_service": Provide(create_service_provider(RoleService)),
+    }
 
     @post(operation_id="AccountLogin", path=urls.ACCOUNT_LOGIN, exclude_from_auth=True)
     async def login(

src/app/domain/accounts/controllers/user_role.py

@@ -3,10 +3,11 @@
 from __future__ import annotations
 
 from litestar import Controller, post
+from litestar.di import Provide
 from litestar.params import Parameter
 from litestar.repository.exceptions import ConflictError
 
-from app.domain.accounts import schemas, urls
+from app.domain.accounts import deps, schemas, urls
 from app.domain.accounts.guards import requires_superuser
 from app.domain.accounts.services import RoleService, UserRoleService, UserService
 from app.lib.deps import create_service_provider
@@ -19,7 +20,9 @@ class UserRoleController(Controller):
     tags = ["User Account Roles"]
     guards = [requires_superuser]
     dependencies = {
-        "user_roles_service": create_service_provider(UserRoleService),
+        "user_roles_service": Provide(create_service_provider(UserRoleService)),
+        "roles_service": Provide(create_service_provider(RoleService)),
+        "users_service": Provide(deps.provide_users_service),
     }
 
     @post(operation_id="AssignUserRole", path=urls.ACCOUNT_ASSIGN_ROLE)

src/app/domain/accounts/controllers/users.py

@@ -6,9 +6,11 @@
 from uuid import UUID
 
 from litestar import Controller, delete, get, patch, post
+from litestar.di import Provide
 from litestar.params import Dependency, Parameter
 
 from app.domain.accounts import urls
+from app.domain.accounts.deps import provide_users_service
 from app.domain.accounts.guards import requires_superuser
 from app.domain.accounts.schemas import User, UserCreate, UserUpdate
 from app.lib.deps import create_filter_dependencies
@@ -26,16 +28,19 @@ class UserController(Controller):
     tags = ["User Accounts"]
     guards = [requires_superuser]
     dependencies = {
-        "filters": create_filter_dependencies(
-            {
-                "id_filter": UUID,
-                "created_at": True,
-                "updated_at": True,
-                "pagination_size": 20,
-                "sort_field": "email",
-                "sort_order": "asc",
-                "search_fields": ["name", "email"],
-            },
+        "users_service": Provide(provide_users_service),
+        "filters": Provide(
+            create_filter_dependencies(
+                {
+                    "id_filter": UUID,
+                    "created_at": True,
+                    "updated_at": True,
+                    "pagination_size": 20,
+                    "sort_field": "email",
+                    "sort_order": "asc",
+                    "search_fields": ["name", "email"],
+                },
+            )
         ),
     }
 

src/app/domain/accounts/services.py

@@ -98,12 +98,12 @@ async def to_model(self, data: ModelDictT[m.User], operation: str | None = None)
 class RoleService(SQLAlchemyAsyncRepositoryService[m.Role]):
     """Handles database operations for users."""
 
-    class RoleRepository(SQLAlchemyAsyncSlugRepository[m.Role]):
+    class Repository(SQLAlchemyAsyncSlugRepository[m.Role]):
         """User SQLAlchemy Repository."""
 
         model_type = m.Role
 
-    repository_type = RoleRepository
+    repository_type = Repository
     match_fields = ["name"]
 
     async def to_model(self, data: ModelDictT[m.Role], operation: str | None = None) -> m.Role:
@@ -125,20 +125,20 @@ async def _populate_slug(self, data: ModelDictT[m.Team], operation: str | None)
 class UserRoleService(SQLAlchemyAsyncRepositoryService[m.UserRole]):
     """Handles database operations for user roles."""
 
-    class UserRoleRepository(SQLAlchemyAsyncRepository[m.UserRole]):
+    class Repository(SQLAlchemyAsyncRepository[m.UserRole]):
         """User Role SQLAlchemy Repository."""
 
         model_type = m.UserRole
 
-    repository_type = UserRoleRepository
+    repository_type = Repository
 
 
 class UserOAuthAccountService(SQLAlchemyAsyncRepositoryService[m.UserOauthAccount]):
     """Handles database operations for user roles."""
 
-    class UserOauthAccountRepository(SQLAlchemyAsyncRepository[m.UserOauthAccount]):
+    class Repository(SQLAlchemyAsyncRepository[m.UserOauthAccount]):
         """User SQLAlchemy Repository."""
 
         model_type = m.UserOauthAccount
 
-    repository_type = UserOauthAccountRepository
+    repository_type = Repository

src/app/domain/tags/controllers.py

@@ -54,7 +54,6 @@ class TagController(Controller):
                 "search_is_case_sensitive": False,
             },
         ),
-    } | {
         "tags_service": create_service_provider(
             TagService,
             load=[selectinload(m.Tag.teams, recursion_depth=2)],