baobab-auth-core 0.4.0__py3-none-any.whl

baobab_auth_core/__init__.py

@@ -0,0 +1,111 @@
+"""baobab-auth-core — librairie métier d'authentification de l'écosystème Baobab."""
+
+# --- Couche domaine : entités, énumérations, ports, politiques ---
+# --- Couche application : commandes, résultats, services, cas d'usage ---
+from baobab_auth_core.application.commands import (
+    AssignRoleCommand,
+    AuthenticateUserCommand,
+    ChangePasswordCommand,
+    LogoutCommand,
+    RefreshSessionCommand,
+    RegisterUserCommand,
+    RemoveRoleCommand,
+    RevokeAllSessionsCommand,
+    RevokeSessionCommand,
+)
+from baobab_auth_core.application.results import (
+    AuthContext,
+    AuthenticateUserResult,
+    RefreshSessionResult,
+    RegisterUserResult,
+)
+from baobab_auth_core.application.services import AuthorizationService
+from baobab_auth_core.application.use_cases import (
+    AssignRole,
+    AuthenticateUser,
+    ChangePassword,
+    Logout,
+    RefreshSession,
+    RegisterUser,
+    RemoveRole,
+    RevokeAllSessions,
+    RevokeSession,
+)
+from baobab_auth_core.domain.entities import (
+    AuditEvent,
+    Permission,
+    Role,
+    Session,
+    User,
+    UserProfile,
+)
+from baobab_auth_core.domain.enums import AuditEventType, SessionStatus, UserStatus
+from baobab_auth_core.domain.policies import (
+    LockoutPolicy,
+    PasswordPolicy,
+    PermissionPolicy,
+    RolePolicy,
+    SessionPolicy,
+)
+from baobab_auth_core.domain.ports import (
+    AuditRepository,
+    Clock,
+    IdGenerator,
+    PasswordHasher,
+    PermissionRepository,
+    RoleRepository,
+    SessionRepository,
+    TokenProvider,
+    UnitOfWork,
+    UserRepository,
+)
+
+__all__ = [
+    "AssignRole",
+    "AssignRoleCommand",
+    "AuditEvent",
+    "AuditEventType",
+    "AuditRepository",
+    "AuthContext",
+    "AuthenticateUser",
+    "AuthenticateUserCommand",
+    "AuthenticateUserResult",
+    "AuthorizationService",
+    "ChangePassword",
+    "ChangePasswordCommand",
+    "Clock",
+    "IdGenerator",
+    "LockoutPolicy",
+    "Logout",
+    "LogoutCommand",
+    "PasswordHasher",
+    "PasswordPolicy",
+    "Permission",
+    "PermissionPolicy",
+    "PermissionRepository",
+    "RefreshSession",
+    "RefreshSessionCommand",
+    "RefreshSessionResult",
+    "RegisterUser",
+    "RegisterUserCommand",
+    "RegisterUserResult",
+    "RemoveRole",
+    "RemoveRoleCommand",
+    "RevokeAllSessions",
+    "RevokeAllSessionsCommand",
+    "RevokeSession",
+    "RevokeSessionCommand",
+    "Role",
+    "RolePolicy",
+    "RoleRepository",
+    "Session",
+    "SessionPolicy",
+    "SessionRepository",
+    "SessionStatus",
+    "TokenProvider",
+    "UnitOfWork",
+    "User",
+    "UserProfile",
+    "UserRepository",
+    "UserStatus",
+]

baobab_auth_core/application/__init__.py

@@ -0,0 +1 @@
+"""Couche application : commandes, résultats et cas d'usage."""

baobab_auth_core/application/commands/__init__.py

@@ -0,0 +1,35 @@
+"""Commandes de la couche application."""
+
+from baobab_auth_core.application.commands.assign_role_command import AssignRoleCommand
+from baobab_auth_core.application.commands.authenticate_user_command import (
+    AuthenticateUserCommand,
+)
+from baobab_auth_core.application.commands.change_password_command import (
+    ChangePasswordCommand,
+)
+from baobab_auth_core.application.commands.logout_command import LogoutCommand
+from baobab_auth_core.application.commands.refresh_session_command import (
+    RefreshSessionCommand,
+)
+from baobab_auth_core.application.commands.register_user_command import (
+    RegisterUserCommand,
+)
+from baobab_auth_core.application.commands.remove_role_command import RemoveRoleCommand
+from baobab_auth_core.application.commands.revoke_all_sessions_command import (
+    RevokeAllSessionsCommand,
+)
+from baobab_auth_core.application.commands.revoke_session_command import (
+    RevokeSessionCommand,
+)
+
+__all__ = [
+    "AssignRoleCommand",
+    "AuthenticateUserCommand",
+    "ChangePasswordCommand",
+    "LogoutCommand",
+    "RefreshSessionCommand",
+    "RegisterUserCommand",
+    "RemoveRoleCommand",
+    "RevokeAllSessionsCommand",
+    "RevokeSessionCommand",
+]

baobab_auth_core/application/commands/assign_role_command.py

@@ -0,0 +1,22 @@
+"""Commande : attribution d'un rôle à un utilisateur."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class AssignRoleCommand:
+    """Commande d'attribution d'un rôle à un utilisateur cible.
+
+    :param target_user_id: identifiant interne de l'utilisateur cible.
+    :param role_name: nom du rôle à attribuer.
+    :param actor_subject: sujet d'authentification de l'acteur (doit être ADMIN+).
+    :param ip_address: adresse IP de la requête (audit).
+    :param user_agent: user-agent de la requête (audit).
+    :spec: FEAT-003.1
+    """
+
+    target_user_id: str
+    role_name: str
+    actor_subject: str
+    ip_address: str
+    user_agent: str

baobab_auth_core/application/commands/authenticate_user_command.py

@@ -0,0 +1,20 @@
+"""Commande d'authentification d'un utilisateur."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class AuthenticateUserCommand:
+    """Données d'entrée pour le cas d'usage AuthenticateUser.
+
+    :param email: adresse e-mail brute de l'utilisateur.
+    :param password: mot de passe en clair.
+    :param ip_address: adresse IP de l'appelant.
+    :param user_agent: user-agent de l'appelant.
+    :spec: FEAT-002.2
+    """
+
+    email: str
+    password: str
+    ip_address: str
+    user_agent: str

baobab_auth_core/application/commands/change_password_command.py

@@ -0,0 +1,22 @@
+"""Commande : changement de mot de passe par l'utilisateur lui-même."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class ChangePasswordCommand:
+    """Données d'entrée pour le cas d'usage ChangePassword.
+
+    :param actor_subject: sujet d'authentification de l'acteur.
+    :param old_password: mot de passe actuel (en clair).
+    :param new_password: nouveau mot de passe souhaité (en clair).
+    :param ip_address: adresse IP de l'appelant.
+    :param user_agent: user-agent de l'appelant.
+    :spec: FEAT-004.2
+    """
+
+    actor_subject: str
+    old_password: str
+    new_password: str
+    ip_address: str
+    user_agent: str

baobab_auth_core/application/commands/logout_command.py

@@ -0,0 +1,20 @@
+"""Commande de déconnexion d'un utilisateur."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class LogoutCommand:
+    """Données d'entrée pour le cas d'usage Logout.
+
+    :param session_id: identifiant de la session à révoquer.
+    :param actor_subject: sujet de l'acteur initiant la déconnexion (ou ``None``).
+    :param ip_address: adresse IP de l'appelant.
+    :param user_agent: user-agent de l'appelant.
+    :spec: FEAT-002.4
+    """
+
+    session_id: str
+    actor_subject: str | None
+    ip_address: str
+    user_agent: str

baobab_auth_core/application/commands/refresh_session_command.py

@@ -0,0 +1,20 @@
+"""Commande de rafraîchissement d'une session."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class RefreshSessionCommand:
+    """Données d'entrée pour le cas d'usage RefreshSession.
+
+    :param session_id: identifiant de la session à rafraîchir.
+    :param refresh_token_id: valeur du refresh token présenté par le client.
+    :param ip_address: adresse IP de l'appelant.
+    :param user_agent: user-agent de l'appelant.
+    :spec: FEAT-002.3
+    """
+
+    session_id: str
+    refresh_token_id: str
+    ip_address: str
+    user_agent: str

baobab_auth_core/application/commands/register_user_command.py

@@ -0,0 +1,20 @@
+"""Commande d'inscription d'un nouvel utilisateur."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class RegisterUserCommand:
+    """Données d'entrée pour le cas d'usage RegisterUser.
+
+    :param email: adresse e-mail brute de l'utilisateur.
+    :param password: mot de passe en clair (validé et haché par le use case).
+    :param ip_address: adresse IP de l'appelant.
+    :param user_agent: user-agent de l'appelant.
+    :spec: FEAT-002.1
+    """
+
+    email: str
+    password: str
+    ip_address: str
+    user_agent: str

baobab_auth_core/application/commands/remove_role_command.py

@@ -0,0 +1,22 @@
+"""Commande : retrait d'un rôle d'un utilisateur."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class RemoveRoleCommand:
+    """Commande de retrait d'un rôle d'un utilisateur cible.
+
+    :param target_user_id: identifiant interne de l'utilisateur cible.
+    :param role_name: nom du rôle à retirer.
+    :param actor_subject: sujet d'authentification de l'acteur (doit être ADMIN+).
+    :param ip_address: adresse IP de la requête (audit).
+    :param user_agent: user-agent de la requête (audit).
+    :spec: FEAT-003.2
+    """
+
+    target_user_id: str
+    role_name: str
+    actor_subject: str
+    ip_address: str
+    user_agent: str

baobab_auth_core/application/commands/revoke_all_sessions_command.py

@@ -0,0 +1,20 @@
+"""Commande : révocation globale de toutes les sessions d'un utilisateur."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class RevokeAllSessionsCommand:
+    """Données d'entrée pour le cas d'usage RevokeAllSessions.
+
+    :param target_user_id: identifiant interne de l'utilisateur cible.
+    :param actor_subject: sujet d'authentification de l'acteur.
+    :param ip_address: adresse IP de l'appelant.
+    :param user_agent: user-agent de l'appelant.
+    :spec: FEAT-004.3
+    """
+
+    target_user_id: str
+    actor_subject: str
+    ip_address: str
+    user_agent: str

baobab_auth_core/application/commands/revoke_session_command.py

@@ -0,0 +1,20 @@
+"""Commande de révocation d'une session par un acteur."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class RevokeSessionCommand:
+    """Données d'entrée pour le cas d'usage RevokeSession.
+
+    :param session_id: identifiant de la session à révoquer.
+    :param actor_subject: sujet de l'acteur demandant la révocation.
+    :param ip_address: adresse IP de l'appelant.
+    :param user_agent: user-agent de l'appelant.
+    :spec: FEAT-002.5
+    """
+
+    session_id: str
+    actor_subject: str
+    ip_address: str
+    user_agent: str

baobab_auth_core/application/results/__init__.py

@@ -0,0 +1,17 @@
+"""Résultats de la couche application."""
+
+from baobab_auth_core.application.results.auth_context import AuthContext
+from baobab_auth_core.application.results.authenticate_user_result import (
+    AuthenticateUserResult,
+)
+from baobab_auth_core.application.results.refresh_session_result import (
+    RefreshSessionResult,
+)
+from baobab_auth_core.application.results.register_user_result import RegisterUserResult
+
+__all__ = [
+    "AuthContext",
+    "AuthenticateUserResult",
+    "RefreshSessionResult",
+    "RegisterUserResult",
+]

baobab_auth_core/application/results/auth_context.py

@@ -0,0 +1,40 @@
+"""Contexte d'autorisation d'un acteur authentifié."""
+
+from dataclasses import dataclass
+
+from baobab_auth_core.domain.value_objects.auth_subject import AuthSubject
+from baobab_auth_core.domain.value_objects.permission_name import PermissionName
+from baobab_auth_core.domain.value_objects.role_name import RoleName
+
+
+@dataclass(frozen=True, slots=True)
+class AuthContext:
+    """Contexte d'autorisation construit depuis le référentiel des rôles.
+
+    Regroupe les rôles et les permissions effectifs d'un acteur authentifié.
+
+    :param auth_subject: identifiant stable de l'acteur.
+    :param roles: ensemble figé des rôles de l'acteur.
+    :param permissions: ensemble figé des permissions cumulées.
+    :spec: FEAT-003.3
+    """
+
+    auth_subject: AuthSubject
+    roles: frozenset[RoleName]
+    permissions: frozenset[PermissionName]
+
+    def has_role(self, role: RoleName) -> bool:
+        """Retourne ``True`` si l'acteur possède le rôle donné.
+
+        :param role: rôle à vérifier.
+        :returns: ``True`` si le rôle est présent.
+        """
+        return role in self.roles
+
+    def has_permission(self, permission: PermissionName) -> bool:
+        """Retourne ``True`` si l'acteur possède la permission donnée.
+
+        :param permission: permission à vérifier.
+        :returns: ``True`` si la permission est présente.
+        """
+        return permission in self.permissions

baobab_auth_core/application/results/authenticate_user_result.py

@@ -0,0 +1,22 @@
+"""Résultat de l'authentification d'un utilisateur."""
+
+from dataclasses import dataclass
+
+from baobab_auth_core.domain.value_objects.utc_datetime import UtcDatetime
+
+
+@dataclass(frozen=True, slots=True)
+class AuthenticateUserResult:
+    """Résultat du cas d'usage AuthenticateUser.
+
+    :param session_id: identifiant de la session créée.
+    :param refresh_token_id: identifiant du refresh token émis.
+    :param user_id: identifiant de l'utilisateur authentifié.
+    :param expires_at: date d'expiration de la session (UTC).
+    :spec: FEAT-002.2
+    """
+
+    session_id: str
+    refresh_token_id: str
+    user_id: str
+    expires_at: UtcDatetime

baobab_auth_core/application/results/refresh_session_result.py

@@ -0,0 +1,20 @@
+"""Résultat du rafraîchissement d'une session."""
+
+from dataclasses import dataclass
+
+from baobab_auth_core.domain.value_objects.utc_datetime import UtcDatetime
+
+
+@dataclass(frozen=True, slots=True)
+class RefreshSessionResult:
+    """Résultat du cas d'usage RefreshSession.
+
+    :param session_id: identifiant de la session rafraîchie.
+    :param refresh_token_id: nouvel identifiant du refresh token (rotation).
+    :param expires_at: date d'expiration de la session (UTC).
+    :spec: FEAT-002.3
+    """
+
+    session_id: str
+    refresh_token_id: str
+    expires_at: UtcDatetime

baobab_auth_core/application/results/register_user_result.py

@@ -0,0 +1,16 @@
+"""Résultat de l'inscription d'un utilisateur."""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class RegisterUserResult:
+    """Résultat du cas d'usage RegisterUser.
+
+    :param user_id: identifiant interne du nouvel utilisateur.
+    :param auth_subject: sujet d'authentification opaque du nouvel utilisateur.
+    :spec: FEAT-002.1
+    """
+
+    user_id: str
+    auth_subject: str

baobab_auth_core/application/services/__init__.py

@@ -0,0 +1,7 @@
+"""Services applicatifs (lecture, autorisation)."""
+
+from baobab_auth_core.application.services.authorization_service import (
+    AuthorizationService,
+)
+
+__all__ = ["AuthorizationService"]

baobab_auth_core/application/services/authorization_service.py

@@ -0,0 +1,56 @@
+"""Service d'autorisation : construction du contexte d'autorisation."""
+
+from baobab_auth_core.application.results.auth_context import AuthContext
+from baobab_auth_core.domain.ports.role_repository import RoleRepository
+from baobab_auth_core.domain.ports.user_repository import UserRepository
+from baobab_auth_core.domain.value_objects.auth_subject import AuthSubject
+from baobab_auth_core.domain.value_objects.permission_name import PermissionName
+from baobab_auth_core.exceptions.user import UserNotFoundError
+
+
+class AuthorizationService:
+    """Construit le contexte d'autorisation d'un acteur authentifié.
+
+    Agrège les rôles de l'utilisateur et les permissions associées à chaque rôle
+    pour produire un :class:`AuthContext` utilisable dans les guards.
+
+    :param users: référentiel des utilisateurs.
+    :param roles: référentiel des rôles (pour résoudre les permissions).
+    :spec: FEAT-003.3
+    """
+
+    def __init__(
+        self,
+        *,
+        users: UserRepository,
+        roles: RoleRepository,
+    ) -> None:
+        """Initialise le service avec ses dépendances."""
+        self._users = users
+        self._roles = roles
+
+    def build_context(self, auth_subject: AuthSubject) -> AuthContext:
+        """Construit le contexte d'autorisation pour un acteur.
+
+        Charge l'utilisateur, puis résout les permissions de chacun de ses rôles.
+
+        :param auth_subject: identifiant de l'acteur.
+        :returns: contexte d'autorisation peuplé.
+        :raises UserNotFoundError: si l'acteur est introuvable.
+        :spec: FEAT-003.3
+        """
+        user = self._users.get_by_auth_subject(auth_subject)
+        if user is None:
+            raise UserNotFoundError(f"utilisateur {auth_subject.value!r} introuvable")
+
+        permissions: set[PermissionName] = set()
+        for role_name in user.roles:
+            role = self._roles.get_by_name(role_name)
+            if role is not None:
+                permissions |= role.permissions
+
+        return AuthContext(
+            auth_subject=auth_subject,
+            roles=frozenset(user.roles),
+            permissions=frozenset(permissions),
+        )

baobab_auth_core/application/use_cases/__init__.py

@@ -0,0 +1,23 @@
+"""Cas d'usage de la couche application."""
+
+from baobab_auth_core.application.use_cases.assign_role import AssignRole
+from baobab_auth_core.application.use_cases.authenticate_user import AuthenticateUser
+from baobab_auth_core.application.use_cases.change_password import ChangePassword
+from baobab_auth_core.application.use_cases.logout import Logout
+from baobab_auth_core.application.use_cases.refresh_session import RefreshSession
+from baobab_auth_core.application.use_cases.register_user import RegisterUser
+from baobab_auth_core.application.use_cases.remove_role import RemoveRole
+from baobab_auth_core.application.use_cases.revoke_all_sessions import RevokeAllSessions
+from baobab_auth_core.application.use_cases.revoke_session import RevokeSession
+
+__all__ = [
+    "AssignRole",
+    "AuthenticateUser",
+    "ChangePassword",
+    "Logout",
+    "RefreshSession",
+    "RegisterUser",
+    "RemoveRole",
+    "RevokeAllSessions",
+    "RevokeSession",
+]

baobab_auth_core/application/use_cases/assign_role.py

@@ -0,0 +1,96 @@
+"""Cas d'usage : attribution d'un rôle à un utilisateur."""
+
+from baobab_auth_core.application.commands.assign_role_command import AssignRoleCommand
+from baobab_auth_core.domain.entities.audit_event import AuditEvent
+from baobab_auth_core.domain.enums.audit_event_type import AuditEventType
+from baobab_auth_core.domain.ports.audit_repository import AuditRepository
+from baobab_auth_core.domain.ports.clock import Clock
+from baobab_auth_core.domain.ports.id_generator import IdGenerator
+from baobab_auth_core.domain.ports.role_repository import RoleRepository
+from baobab_auth_core.domain.ports.unit_of_work import UnitOfWork
+from baobab_auth_core.domain.ports.user_repository import UserRepository
+from baobab_auth_core.domain.value_objects.auth_subject import AuthSubject
+from baobab_auth_core.domain.value_objects.role_name import RoleName
+from baobab_auth_core.exceptions.authorization import ForbiddenError
+from baobab_auth_core.exceptions.role import RoleNotFoundError
+from baobab_auth_core.exceptions.user import UserNotFoundError
+
+_ADMIN_ROLES = {RoleName(value="ADMIN"), RoleName(value="SUPER_ADMIN")}
+
+
+class AssignRole:
+    """Attribue un rôle à un utilisateur au nom d'un acteur autorisé.
+
+    L'acteur doit posséder le rôle ``ADMIN`` ou ``SUPER_ADMIN``.
+    L'opération est idempotente : attribuer un rôle déjà présent n'a pas d'effet.
+
+    :param users: référentiel des utilisateurs.
+    :param roles: référentiel des rôles.
+    :param id_gen: générateur d'identifiants (audit).
+    :param clock: source de temps courante.
+    :param audit: référentiel d'événements d'audit.
+    :param uow: gestionnaire de transaction.
+    :spec: FEAT-003.1
+    """
+
+    def __init__(
+        self,
+        *,
+        users: UserRepository,
+        roles: RoleRepository,
+        id_gen: IdGenerator,
+        clock: Clock,
+        audit: AuditRepository,
+        uow: UnitOfWork,
+    ) -> None:
+        """Initialise le use case avec ses dépendances."""
+        self._users = users
+        self._roles = roles
+        self._id_gen = id_gen
+        self._clock = clock
+        self._audit = audit
+        self._uow = uow
+
+    def execute(self, command: AssignRoleCommand) -> None:
+        """Exécute l'attribution d'un rôle.
+
+        :param command: données d'entrée de l'attribution.
+        :raises ForbiddenError: si l'acteur n'est pas ADMIN ni SUPER_ADMIN.
+        :raises UserNotFoundError: si l'utilisateur cible est introuvable.
+        :raises RoleNotFoundError: si le rôle n'existe pas.
+        :spec: FEAT-003.1
+        """
+        now = self._clock.now()
+        actor_subject = AuthSubject(value=command.actor_subject)
+
+        actor = self._users.get_by_auth_subject(actor_subject)
+        if actor is None or not bool(actor.roles & _ADMIN_ROLES):
+            raise ForbiddenError("accès refusé : droits insuffisants")
+
+        target = self._users.get_by_id(command.target_user_id)
+        if target is None:
+            raise UserNotFoundError(f"utilisateur {command.target_user_id!r} introuvable")
+
+        role_name = RoleName(value=command.role_name)
+        if self._roles.get_by_name(role_name) is None:
+            raise RoleNotFoundError(f"rôle {command.role_name!r} introuvable")
+
+        target.assign_role(role_name, now)
+
+        with self._uow:
+            self._users.save(target)
+            self._audit.save(
+                AuditEvent(
+                    id=self._id_gen.generate(),
+                    actor_subject=actor_subject,
+                    event_type=AuditEventType.ROLE_ASSIGNED,
+                    target_type="user",
+                    target_id=target.id,
+                    ip_address=command.ip_address,
+                    user_agent=command.user_agent,
+                    metadata={"role": command.role_name},
+                    created_at=now,
+                    severity="INFO",
+                )
+            )
+            self._uow.commit()