maleo-foundation 0.1.67__tar.gz → 0.1.69__tar.gz

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.1.67
+Version: 0.1.69
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/maleo_foundation/authentication.py

@@ -3,16 +3,28 @@ from starlette.authentication import (
     BaseUser
 )
 from typing import Optional, Sequence
+from maleo_foundation.models.transfers.general.token import BaseTokenGeneralTransfers
+from maleo_foundation.types import BaseTypes
 
 class Credentials(AuthCredentials):
     def __init__(
         self,
-        token:Optional[str] = None,
+        token:BaseTypes.OptionalString = None,
+        payload:Optional[BaseTokenGeneralTransfers.DecodePayload] = None,
         scopes:Optional[Sequence[str]] = None
     ) -> None:
-        self.token = token
+        self._token = token
+        self._payload = payload
         super().__init__(scopes)
 
+    @property
+    def token(self) -> BaseTypes.OptionalString:
+        return self._token
+
+    @property
+    def payload(self) -> Optional[BaseTokenGeneralTransfers.DecodePayload]:
+        return self._payload
+
 class User(BaseUser):
     def __init__(
         self,

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/maleo_foundation/managers/middleware.py

@@ -1,10 +1,10 @@
 from fastapi import FastAPI
 from pydantic import BaseModel, Field
-from typing import List, Optional
+from typing import List
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.models.schemas import BaseGeneralSchemas
 from maleo_foundation.middlewares.authentication import add_authentication_middleware
-from maleo_foundation.middlewares.base import add_base_middleware, RequestProcessor
+from maleo_foundation.middlewares.base import add_base_middleware
 from maleo_foundation.middlewares.cors import add_cors_middleware
 from maleo_foundation.utils.logging import MiddlewareLogger
 

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/maleo_foundation/middlewares/authentication.py

@@ -1,5 +1,6 @@
+from datetime import datetime, timezone
 from fastapi import FastAPI
-from starlette.authentication import AuthenticationBackend
+from starlette.authentication import AuthenticationBackend, AuthenticationError
 from starlette.middleware.authentication import AuthenticationMiddleware
 from starlette.requests import HTTPConnection
 from typing import Tuple
@@ -7,7 +8,7 @@ from maleo_foundation.authentication import Credentials, User
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.models.schemas import BaseGeneralSchemas
 from maleo_foundation.models.transfers.parameters.token import BaseTokenParametersTransfers
-from maleo_foundation.utils.extractor import BaseExtractors
+from maleo_foundation.utils.exceptions import BaseExceptions
 from maleo_foundation.utils.logging import MiddlewareLogger
 
 class Backend(AuthenticationBackend):
@@ -18,25 +19,22 @@ class Backend(AuthenticationBackend):
         self._maleo_foundation = maleo_foundation
 
     async def authenticate(self, conn:HTTPConnection) -> Tuple[Credentials, User]:
-        client_ip = BaseExtractors.extract_client_ip(conn)
         if "Authorization" not in conn.headers:
-            self._logger.info(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Header did not contain authorization")
             return Credentials(), User(authenticated=False)
 
         auth = conn.headers["Authorization"]
         scheme, token = auth.split()
         if scheme != 'Bearer':
-            self._logger.info(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Authorization scheme is not Bearer")
-            return Credentials(), User(authenticated=False)
+            raise AuthenticationError("Authorization scheme must be Bearer token")
 
         decode_token_parameters = BaseTokenParametersTransfers.Decode(key=self._keys.public, token=token)
         decode_token_result = self._maleo_foundation.services.token.decode(parameters=decode_token_parameters)
         if not decode_token_result.success:
-            self._logger.error(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | General: Failed decoding authorization token")
-            return Credentials(token=token), User(authenticated=False)
+            raise AuthenticationError("Invalid Bearer token, unable to decode token")
+        if decode_token_result.data.exp_dt <= datetime.now(tz=timezone.utc):
+            raise AuthenticationError("Expired Bearer token, request new or refresh token")
 
-        self._logger.info(f"Request | IP: {client_ip} | URL: {conn.url.path} - Result | Username: {decode_token_result.data.u_u} | Email: {decode_token_result.data.u_e}")
-        return Credentials(token=token), User(authenticated=True, username=decode_token_result.data.u_u, email=decode_token_result.data.u_e)
+        return Credentials(token=token, payload=decode_token_result.data, scopes=["authenticated"]), User(authenticated=True, username=decode_token_result.data.u_u, email=decode_token_result.data.u_e)
 
 def add_authentication_middleware(app:FastAPI, keys:BaseGeneralSchemas.RSAKeys, logger:MiddlewareLogger, maleo_foundation:MaleoFoundationClientManager) -> None:
     """
@@ -64,4 +62,4 @@ def add_authentication_middleware(app:FastAPI, keys:BaseGeneralSchemas.RSAKeys,
     add_authentication_middleware(app=app, limit=10, window=1, cleanup_interval=60, ip_timeout=300)
     ```
     """
-    app.add_middleware(AuthenticationMiddleware, backend=Backend(keys, logger, maleo_foundation))
+    app.add_middleware(AuthenticationMiddleware, backend=Backend(keys, logger, maleo_foundation), on_error=BaseExceptions.authentication_error_handler)

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/maleo_foundation/middlewares/base.py

@@ -8,6 +8,7 @@ from fastapi import FastAPI, Request, Response, status
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 from typing import Awaitable, Callable, Optional, Sequence
+from maleo_foundation.authentication import Credentials, User
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.models.schemas import BaseGeneralSchemas
 from maleo_foundation.models.responses import BaseResponses
@@ -136,6 +137,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
     def _build_response(
         self,
         request:Request,
+        authentication_info:str,
         response:Response,
         request_timestamp:datetime,
         response_timestamp:datetime,
@@ -146,7 +148,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
         response = self._add_response_headers(request, response, request_timestamp, response_timestamp, process_time)
         log_func = getattr(self._logger, log_level)
         log_func(
-            f"Request | IP: {client_ip} | Method: {request.method} | URL: {request.url.path} | "
+            f"Request {authentication_info} | IP: {client_ip} | Method: {request.method} | URL: {request.url.path} | "
             f"Headers: {dict(request.headers)} - Response | Status: {response.status_code} | "
         )
         return response
@@ -154,11 +156,12 @@ class BaseMiddleware(BaseHTTPMiddleware):
     def _handle_exception(
         self,
         request:Request,
+        authentication_info:str,
         error,
         request_timestamp:datetime,
         response_timestamp:datetime,
         process_time:int,
-        client_ip
+        client_ip:str = "unknown"
     ):
         traceback_str = traceback.format_exc().split("\n")
         error_details = {
@@ -176,7 +179,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
         )
 
         self._logger.error(
-            f"Request | IP: {client_ip} | Method: {request.method} | URL: {request.url.path} | "
+            f"Request {authentication_info} | IP: {client_ip} | Method: {request.method} | URL: {request.url.path} | "
             f"Headers: {dict(request.headers)} - Response | Status: 500 | Exception:\n{json.dumps(error_details, indent=4)}"
         )
 
@@ -190,12 +193,18 @@ class BaseMiddleware(BaseHTTPMiddleware):
         request_timestamp = datetime.now(tz=timezone.utc) #* Record the request timestamp
         start_time = time.perf_counter() #* Record the start time
         client_ip = BaseExtractors.extract_client_ip(request) #* Get request IP with improved extraction
+        user:User = request.user
+        if not user.is_authenticated:
+            authentication_info = "| Unauthenticated"
+        else:
+            authentication_info = f"| Username: {user.display_name} | Email:{user.identity}"
 
         try:
             #* 1. Rate limit check
             if self._check_rate_limit(client_ip):
                 return self._build_response(
                     request=request,
+                    authentication_info=authentication_info,
                     response=JSONResponse(
                         content=BaseResponses.RateLimitExceeded().model_dump(),
                         status_code=status.HTTP_429_TOO_MANY_REQUESTS,
@@ -212,6 +221,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
             if pre_response is not None:
                 return self._build_response(
                     request=request,
+                    authentication_info=authentication_info,
                     response=pre_response,
                     request_timestamp=request_timestamp,
                     response_timestamp=datetime.now(tz=timezone.utc),
@@ -224,6 +234,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
             response = await call_next(request)
             response = self._build_response(
                 request=request,
+                authentication_info=authentication_info,
                 response=response,
                 request_timestamp=request_timestamp,
                 response_timestamp=datetime.now(tz=timezone.utc),
@@ -237,6 +248,7 @@ class BaseMiddleware(BaseHTTPMiddleware):
         except Exception as e:
             return self._handle_exception(
                 request=request,
+                authentication_info=authentication_info,
                 error=e,
                 request_timestamp=request_timestamp,
                 response_timestamp=datetime.now(tz=timezone.utc),

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/maleo_foundation/models/responses.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 from fastapi import status
 from pydantic import Field, model_validator
+from typing import Dict, Type, Union
 from maleo_foundation.models.schemas.general import BaseGeneralSchemas
 from maleo_foundation.models.schemas.result import BaseResultSchemas
 from maleo_foundation.types import BaseTypes
@@ -88,7 +89,7 @@ class BaseResponses:
             return values
 
     #* ----- ----- Responses Class ----- ----- *#
-    other_responses={
+    other_responses:Dict[int, Dict[str, Union[str, Type[Fail]]]]={
         status.HTTP_400_BAD_REQUEST: {
             "description": "Bad Request Response",
             "model": BadRequest

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/maleo_foundation/utils/exceptions.py

@@ -11,17 +11,19 @@ from maleo_foundation.models.transfers.results.service.query import BaseServiceQ
 from maleo_foundation.utils.logging import BaseLogger
 
 class BaseExceptions:
+    @staticmethod
+    def authentication_error_handler(request:Request, exc:Exception):
+        return JSONResponse(content=BaseResponses.Unauthorized(other=str(exc)).model_dump(), status_code=status.HTTP_401_UNAUTHORIZED)
+
     @staticmethod
     async def validation_exception_handler(request:Request, exc:RequestValidationError):
-        return JSONResponse(status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, content=BaseResponses.ValidationError(other=exc.errors()).model_dump())
+        return JSONResponse(content=BaseResponses.ValidationError(other=exc.errors()).model_dump(), status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)
 
     @staticmethod
     async def http_exception_handler(request:Request, exc:StarletteHTTPException):
-        if exc.status_code == 404:
-            return JSONResponse(status_code=status.HTTP_404_NOT_FOUND, content=BaseResponses.NotFound().model_dump())
-
-        #* Handle other HTTP exceptions normally
-        return None
+        if exc.status_code in BaseResponses.other_responses:
+            return JSONResponse(content=BaseResponses.other_responses[exc.status_code]["model"]().model_dump(), status_code=exc.status_code)
+        return JSONResponse(content=BaseResponses.ServerError().model_dump(), status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
     @staticmethod
     def database_exception_handler(

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/maleo_foundation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo_foundation
-Version: 0.1.67
+Version: 0.1.69
 Summary: Foundation package for Maleo
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: MIT

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/maleo_foundation.egg-info/SOURCES.txt

@@ -34,7 +34,6 @@ maleo_foundation/managers/client/google/__init__.py
 maleo_foundation/managers/client/google/base.py
 maleo_foundation/managers/client/google/secret.py
 maleo_foundation/managers/client/google/storage.py
-maleo_foundation/middlewares/__init__.py
 maleo_foundation/middlewares/authentication.py
 maleo_foundation/middlewares/base.py
 maleo_foundation/middlewares/cors.py

{maleo_foundation-0.1.67 → maleo_foundation-0.1.69}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo_foundation"
-version = "0.1.67"
+version = "0.1.69"
 description = "Foundation package for Maleo"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }

maleo_foundation-0.1.67/maleo_foundation/middlewares/__init__.py

@@ -1,98 +0,0 @@
-from fastapi import FastAPI
-from logging import Logger
-from typing import Optional, Sequence
-from .base import add_base_middleware, RequestProcessor
-from .cors import add_cors_middleware
-
-class MiddlewareManager:
-    _default_limit:int = 10
-    _default_window:int = 1
-    _default_cleanup_interval:int = 60
-    _default_ip_timeout:int = 300
-    _default_allow_origins:Sequence[str] = ()
-    _default_allow_methods:Sequence[str] = ("GET",)
-    _default_allow_headers:Sequence[str] = ()
-    _default_allow_credentials:bool = False
-    _default_expose_headers:Sequence[str] = ()
-    _default_request_processor:Optional[RequestProcessor] = None
-
-    def __init__(self, app:FastAPI):
-        self.app = app
-
-    def add_all_middlewares(
-        self,
-        logger:Logger,
-        limit:int = _default_limit,
-        window:int = _default_window,
-        cleanup_interval:int = _default_cleanup_interval,
-        ip_timeout:int = _default_ip_timeout,
-        allow_origins:Sequence[str] = _default_allow_origins,
-        allow_methods:Sequence[str] = _default_allow_methods,
-        allow_headers:Sequence[str] = _default_allow_headers,
-        allow_credentials:bool = _default_allow_credentials,
-        expose_headers:Sequence[str] = _default_expose_headers,
-        request_processor:Optional[RequestProcessor] = _default_request_processor
-    ):
-        self.add_cors_middleware(
-            allow_origins=allow_origins,
-            allow_methods=allow_methods,
-            allow_headers=allow_headers,
-            allow_credentials=allow_credentials,
-            expose_headers=expose_headers
-        )
-        self.add_base_middleware(
-            logger=logger,
-            allow_origins=allow_origins,
-            allow_methods=allow_methods,
-            allow_headers=allow_headers,
-            allow_credentials=allow_credentials,
-            limit=limit,
-            window=window,
-            cleanup_interval=cleanup_interval,
-            ip_timeout=ip_timeout,
-            request_processor=request_processor
-        )
-
-    def add_cors_middleware(
-        self,
-        allow_origins:Sequence[str] = _default_allow_origins,
-        allow_methods:Sequence[str] = _default_allow_methods,
-        allow_headers:Sequence[str] = _default_allow_headers,
-        allow_credentials:bool = _default_allow_credentials,
-        expose_headers:Sequence[str] = _default_expose_headers
-    ):
-        add_cors_middleware(
-            app=self.app,
-            allow_origins=allow_origins,
-            allow_methods=allow_methods,
-            allow_headers=allow_headers,
-            allow_credentials=allow_credentials,
-            expose_headers=expose_headers
-        )
-
-    def add_base_middleware(
-        self,
-        logger:Logger,
-        allow_origins:Sequence[str] = _default_allow_origins,
-        allow_methods:Sequence[str] = _default_allow_methods,
-        allow_headers:Sequence[str] = _default_allow_headers,
-        allow_credentials:bool = _default_allow_credentials,
-        limit:int = _default_limit,
-        window:int = _default_window,
-        cleanup_interval:int = _default_cleanup_interval,
-        ip_timeout:int = _default_ip_timeout,
-        request_processor:Optional[RequestProcessor] = _default_request_processor
-    ):
-        add_base_middleware(
-            app=self.app,
-            logger=logger,
-            allow_origins=allow_origins,
-            allow_methods=allow_methods,
-            allow_headers=allow_headers,
-            allow_credentials=allow_credentials,
-            limit=limit,
-            window=window,
-            cleanup_interval=cleanup_interval,
-            ip_timeout=ip_timeout,
-            request_processor=request_processor
-        )