alpha-python 0.6.3__py3-none-any.whl → 0.7.0__py3-none-any.whl

alpha/__init__.py

@@ -64,6 +64,18 @@ from alpha.providers.oidc_provider import (
 from alpha.repositories.models.repository_model import RepositoryModel
 from alpha.repositories.rest_api_repository import RestApiRepository
 from alpha.repositories.sql_alchemy_repository import SqlAlchemyRepository
+from alpha.repositories.refresh.cache_repository import (
+    CacheRefreshRepository,
+)
+from alpha.repositories.refresh.database_repository import (
+    DatabaseRefreshRepository,
+)
+from alpha.repositories.refresh.file_repository import (
+    FileRefreshRepository,
+)
+from alpha.repositories.refresh.memory_repository import (
+    MemoryRefreshRepository,
+)
 from alpha.services.authentication_service import AuthenticationService
 from alpha.services.user_lifecycle_management import UserLifecycleManagement
 from alpha.utils.is_attrs import is_attrs
@@ -156,6 +168,10 @@ __all__ = [
     "RepositoryModel",
     "RestApiRepository",
     "SqlAlchemyRepository",
+    "CacheRefreshRepository",
+    "DatabaseRefreshRepository",
+    "FileRefreshRepository",
+    "MemoryRefreshRepository",
     "AuthenticationService",
     "UserLifecycleManagement",
     "is_attrs",

alpha/interfaces/__init__.py

@@ -9,6 +9,7 @@ from alpha.interfaces.patchable import Patchable
 # import all repository related interfaces
 from alpha.interfaces.api_repository import ApiRepository
 from alpha.interfaces.sql_repository import SqlRepository
+from alpha.interfaces.refresh_repository import RefreshRepository
 
 # import all database related interfaces
 from alpha.interfaces.sql_mapper import SqlMapper
@@ -35,6 +36,7 @@ __all__ = [
     "Patchable",
     "ApiRepository",
     "SqlRepository",
+    "RefreshRepository",
     "SqlMapper",
     "SqlDatabase",
     "UnitOfWork",

alpha/interfaces/http_client.py

@@ -0,0 +1,26 @@
+from typing import Protocol, Any, runtime_checkable
+
+
+@runtime_checkable
+class HTTPClient(Protocol):
+    """Interface for HTTP clients like requests, httpx or a custom
+    implementation.
+
+    This interface is compatible with the popular synchronous HTTP client
+    libraries, for example, the `requests` library, `httpx` library or any
+    custom implementation that follows the same method signatures.
+
+    This interface defines the methods that an HTTP client should implement to
+    be compatible with the REST API repository. It includes methods for making
+    HTTP requests (POST, GET, DELETE, PUT, PATCH) and allows for additional
+    parameters to be passed as needed.
+    """
+
+    cookies: Any
+    headers: Any
+
+    def post(self, url: str, json: Any = None, **kwargs: Any) -> Any: ...
+    def get(self, url: str, **kwargs: Any) -> Any: ...
+    def delete(self, url: str, **kwargs: Any) -> Any: ...
+    def put(self, url: str, json: Any = None, **kwargs: Any) -> Any: ...
+    def patch(self, url: str, json: Any = None, **kwargs: Any) -> Any: ...

alpha/interfaces/providers.py

@@ -1,11 +1,15 @@
 """This module contains interfaces for various types of identity providers."""
 
-from typing import ClassVar, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, ClassVar, Protocol, runtime_checkable, Any
 
 from alpha.interfaces.token_factory import TokenFactory
 from alpha.providers.models.credentials import PasswordCredentials
 from alpha.providers.models.identity import Identity
-from alpha.providers.models.token import Token
+
+if TYPE_CHECKING:
+    from alpha.providers.models.token import Token
+else:
+    Token = Any
 
 
 @runtime_checkable

alpha/interfaces/refresh_repository.py

@@ -0,0 +1,60 @@
+from typing import TYPE_CHECKING, Protocol, Any
+
+if TYPE_CHECKING:
+    from alpha.providers.models.token import Token
+else:
+    Token = Any
+
+
+class RefreshRepository(Protocol):
+    """Repository interface for managing refresh tokens."""
+
+    def get(self, token: str) -> Token:
+        """Get a token by its value.
+
+        Parameters
+        ----------
+        token
+            Token value.
+
+        Returns
+        -------
+        Token
+            Token object with the given token value.
+        """
+        ...
+
+    def create(self, subject: str) -> Token:
+        """Create a new token for a given subject.
+
+        Parameters
+        ----------
+        subject
+            Subject identifier
+
+        Returns
+        -------
+        Token
+            Newly created token object.
+        """
+        ...
+
+    def delete(self, token: str) -> None:
+        """Delete a token by its value.
+
+        Parameters
+        ----------
+        token
+            Token value.
+        """
+        ...
+
+    def delete_all(self, subject: str) -> None:
+        """Delete all tokens for a given subject.
+
+        Parameters
+        ----------
+        subject
+            Subject identifier.
+        """
+        ...

alpha/providers/models/token.py

@@ -1,9 +1,10 @@
 from uuid import UUID
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
 from dataclasses import dataclass
 from typing import Any, Literal
 
 from alpha.domain.models.base_model import BaseDomainModel
+from alpha.utils.secret_generator import generate_secret
 
 
 @dataclass
@@ -79,6 +80,40 @@ class Token(BaseDomainModel):
             ),
         )
 
+    @classmethod
+    def create_refresh(
+        cls,
+        subject: str,
+        max_age_seconds: int = 7 * 24 * 3600,
+        token_length: int = 32,
+    ) -> "Token":
+        """Factory method to create a new Refresh Token instance.
+
+        Parameters
+        ----------
+        subject
+            The subject or user associated with the token.
+        max_age_seconds, optional
+            Optional maximum age of the token in seconds. Defaults to 7 days.
+            If provided, the expires_at will be set to created_at +
+            max_age_seconds.
+        token_length, optional
+            Optional length of the token value. Defaults to 32.
+
+        Returns
+        -------
+        Token
+            A new Refresh Token instance with the provided attributes and generated id and created_at.
+        """
+        return cls(
+            value=generate_secret(token_length),
+            token_type="Refresh",
+            subject=subject,
+            created_at=datetime.now(tz=timezone.utc),
+            expires_at=datetime.now(tz=timezone.utc)
+            + timedelta(seconds=max_age_seconds),
+        )
+
     def to_dict(self) -> dict[str, str | None]:
         """Converts the Token instance to a dictionary.
 
@@ -97,15 +132,18 @@ class Token(BaseDomainModel):
             - "expires_at": ISO format datetime string for when the token
             expires or None.
         """
-        return {
-            "id": str(self.id) if self.id else None,
+
+        obj: dict[str, str | None] = {
             "value": self.value,
             "subject": self.subject,
             "token_type": self.token_type,
-            "created_at": (
-                self.created_at.isoformat() if self.created_at else None
-            ),
-            "expires_at": (
-                self.expires_at.isoformat() if self.expires_at else None
-            ),
         }
+
+        if self.id:
+            obj["id"] = str(self.id)
+        if self.created_at:
+            obj["created_at"] = self.created_at.isoformat()
+        if self.expires_at:
+            obj["expires_at"] = self.expires_at.isoformat()
+
+        return obj

alpha/repositories/__init__.py

@@ -1,4 +1,16 @@
 from alpha.repositories.models.repository_model import RepositoryModel
+from alpha.repositories.refresh.cache_repository import (
+    CacheRefreshRepository,
+)
+from alpha.repositories.refresh.database_repository import (
+    DatabaseRefreshRepository,
+)
+from alpha.repositories.refresh.file_repository import (
+    FileRefreshRepository,
+)
+from alpha.repositories.refresh.memory_repository import (
+    MemoryRefreshRepository,
+)
 from alpha.repositories.rest_api_repository import RestApiRepository
 from alpha.repositories.sql_alchemy_repository import SqlAlchemyRepository
 
@@ -6,4 +18,8 @@ __all__ = [
     "RepositoryModel",
     "RestApiRepository",
     "SqlAlchemyRepository",
+    "CacheRefreshRepository",
+    "DatabaseRefreshRepository",
+    "FileRefreshRepository",
+    "MemoryRefreshRepository",
 ]

alpha/repositories/refresh/__init__.py

@@ -0,0 +1,19 @@
+from alpha.repositories.refresh.cache_repository import (
+    CacheRefreshRepository,
+)
+from alpha.repositories.refresh.database_repository import (
+    DatabaseRefreshRepository,
+)
+from alpha.repositories.refresh.file_repository import (
+    FileRefreshRepository,
+)
+from alpha.repositories.refresh.memory_repository import (
+    MemoryRefreshRepository,
+)
+
+__all__ = [
+    "CacheRefreshRepository",
+    "DatabaseRefreshRepository",
+    "FileRefreshRepository",
+    "MemoryRefreshRepository",
+]

alpha/repositories/refresh/cache_repository.py

@@ -0,0 +1,54 @@
+from typing import Any
+
+from alpha.providers.models.token import Token
+
+
+class CacheRefreshRepository:
+    def __init__(
+        self,
+        cache_connector: Any,
+        token_model: type[Token] = Token,
+        token_max_age_seconds: int = 7 * 24 * 3600,
+        token_length: int = 32,
+    ):
+        """Initialize the CacheRefreshRepository with the given cache connector.
+
+        Parameters
+        ----------
+        cache_connector
+            The cache connector instance to use for cache operations.
+        token_model, optional
+            The model class for tokens, by default Token. The model class
+            should have a `from_dict` class method that takes a dictionary and
+            returns an instance of the model. The dictionary will have the same
+            structure as the token data in the JSON file. The model class
+            should also have a `to_dict` method that converts an instance of
+            the model to a dictionary with the same structure as the token data
+            in the JSON file. The model class should also have a
+            `create_refresh` class method that creates a new refresh token.
+        token_max_age_seconds, optional
+            The maximum age of a token in seconds, by default the equivalent of
+            7 days in seconds
+        token_length, optional
+            The length of the generated token string, by default 32 characters
+        """
+        self._cache_connector = cache_connector
+        self._token_model = token_model
+        self._token_max_age_seconds = token_max_age_seconds
+        self._token_length = token_length
+
+    def get(self, token: str) -> Token:
+        """Get a token by its value."""
+        raise NotImplementedError("Method not implemented yet.")
+
+    def create(self, subject: str) -> Token:
+        """Create a new token for a given subject."""
+        raise NotImplementedError("Method not implemented yet.")
+
+    def delete(self, token: str) -> None:
+        """Delete a token by its value."""
+        raise NotImplementedError("Method not implemented yet.")
+
+    def delete_all(self, subject: str) -> None:
+        """Delete all tokens for a given subject."""
+        raise NotImplementedError("Method not implemented yet.")

alpha/repositories/refresh/database_repository.py

@@ -0,0 +1,145 @@
+from alpha import exceptions
+from alpha.infra.connectors.sql_alchemy import SqlAlchemyDatabase
+from alpha.providers.models.token import Token
+
+
+class DatabaseRefreshRepository:
+    """Implementation of the RefreshRepository interface for database
+    operations.
+
+    This repository uses a SQLAlchemy database connector to manage refresh
+    tokens in a database. It provides methods to get, create, delete, and
+    delete all refresh tokens for a given subject. The tokens are stored in a
+    database table which is mapped to the token model.
+    """
+
+    def __init__(
+        self,
+        database_connector: SqlAlchemyDatabase,
+        token_model: type[Token] = Token,
+        token_max_age_seconds: int = 7 * 24 * 3600,
+        token_length: int = 32,
+    ):
+        """Initialize the DatabaseRefreshRepository with the given database
+        connector and token model.
+
+        Parameters
+        ----------
+        database_connector
+            The database connector instance to use for database operations.
+        token_model, optional
+            The model class for tokens, by default Token. The model class
+            should have a `from_dict` class method that takes a dictionary and
+            returns an instance of the model. The dictionary will have the same
+            structure as the token data in the JSON file. The model class
+            should also have a `to_dict` method that converts an instance of
+            the model to a dictionary with the same structure as the token data
+            in the JSON file. The model class should also have a
+            `create_refresh` class method that creates a new refresh token.
+        token_max_age_seconds, optional
+            The maximum age of a token in seconds, by default the equivalent of
+            7 days in seconds
+        token_length, optional
+            The length of the generated token string, by default 32 characters
+        """
+        self._database_connector = database_connector
+        self._token_model = token_model
+        self._token_max_age_seconds = token_max_age_seconds
+        self._token_length = token_length
+
+    def get(self, token: str) -> Token:
+        """Get a token by its value.
+
+        Parameters
+        ----------
+        token
+            The value of the token to retrieve.
+
+        Returns
+        -------
+        Token
+            The token object corresponding to the given value.
+
+        Raises
+        ------
+        NotFoundException
+            If the token is not found in the database.
+        """
+        with self._database_connector.get_session() as session:
+            result = (
+                session.query(self._token_model)
+                .filter_by(value=token)
+                .one_or_none()
+            )
+
+            if result is None:
+                raise exceptions.NotFoundException("Refresh token not found")
+
+            return result
+
+    def create(self, subject: str) -> Token:
+        """Create a new token for a given subject.
+
+        Parameters
+        ----------
+        subject
+            The subject for which to create the token.
+
+        Returns
+        -------
+        Token
+            The newly created token object.
+        """
+        token = self._token_model.create_refresh(
+            subject=subject,
+            max_age_seconds=self._token_max_age_seconds,
+            token_length=self._token_length,
+        )
+
+        with self._database_connector.get_session() as session:
+            session.add(token)
+            session.commit()
+            session.refresh(token)
+            return token
+
+    def delete(self, token: str) -> None:
+        """Delete a token by its value.
+
+        Parameters
+        ----------
+        token
+            The value of the token to delete.
+
+        Raises
+        ------
+        NotFoundException
+            If the token is not found in the database.
+        """
+        with self._database_connector.get_session() as session:
+            token_obj = (
+                session.query(self._token_model)
+                .filter_by(value=token)
+                .one_or_none()
+            )
+            if token_obj is None:
+                raise exceptions.NotFoundException("Refresh token not found")
+            session.delete(token_obj)
+            session.commit()
+
+    def delete_all(self, subject: str) -> None:
+        """Delete all tokens for a given subject.
+
+        Parameters
+        ----------
+        subject
+            The subject for which to delete all tokens.
+        """
+        with self._database_connector.get_session() as session:
+            tokens = (
+                session.query(self._token_model)
+                .filter_by(subject=subject)
+                .all()
+            )
+            for token in tokens:
+                session.delete(token)
+            session.commit()

alpha/repositories/refresh/file_repository.py

@@ -0,0 +1,167 @@
+import json
+from typing import Any
+
+from alpha import exceptions
+from alpha.providers.models.token import Token
+
+
+class FileRefreshRepository:
+    def __init__(
+        self,
+        file_path: str | None = None,
+        token_model: type[Token] = Token,
+        token_max_age_seconds: int = 7 * 24 * 3600,
+        token_length: int = 32,
+    ):
+        """Initialize the FileRefreshRepository with the given file path.
+
+        Parameters
+        ----------
+        file_path
+            File path for storing refresh tokens if using file storage,
+            by default None. When the value is None the file will be stored in
+            the current working directory. The file should be a JSON file that
+            stores an object of refresh tokens. If the file does not exist, it
+            will be created automatically. The structure of the JSON file
+            should be as follows:
+            ```json
+            {
+                "<TOKEN_VALUE>": {
+                    "value": "<TOKEN_VALUE>",
+                    "token_type": "Refresh",
+                    "subject": "<SUBJECT>",
+                    "created_at": "<ISO8601_DATETIME>",
+                    "expires_at": "<ISO8601_DATETIME>"
+                },
+                ...
+            }
+            ```
+        token_model, optional
+            The model class for tokens, by default Token. The model class
+            should have a `from_dict` class method that takes a dictionary and
+            returns an instance of the model. The dictionary will have the same
+            structure as the token data in the JSON file. The model class
+            should also have a `to_dict` method that converts an instance of
+            the model to a dictionary with the same structure as the token data
+            in the JSON file. The model class should also have a
+            `create_refresh` class method that creates a new refresh token.
+        token_max_age_seconds, optional
+            The maximum age of a token in seconds, by default the equivalent of
+            7 days in seconds
+        token_length, optional
+            The length of the generated token string, by default 32 characters
+        """
+        self._file_path = file_path or "refresh_tokens.json"
+        self._token_model = token_model
+        self._token_max_age_seconds = token_max_age_seconds
+        self._token_length = token_length
+
+        with open(self._file_path, "a+") as file:
+            file.seek(0)
+            try:
+                json.load(file)
+            except json.JSONDecodeError:
+                file.seek(0)
+                file.write("{}")
+                file.truncate()
+
+    def get(self, token: str) -> Token:
+        """Get a token by its value.
+
+        Parameters
+        ----------
+        token
+            The value of the token to retrieve.
+
+        Returns
+        -------
+        Token
+            The token object corresponding to the given value.
+        """
+        with open(self._file_path, "r") as file:
+            tokens_data: dict[str, dict[str, Any]] = json.load(file)
+            token_data = tokens_data.get(token, None)
+
+            if not token_data:
+                raise exceptions.NotFoundException("Refresh token not found")
+
+            return self._token_model.from_dict(token_data)
+
+    def create(self, subject: str) -> Token:
+        """Create a new token for a given subject.
+
+        Parameters
+        ----------
+        subject
+            The subject for which to create a new token.
+
+        Returns
+        -------
+        Token
+            The newly created token object.
+        """
+        token = self._token_model.create_refresh(
+            subject=subject,
+            max_age_seconds=self._token_max_age_seconds,
+            token_length=self._token_length,
+        )
+
+        with open(self._file_path, "r") as file:
+            tokens_data: dict[str, dict[str, Any]] = json.load(file)
+
+        tokens_data[token.value] = token.to_dict()
+
+        with open(self._file_path, "w") as file:
+            json.dump(tokens_data, file, indent=4)
+
+        return token
+
+    def delete(self, token: str) -> None:
+        """Delete a token by its value.
+
+        Parameters
+        ----------
+        token
+            The value of the token to delete.
+
+        Raises
+        ------
+        NotFoundException
+            If the token with the given value is not found in the file.
+        """
+        with open(self._file_path, "r") as file:
+            tokens_data: dict[str, dict[str, Any]] = json.load(file)
+
+        if token in tokens_data:
+            del tokens_data[token]
+
+            with open(self._file_path, "w") as file:
+                json.dump(tokens_data, file, indent=4)
+        else:
+            raise exceptions.NotFoundException("Refresh token not found")
+
+    def delete_all(self, subject: str) -> None:
+        """Delete all tokens for a given subject.
+
+        Parameters
+        ----------
+        subject
+            The subject for which to delete all tokens.
+        """
+        with open(self._file_path, "r") as file:
+            tokens_data: dict[str, dict[str, Any]] = json.load(file)
+
+        tokens_to_delete = [
+            token
+            for token, data in tokens_data.items()
+            if data["subject"] == subject
+        ]
+
+        if not tokens_to_delete:
+            return None
+
+        for token in tokens_to_delete:
+            del tokens_data[token]
+
+        with open(self._file_path, "w") as file:
+            json.dump(tokens_data, file, indent=4)