maleo-foundation 0.3.72__py3-none-any.whl → 0.3.74__py3-none-any.whl

maleo_foundation/middlewares/base.py

@@ -1,21 +1,35 @@
 import json
+import re
 import threading
-import time
 import traceback
 from collections import defaultdict
 from datetime import datetime, timedelta, timezone
-from typing import Awaitable, Callable, Optional, Sequence, Dict, List
+from typing import Awaitable, Callable, Optional, Dict, List
+from uuid import UUID, uuid4
 
 from fastapi import FastAPI, Request, Response, status
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 from starlette.types import ASGIApp
 
-from maleo_foundation.authentication import Authentication
 from maleo_foundation.enums import BaseEnums
 from maleo_foundation.client.manager import MaleoFoundationClientManager
 from maleo_foundation.models.schemas import BaseGeneralSchemas
 from maleo_foundation.models.responses import BaseResponses
+from maleo_foundation.models.transfers.general.authentication import Authentication
+from maleo_foundation.models.transfers.general.operation import (
+    OperationOrigin,
+    OperationLayer,
+    OperationTarget,
+    OperationContext,
+    OperationMetadata,
+    OperationException,
+    OperationTimestamps,
+    OperationResult,
+    Operation,
+)
+from maleo_foundation.models.transfers.general.service import ServiceContext
+from maleo_foundation.models.transfers.general.settings import Settings
 from maleo_foundation.models.transfers.general.token import (
     MaleoFoundationTokenGeneralTransfers,
 )
@@ -26,7 +40,11 @@ from maleo_foundation.models.transfers.parameters.signature import (
     MaleoFoundationSignatureParametersTransfers,
 )
 from maleo_foundation.models.transfers.general.request import RequestContext
-from maleo_foundation.utils.extractor import extract_request_context
+from maleo_foundation.models.transfers.general.response import ResponseContext
+from maleo_foundation.utils.extractor import (
+    extract_authentication,
+    extract_request_context,
+)
 from maleo_foundation.utils.logging import MiddlewareLogger
 
 RequestProcessor = Callable[[Request], Awaitable[Optional[Response]]]
@@ -74,7 +92,7 @@ class RateLimiter:
             self._requests[client_ip].append(now)
             return False
 
-    def cleanup_old_data(self, logger: MiddlewareLogger) -> None:
+    def cleanup_old_data(self) -> None:
         """Clean up old request data to prevent memory growth."""
         now = datetime.now()
         if now - self._last_cleanup <= self.cleanup_interval:
@@ -100,10 +118,6 @@ class RateLimiter:
                 self._last_seen.pop(ip, None)
 
             self._last_cleanup = now
-            logger.debug(
-                f"Cleaned up request cache. Removed {len(inactive_ips)} inactive IPs. "
-                f"Current tracked IPs: {len(self._requests)}"
-            )
 
 
 class ResponseBuilder:
@@ -117,42 +131,26 @@ class ResponseBuilder:
         self.keys = keys
         self.maleo_foundation = maleo_foundation
 
-    def add_response_headers(
-        self,
-        authentication: Authentication,
-        response: Response,
-        request_context: RequestContext,
-        responded_at: datetime,
-        process_time: float,
-    ) -> Response:
-        """Add custom headers to response."""
-        # Basic headers
-        response.headers["X-Request-ID"] = str(request_context.request_id)
-        response.headers["X-Process-Time"] = str(process_time)
-        response.headers["X-Requested-At"] = request_context.requested_at.isoformat()
-        response.headers["X-Responded-At"] = responded_at.isoformat()
-
-        # Add signature header
-        self._add_signature_header(
-            response, request_context, responded_at, process_time
-        )
-
-        # Add new authorization header if needed
-        self._add_new_authorization_header(request_context, authentication, response)
-
-        return response
-
     def _add_signature_header(
         self,
-        response: Response,
-        request_context: RequestContext,
+        operation_id: UUID,
+        request_id: UUID,
+        method: str,
+        url: str,
+        requested_at: datetime,
         responded_at: datetime,
         process_time: float,
+        response: Response,
     ) -> None:
         """Generate and add signature header."""
         message = (
-            f"{request_context.method}|{request_context.url}|{request_context.requested_at.isoformat()}|"
-            f"{responded_at.isoformat()}|{str(process_time)}|{str(request_context.request_id)}"
+            f"{str(operation_id)}|"
+            f"{str(request_id)}"
+            f"{method}|"
+            f"{url}|"
+            f"{requested_at.isoformat()}|"
+            f"{responded_at.isoformat()}|"
+            f"{str(process_time)}|"
         )
 
         sign_parameters = MaleoFoundationSignatureParametersTransfers.Sign(
@@ -165,6 +163,22 @@ class ResponseBuilder:
         if sign_result.success and sign_result.data is not None:
             response.headers["X-Signature"] = sign_result.data.signature
 
+    def _should_regenerate_auth(
+        self,
+        request_context: RequestContext,
+        authentication: Authentication,
+        response: Response,
+    ) -> bool:
+        """Check if authorization should be regenerated."""
+        if authentication.credentials.token is not None:
+            return (
+                authentication.user.is_authenticated
+                and authentication.credentials.token.type == BaseEnums.TokenType.REFRESH
+                and 200 <= response.status_code < 300
+                and "logout" not in request_context.url
+            )
+        return False
+
     def _add_new_authorization_header(
         self,
         request_context: RequestContext,
@@ -190,84 +204,39 @@ class ResponseBuilder:
         if result.success and result.data is not None:
             response.headers["X-New-Authorization"] = result.data.token
 
-    def _should_regenerate_auth(
+    def add_response_headers(
         self,
+        operation_id: UUID,
         request_context: RequestContext,
         authentication: Authentication,
         response: Response,
-    ) -> bool:
-        """Check if authorization should be regenerated."""
-        if authentication.credentials.token is not None:
-            return (
-                authentication.user.is_authenticated
-                and authentication.credentials.token.type == BaseEnums.TokenType.REFRESH
-                and 200 <= response.status_code < 300
-                and "logout" not in request_context.url
-            )
-        return False
-
-
-class RequestLogger:
-    """Handles request/response logging."""
-
-    def __init__(self, logger: MiddlewareLogger):
-        self.logger = logger
-
-    def log_request_response(
-        self,
-        authentication: Authentication,
-        response: Response,
-        request_context: RequestContext,
-        log_level: str = "info",
-    ) -> None:
-        """Log request and response details."""
-        authentication_info = self._get_authentication_info(authentication)
-
-        log_func = getattr(self.logger, log_level)
-        log_func(
-            f"Request | ID: {request_context.request_id} {authentication_info} | "
-            f"IP: {request_context.ip_address} | Host: {request_context.host} | "
-            f"Method: {request_context.method} | URL: {request_context.url} | "
-            f"Query Parameters: {request_context.query_params} - "
-            f"Response | Status: {response.status_code}"
-        )
+        responded_at: datetime,
+        process_time: float,
+    ) -> Response:
+        """Add custom headers to response."""
+        # Basic headers
+        response.headers["X-Operation-Id"] = str(operation_id)
+        response.headers["X-Process-Time"] = str(process_time)
+        response.headers["X-Request-Id"] = str(request_context.request_id)
+        response.headers["X-Requested-At"] = request_context.requested_at.isoformat()
+        response.headers["X-Responded-At"] = responded_at.isoformat()
 
-    def log_exception(
-        self,
-        authentication: Authentication,
-        error: Exception,
-        request_context: RequestContext,
-    ) -> None:
-        """Log exception details."""
-        authentication_info = self._get_authentication_info(authentication)
-
-        error_details = {
-            "request_context": request_context.model_dump(mode="json"),
-            "error": str(error),
-            "traceback": traceback.format_exc().split("\n"),
-        }
-
-        self.logger.error(
-            f"Request | ID: {request_context.request_id} {authentication_info} | "
-            f"IP: {request_context.ip_address} | Host: {request_context.host} | "
-            f"Method: {request_context.method} | URL: {request_context.url} | "
-            f"Query Parameters: {request_context.query_params} - "
-            f"Response | Status: 500 | Exception:\n{json.dumps(error_details, indent=4)}"
+        # Add signature header
+        self._add_signature_header(
+            operation_id=operation_id,
+            request_id=request_context.request_id,
+            method=request_context.method,
+            url=request_context.url,
+            requested_at=request_context.requested_at,
+            responded_at=responded_at,
+            process_time=process_time,
+            response=response,
         )
 
-    def _get_authentication_info(self, authentication: Authentication) -> str:
-        """Get authentication info string."""
-        if not authentication.user.is_authenticated:
-            return "| Unauthenticated"
-
-        if authentication.credentials.token is not None:
-            return (
-                f"| Token type: {authentication.credentials.token.type} | "
-                f"Username: {authentication.user.display_name} | "
-                f"Email: {authentication.user.identity}"
-            )
+        # Add new authorization header if needed
+        self._add_new_authorization_header(request_context, authentication, response)
 
-        return "| Unauthenticated"
+        return response
 
 
 class BaseMiddleware(BaseHTTPMiddleware):
@@ -276,13 +245,10 @@ class BaseMiddleware(BaseHTTPMiddleware):
     def __init__(
         self,
         app: ASGIApp,
+        settings: Settings,
         keys: BaseGeneralSchemas.RSAKeys,
         logger: MiddlewareLogger,
         maleo_foundation: MaleoFoundationClientManager,
-        allow_origins: Sequence[str] = (),
-        allow_methods: Sequence[str] = ("GET",),
-        allow_headers: Sequence[str] = (),
-        allow_credentials: bool = False,
         limit: int = 10,
         window: int = 1,
         cleanup_interval: int = 60,
@@ -290,6 +256,9 @@ class BaseMiddleware(BaseHTTPMiddleware):
     ):
         super().__init__(app)
 
+        self._settings = settings
+        self._logger = logger
+
         # Core components
         self.rate_limiter = RateLimiter(
             limit=limit,
@@ -298,130 +267,279 @@ class BaseMiddleware(BaseHTTPMiddleware):
             cleanup_interval=timedelta(seconds=cleanup_interval),
         )
         self.response_builder = ResponseBuilder(keys, maleo_foundation)
-        self.request_logger = RequestLogger(logger)
 
-        # CORS settings (if needed)
-        self.cors_config = {
-            "allow_origins": allow_origins,
-            "allow_methods": allow_methods,
-            "allow_headers": allow_headers,
-            "allow_credentials": allow_credentials,
-        }
+        # define service_context
+        self.service_context = ServiceContext(
+            key=self._settings.SERVICE_KEY, environment=self._settings.ENVIRONMENT
+        )
+
+        # define operation context
+        self.operation_context = OperationContext(
+            origin=OperationOrigin(
+                type=BaseEnums.OperationOrigin.SERVICE, properties=None
+            ),
+            layer=OperationLayer(
+                type=BaseEnums.OperationLayer.MIDDLEWARE, properties=None
+            ),
+            target=OperationTarget(
+                type=BaseEnums.OperationTarget.INTERNAL, properties=None
+            ),
+        )
+
+    def _build_operation_metadata(
+        self, request_context: RequestContext
+    ) -> OperationMetadata:
+        operation_type = BaseEnums.OperationType.OTHER
+        create_type = None
+        update_type = None
+        status_update_type = None
+
+        if request_context.method == "POST":
+            operation_type = BaseEnums.OperationType.CREATE
+            if request_context.url.endswith("/restore"):
+                create_type = BaseEnums.CreateType.RESTORE
+            else:
+                create_type = BaseEnums.CreateType.CREATE
+        elif request_context.method == "GET":
+            operation_type = BaseEnums.OperationType.READ
+        elif request_context.method in ["PATCH", "PUT"]:
+            operation_type = BaseEnums.OperationType.UPDATE
+            if request_context.method == "PUT":
+                update_type = BaseEnums.UpdateType.DATA
+            elif request_context.method == "PATCH":
+                if request_context.url.endswith("/status"):
+                    update_type = BaseEnums.UpdateType.STATUS
+                    if request_context.query_params is not None:
+                        match = re.search(
+                            r"[?&]action=([^&]+)", request_context.query_params
+                        )
+                        if match:
+                            try:
+                                status_update_type = BaseEnums.StatusUpdateType(
+                                    match.group(1)
+                                )
+                            except Exception:
+                                pass
+                else:
+                    update_type = BaseEnums.UpdateType.DATA
+        elif request_context.method == "DELETE":
+            operation_type = BaseEnums.OperationType.DELETE
+
+        metadata = OperationMetadata(
+            type=operation_type,
+            create_type=create_type,
+            update_type=update_type,
+            status_update_type=status_update_type,
+        )
+
+        return metadata
+
+    def _log_operation(
+        self,
+        operation: Operation,
+        log_level: BaseEnums.LogLevel = BaseEnums.LogLevel.INFO,
+    ) -> None:
+        exc_info = (
+            log_level is BaseEnums.LogLevel.FATAL
+            or log_level is BaseEnums.LogLevel.ERROR
+            or log_level is BaseEnums.LogLevel.CRITICAL
+        )
+
+        self._logger.log(int(log_level), operation.to_log_string(), exc_info=exc_info)
+
+        return None
 
     async def dispatch(
         self, request: Request, call_next: RequestResponseEndpoint
     ) -> Response:
         """Main middleware dispatch method."""
         # Setup
-        self.rate_limiter.cleanup_old_data(self.request_logger.logger)
+        self.rate_limiter.cleanup_old_data()
+
+        # Assign operation id
+        operation_id = request.headers.get("X-Operation-Id", None)
+        if operation_id is None:
+            operation_id = uuid4()
+        else:
+            operation_id = UUID(operation_id)
+        request.state.operation_id = operation_id
+
+        # Assign request id and timestamp
+        request.state.request_id = uuid4()
+        request.state.requested_at = datetime.now(tz=timezone.utc)
+
+        # Extract and assign request context
         request_context = extract_request_context(request)
         request.state.request_context = request_context
-        start_time = time.perf_counter()
-        authentication = Authentication(credentials=request.auth, user=request.user)
 
-        try:
-            # Rate limiting check
-            if self.rate_limiter.is_rate_limited(request_context):
-                return self._create_rate_limit_response(
-                    authentication, request_context, start_time
-                )
-
-            # Optional preprocessing
-            pre_response = await self._request_processor(request)
-            if pre_response is not None:
-                return self._build_final_response(
-                    authentication, pre_response, request_context, start_time
-                )
+        # Extract authentication
+        authentication = extract_authentication(request=request)
+
+        started_at = datetime.now(tz=timezone.utc)
+
+        # Rate limiting check
+        if self.rate_limiter.is_rate_limited(request_context):
+            finished_at = datetime.now(tz=timezone.utc)
+            operation_summary = "Rate limit exceeded for the request"
+            # define operation timestamps
+            operation_timestamps = OperationTimestamps(
+                started_at=started_at,
+                finished_at=finished_at,
+                duration=(finished_at - started_at).total_seconds(),
+            )
+            operation_exception = OperationException(
+                type=BaseEnums.ExceptionType.RATE_LIMIT,
+                raw="Rate limit exceeded",
+                traceback=[],
+            )
+            content = BaseResponses.RateLimitExceeded().model_dump()  # type: ignore
+            operation_result = OperationResult.model_validate(content)
+            response = JSONResponse(
+                content=content,
+                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+            )
+            return self._build_final_response(
+                operation_id=operation_id,
+                operation_summary=operation_summary,
+                request_context=request_context,
+                authentication=authentication,
+                operation_timestamps=operation_timestamps,
+                operation_exception=operation_exception,
+                operation_result=operation_result,
+                response=response,
+                log_level=BaseEnums.LogLevel.ERROR,
+            )
 
+        try:
             # Main request processing
             response = await call_next(request)
+            finished_at = datetime.now(tz=timezone.utc)
+            operation_summary = "Successfully processed the request"
+            # define operation timestamps
+            operation_timestamps = OperationTimestamps(
+                started_at=started_at,
+                finished_at=finished_at,
+                duration=(finished_at - started_at).total_seconds(),
+            )
             return self._build_final_response(
-                authentication, response, request_context, start_time
+                operation_id=operation_id,
+                operation_summary=operation_summary,
+                request_context=request_context,
+                authentication=authentication,
+                operation_timestamps=operation_timestamps,
+                operation_result=None,
+                operation_exception=None,
+                response=response,
             )
 
         except Exception as e:
-            return self._handle_exception(
-                authentication, e, request_context, start_time
+            finished_at = datetime.now(tz=timezone.utc)
+            operation_summary = "Unexpected error occured for the request"
+            # define operation timestamps
+            operation_timestamps = OperationTimestamps(
+                started_at=started_at,
+                finished_at=finished_at,
+                duration=(finished_at - started_at).total_seconds(),
+            )
+            operation_exception = OperationException(
+                type=BaseEnums.ExceptionType.INTERNAL,
+                raw=str(e),
+                traceback=traceback.format_exc().splitlines(),
+            )
+            content = (BaseResponses.ServerError(other=str(e)).model_dump(),)  # type: ignore
+            operation_result = OperationResult.model_validate(content)
+            response = JSONResponse(
+                content=content,
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+            return self._build_final_response(
+                operation_id=operation_id,
+                operation_summary=operation_summary,
+                request_context=request_context,
+                authentication=authentication,
+                operation_timestamps=operation_timestamps,
+                operation_exception=operation_exception,
+                operation_result=operation_result,
+                response=response,
+                log_level=BaseEnums.LogLevel.ERROR,
             )
-
-    async def _request_processor(self, request: Request) -> Optional[Response]:
-        """Override this method for custom request preprocessing."""
-        return None
-
-    def _create_rate_limit_response(
-        self,
-        authentication: Authentication,
-        request_context: RequestContext,
-        start_time: float,
-    ) -> Response:
-        """Create rate limit exceeded response."""
-        response = JSONResponse(
-            content=BaseResponses.RateLimitExceeded().model_dump(),  # type: ignore
-            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-        )
-
-        return self._build_final_response(
-            authentication, response, request_context, start_time, log_level="warning"
-        )
 
     def _build_final_response(
         self,
+        operation_id: UUID,
+        operation_summary: str,
+        request_context: RequestContext,
         authentication: Authentication,
+        operation_timestamps: OperationTimestamps,
+        operation_exception: Optional[OperationException],
+        operation_result: Optional[OperationResult],
         response: Response,
-        request_context: RequestContext,
-        start_time: float,
-        log_level: str = "info",
+        log_level: BaseEnums.LogLevel = BaseEnums.LogLevel.INFO,
     ) -> Response:
         """Build final response with headers and logging."""
+        # define operation metadata
+        operation_metadata = self._build_operation_metadata(
+            request_context=request_context
+        )
+
+        # define result
+        if operation_result is None:
+            if isinstance(response, JSONResponse):
+                try:
+                    data = json.loads(response.body.decode())  # type: ignore
+                    operation_result = OperationResult.model_validate(data)
+                except Exception:
+                    pass
+
+        # define response-related timestamps
         responded_at = datetime.now(tz=timezone.utc)
-        process_time = time.perf_counter() - start_time
+        process_time = (responded_at - request_context.requested_at).total_seconds()
 
         # Add headers
         response = self.response_builder.add_response_headers(
-            authentication, response, request_context, responded_at, process_time
+            operation_id,
+            request_context,
+            authentication,
+            response,
+            responded_at,
+            process_time,
         )
 
-        # Log request/response
-        self.request_logger.log_request_response(
-            authentication, response, request_context, log_level
+        # Define response context
+        response_context = ResponseContext(
+            responded_at=responded_at,
+            process_time=process_time,
+            headers=response.headers.items(),
         )
 
-        return response
-
-    def _handle_exception(
-        self,
-        authentication: Authentication,
-        error: Exception,
-        request_context: RequestContext,
-        start_time: float,
-    ) -> Response:
-        """Handle exceptions and create error response."""
-        responded_at = datetime.now(tz=timezone.utc)
-        process_time = time.perf_counter() - start_time
-
-        response = JSONResponse(
-            content=BaseResponses.ServerError().model_dump(),  # type: ignore
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        # Define operation
+        operation = Operation(
+            operation_id=operation_id,
+            summary=operation_summary,
+            request_context=request_context,
+            authentication=authentication,
+            authorization=None,
+            service=self.service_context,
+            timestamps=operation_timestamps,
+            context=self.operation_context,
+            metadata=operation_metadata,
+            exception=operation_exception,
+            arguments=None,
+            result=operation_result,
+            response_context=response_context,
         )
 
-        # Log exception
-        self.request_logger.log_exception(authentication, error, request_context)
+        self._log_operation(operation=operation, log_level=log_level)
 
-        # Add headers
-        return self.response_builder.add_response_headers(
-            authentication, response, request_context, responded_at, process_time
-        )
+        return response
 
 
 def add_base_middleware(
     app: FastAPI,
+    settings: Settings,
     keys: BaseGeneralSchemas.RSAKeys,
     logger: MiddlewareLogger,
     maleo_foundation: MaleoFoundationClientManager,
-    allow_origins: Sequence[str] = (),
-    allow_methods: Sequence[str] = ("GET",),
-    allow_headers: Sequence[str] = (),
-    allow_credentials: bool = False,
     limit: int = 10,
     window: int = 1,
     cleanup_interval: int = 60,
@@ -460,13 +578,10 @@ def add_base_middleware(
     """
     app.add_middleware(
         BaseMiddleware,
+        settings=settings,
         keys=keys,
         logger=logger,
         maleo_foundation=maleo_foundation,
-        allow_origins=allow_origins,
-        allow_methods=allow_methods,
-        allow_headers=allow_headers,
-        allow_credentials=allow_credentials,
         limit=limit,
         window=window,
         cleanup_interval=cleanup_interval,