Auth method refactoring (#183)

## Изменения
Метаклассы AuthMethod перенесены в отдельную папку и разделены на несколько

## Детали реализации
Теперь `AuthPluginMeta` (ex. `AuthMethodMeta`) – это абстрактный класс
минимального плагина аутентификации. Дополнительная функциональность
подключается миксинами:
- `LoginMixin` – требуется для ручки `/login`
- `RegisterMixin` – требуется для ручки `/register`
- `UserdataMixin` – требуется для работы с кафкой и отправки событий в Userdata API

Author: dyakovri

auth_backend/auth_method/__init__.py

@@ -0,0 +1,16 @@
+from .base import AUTH_METHODS, AuthPluginMeta
+from .method_mixins import LoginableMixin, RegistrableMixin
+from .oauth import OauthMeta
+from .session import Session
+from .userdata_mixin import UserdataMixin
+
+
+__all__ = [
+    "Session",
+    "AUTH_METHODS",
+    "AuthPluginMeta",
+    "OauthMeta",
+    "LoginableMixin",
+    "RegistrableMixin",
+    "UserdataMixin",
+]

auth_backend/auth_plugins/auth_method.py auth_backend/auth_method/base.pyauth_backend/auth_plugins/auth_method.py renamed to auth_backend/auth_method/base.py

@@ -1,49 +1,29 @@
 from __future__ import annotations
 
 import logging
-import random
 import re
-import string
-from abc import ABCMeta, abstractmethod
+from abc import ABCMeta
 from asyncio import gather
-from datetime import datetime
-from typing import Annotated, Any, Iterable, final
+from typing import Any, Iterable
 
-from annotated_types import MinLen
-from event_schema.auth import UserLogin, UserLoginKey
-from fastapi import APIRouter, Depends
-from fastapi_sqlalchemy import db
+from fastapi import APIRouter
 from sqlalchemy.orm import Session as DbSession
 
-from auth_backend.base import Base
-from auth_backend.exceptions import LastAuthMethodDelete
-from auth_backend.models.db import AuthMethod, User, UserSession
+from auth_backend.auth_method.session import Session
+from auth_backend.models.db import User, UserSession
 from auth_backend.schemas.types.scopes import Scope as TypeScope
 from auth_backend.settings import get_settings
-from auth_backend.utils.security import UnionAuth
 from auth_backend.utils.user_session_control import create_session
 
 
 logger = logging.getLogger(__name__)
 settings = get_settings()
 
 
-def random_string(length: int = 32) -> str:
-    return "".join([random.choice(string.ascii_letters) for _ in range(length)])
+AUTH_METHODS: dict[str, type[AuthPluginMeta]] = {}
 
 
-class Session(Base):
-    token: Annotated[str, MinLen(1)]
-    expires: datetime
-    id: int
-    user_id: int
-    session_scopes: list[TypeScope]
-
-
-AUTH_METHODS: dict[str, type[AuthMethodMeta]] = {}
-
-
-class AuthMethodMeta(metaclass=ABCMeta):
+class AuthPluginMeta(metaclass=ABCMeta):
     router: APIRouter
     prefix: str
     tags: list[str] = []
@@ -58,35 +38,11 @@ def __init__(self):
         self.router.add_api_route("/login", self._login, methods=["POST"], response_model=Session)
 
     def __init_subclass__(cls, **kwargs):
-        if cls.__name__.endswith('Meta'):
+        if cls.__name__.endswith('Meta') or cls.__name__.endswith('Mixin'):
             return
         logger.info(f'Init authmethod {cls.__name__}')
         AUTH_METHODS[cls.__name__] = cls
 
-    @staticmethod
-    @abstractmethod
-    async def _register(*args, **kwargs) -> object:
-        raise NotImplementedError()
-
-    @staticmethod
-    @abstractmethod
-    async def _login(*args, **kwargs) -> Session:
-        raise NotImplementedError()
-
-    @staticmethod
-    @final
-    def generate_kafka_key(user_id: int) -> UserLoginKey:
-        """
-        Мы генерируем ключи так как для сообщений с одинаковыми ключами
-        Kafka гарантирует последовательность чтений
-        Args:
-            user_id: Айди пользователя
-
-        Returns:
-            Ничего
-        """
-        return UserLoginKey.model_validate({"user_id": user_id})
-
     @staticmethod
     async def _create_session(
         user: User, scopes_list_names: list[TypeScope] | None, session_name: str | None = None, *, db_session: DbSession
@@ -124,11 +80,6 @@ async def _get_user(
             return user_session.user
         return
 
-    @classmethod
-    @abstractmethod
-    async def _convert_data_to_userdata_format(cls, data: Any) -> UserLogin:
-        raise NotImplementedError()
-
     @staticmethod
     async def user_updated(
         new_user: dict[str, Any] | None,
@@ -173,7 +124,7 @@ async def user_updated(
         ```
         """
         exceptions = await gather(
-            *[m.on_user_update(new_user, old_user) for m in AuthMethodMeta.active_auth_methods()],
+            *[m.on_user_update(new_user, old_user) for m in AuthPluginMeta.active_auth_methods()],
             return_exceptions=True,
         )
         if len(exceptions) > 0:
@@ -193,96 +144,7 @@ def is_active(cls):
         return settings.ENABLED_AUTH_METHODS is None or cls.get_name() in settings.ENABLED_AUTH_METHODS
 
     @staticmethod
-    def active_auth_methods() -> Iterable[type['AuthMethodMeta']]:
+    def active_auth_methods() -> Iterable[type['AuthPluginMeta']]:
         for method in AUTH_METHODS.values():
             if method.is_active():
                 yield method
-
-
-class OauthMeta(AuthMethodMeta):
-    """Абстрактная авторизация и аутентификация через OAuth"""
-
-    class UrlSchema(Base):
-        url: str
-
-    def __init__(self):
-        super().__init__()
-        self.router.add_api_route("/redirect_url", self._redirect_url, methods=["GET"], response_model=self.UrlSchema)
-        self.router.add_api_route("/auth_url", self._auth_url, methods=["GET"], response_model=self.UrlSchema)
-        self.router.add_api_route("", self._unregister, methods=["DELETE"])
-
-    @staticmethod
-    @abstractmethod
-    async def _redirect_url(*args, **kwargs) -> UrlSchema:
-        """URL на который происходит редирект после завершения входа на стороне провайдера"""
-        raise NotImplementedError()
-
-    @staticmethod
-    @abstractmethod
-    async def _auth_url(*args, **kwargs) -> UrlSchema:
-        """URL на который происходит редирект из приложения для авторизации на стороне провайдера"""
-        raise NotImplementedError()
-
-    @classmethod
-    async def _unregister(cls, user_session: UserSession = Depends(UnionAuth(scopes=[], auto_error=True))):
-        """Отключает для пользователя метод входа"""
-        old_user = {"user_id": user_session.user.id}
-        new_user = {"user_id": user_session.user.id}
-        old_user_params = await cls._delete_auth_methods(user_session.user, db_session=db.session)
-        old_user[cls.get_name()] = old_user_params
-        await AuthMethodMeta.user_updated(new_user, old_user)
-        return None
-
-    @classmethod
-    async def _get_user(cls, key: str, value: str | int, *, db_session: DbSession) -> User | None:
-        auth_method: AuthMethod = (
-            AuthMethod.query(session=db_session)
-            .filter(
-                AuthMethod.param == key,
-                AuthMethod.value == str(value),
-                AuthMethod.auth_method == cls.get_name(),
-            )
-            .limit(1)
-            .one_or_none()
-        )
-        if auth_method:
-            return auth_method.user
-
-    @classmethod
-    async def _register_auth_method(cls, key: str, value: str | int, user: User, *, db_session) -> AuthMethod:
-        """Добавление пользователю новый AuthMethod"""
-        return AuthMethod.create(
-            user_id=user.id,
-            auth_method=cls.get_name(),
-            param=key,
-            value=str(value),
-            session=db_session,
-        )
-
-    @classmethod
-    async def _delete_auth_methods(cls, user: User, *, db_session) -> list[AuthMethod]:
-        """Удаляет пользователю все AuthMethod конкретной авторизации"""
-        auth_methods: list[AuthMethod] = (
-            AuthMethod.query(session=db_session)
-            .filter(
-                AuthMethod.user_id == user.id,
-                AuthMethod.auth_method == cls.get_name(),
-            )
-            .all()
-        )
-        all_auth_methods = AuthMethod.query(session=db_session).filter(AuthMethod.user_id == user.id).all()
-        if len(all_auth_methods) - len(auth_methods) == 0:
-            raise LastAuthMethodDelete()
-        logger.debug(auth_methods)
-        for method in auth_methods:
-            method.is_deleted = True
-        db_session.flush()
-        return {m.param: m.value for m in auth_methods}
-
-    @classmethod
-    def userdata_process_empty_strings(cls, userdata: UserLogin) -> UserLogin:
-        '''Изменяет значения с пустыми строками в параметре категории юзердаты на None'''
-        for item in userdata.items:
-            if item.value == '':
-                item.value = None
-        return userdata

auth_backend/auth_method/method_mixins.py

@@ -0,0 +1,36 @@
+from abc import ABCMeta, abstractmethod
+
+from .base import AuthPluginMeta
+from .session import Session
+
+
+class RegistrableMixin(AuthPluginMeta, metaclass=ABCMeta):
+    """Сообщает что AuthMethod поддерживает регистрацию
+
+    Обязывает AuthMethod иметь метод `_register`, который используется как апи-запрос `/registration`
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.router.add_api_route("/registration", self._register, methods=["POST"])
+
+    @staticmethod
+    @abstractmethod
+    async def _register(*args, **kwargs) -> object:
+        raise NotImplementedError()
+
+
+class LoginableMixin(AuthPluginMeta, metaclass=ABCMeta):
+    """Сообщает что AuthMethod поддерживает вход
+
+    Обязывает AuthMethod иметь метод `_login`, который используется как апи-запрос `/login`
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.router.add_api_route("/login", self._login, methods=["POST"], response_model=Session)
+
+    @staticmethod
+    @abstractmethod
+    async def _login(*args, **kwargs) -> Session:
+        raise NotImplementedError()

auth_backend/auth_method/oauth.py

@@ -0,0 +1,99 @@
+import logging
+from abc import abstractmethod
+
+from fastapi import Depends
+from fastapi_sqlalchemy import db
+from sqlalchemy.orm import Session as DbSession
+
+from auth_backend.base import Base
+from auth_backend.exceptions import LastAuthMethodDelete
+from auth_backend.models.db import AuthMethod, User, UserSession
+from auth_backend.utils.security import UnionAuth
+
+from .base import AuthPluginMeta
+from .method_mixins import LoginableMixin, RegistrableMixin
+from .userdata_mixin import UserdataMixin
+
+
+logger = logging.getLogger(__name__)
+
+
+class OauthMeta(UserdataMixin, LoginableMixin, RegistrableMixin, AuthPluginMeta):
+    """Абстрактная авторизация и аутентификация через OAuth"""
+
+    class UrlSchema(Base):
+        url: str
+
+    def __init__(self):
+        super().__init__()
+        self.router.add_api_route("/redirect_url", self._redirect_url, methods=["GET"], response_model=self.UrlSchema)
+        self.router.add_api_route("/auth_url", self._auth_url, methods=["GET"], response_model=self.UrlSchema)
+        self.router.add_api_route("", self._unregister, methods=["DELETE"])
+
+    @staticmethod
+    @abstractmethod
+    async def _redirect_url(*args, **kwargs) -> UrlSchema:
+        """URL на который происходит редирект после завершения входа на стороне провайдера"""
+        raise NotImplementedError()
+
+    @staticmethod
+    @abstractmethod
+    async def _auth_url(*args, **kwargs) -> UrlSchema:
+        """URL на который происходит редирект из приложения для авторизации на стороне провайдера"""
+        raise NotImplementedError()
+
+    @classmethod
+    async def _unregister(cls, user_session: UserSession = Depends(UnionAuth(scopes=[], auto_error=True))):
+        """Отключает для пользователя метод входа"""
+        old_user = {"user_id": user_session.user.id}
+        new_user = {"user_id": user_session.user.id}
+        old_user_params = await cls._delete_auth_methods(user_session.user, db_session=db.session)
+        old_user[cls.get_name()] = old_user_params
+        await AuthPluginMeta.user_updated(new_user, old_user)
+        return None
+
+    @classmethod
+    async def _get_user(cls, key: str, value: str | int, *, db_session: DbSession) -> User | None:
+        auth_method: AuthMethod = (
+            AuthMethod.query(session=db_session)
+            .filter(
+                AuthMethod.param == key,
+                AuthMethod.value == str(value),
+                AuthMethod.auth_method == cls.get_name(),
+            )
+            .limit(1)
+            .one_or_none()
+        )
+        if auth_method:
+            return auth_method.user
+
+    @classmethod
+    async def _register_auth_method(cls, key: str, value: str | int, user: User, *, db_session) -> AuthMethod:
+        """Добавление пользователю новый AuthMethod"""
+        return AuthMethod.create(
+            user_id=user.id,
+            auth_method=cls.get_name(),
+            param=key,
+            value=str(value),
+            session=db_session,
+        )
+
+    @classmethod
+    async def _delete_auth_methods(cls, user: User, *, db_session) -> list[AuthMethod]:
+        """Удаляет пользователю все AuthMethod конкретной авторизации"""
+        auth_methods: list[AuthMethod] = (
+            AuthMethod.query(session=db_session)
+            .filter(
+                AuthMethod.user_id == user.id,
+                AuthMethod.auth_method == cls.get_name(),
+            )
+            .all()
+        )
+        all_auth_methods = AuthMethod.query(session=db_session).filter(AuthMethod.user_id == user.id).all()
+        if len(all_auth_methods) - len(auth_methods) == 0:
+            raise LastAuthMethodDelete()
+        logger.debug(auth_methods)
+        for method in auth_methods:
+            method.is_deleted = True
+        db_session.flush()
+        return {m.param: m.value for m in auth_methods}

auth_backend/auth_method/session.py

@@ -0,0 +1,15 @@
+from datetime import datetime
+from typing import Annotated
+
+from annotated_types import MinLen
+
+from auth_backend.base import Base
+from auth_backend.schemas.types.scopes import Scope as TypeScope
+
+
+class Session(Base):
+    token: Annotated[str, MinLen(1)]
+    expires: datetime
+    id: int
+    user_id: int
+    session_scopes: list[TypeScope]