miso-client 0.1.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

miso_client/__init__.py

@@ -7,36 +7,38 @@ for authentication, role-based access control, permission management, and loggin
 
 from typing import Any, Optional
 
+from .errors import (
+    AuthenticationError,
+    AuthorizationError,
+    ConfigurationError,
+    ConnectionError,
+    MisoClientError,
+)
 from .models.config import (
-    RedisConfig,
-    MisoClientConfig,
-    UserInfo,
     AuthResult,
-    LogEntry,
-    RoleResult,
-    PermissionResult,
+    ClientLoggingOptions,
     ClientTokenResponse,
+    LogEntry,
+    MisoClientConfig,
     PerformanceMetrics,
-    ClientLoggingOptions,
+    PermissionResult,
+    RedisConfig,
+    RoleResult,
+    UserInfo,
 )
+from .models.error_response import ErrorResponse
 from .services.auth import AuthService
-from .services.role import RoleService
+from .services.cache import CacheService
+from .services.encryption import EncryptionService
+from .services.logger import LoggerChain, LoggerService
 from .services.permission import PermissionService
-from .services.logger import LoggerService, LoggerChain
 from .services.redis import RedisService
-from .services.encryption import EncryptionService
-from .services.cache import CacheService
-from .utils.http_client import HttpClient
+from .services.role import RoleService
 from .utils.config_loader import load_config
-from .errors import (
-    MisoClientError,
-    AuthenticationError,
-    AuthorizationError,
-    ConnectionError,
-    ConfigurationError,
-)
+from .utils.http_client import HttpClient
+from .utils.internal_http_client import InternalHttpClient
 
-__version__ = "0.1.0"
+__version__ = "0.4.0"
 __author__ = "AI Fabrix Team"
 __license__ = "MIT"
 
@@ -44,30 +46,45 @@ __license__ = "MIT"
 class MisoClient:
     """
     Main MisoClient SDK class for authentication, authorization, and logging.
-    
+
     This client provides a unified interface for:
     - Token validation and user management
     - Role-based access control
     - Permission management
     - Application logging with Redis caching
     """
-    
+
     def __init__(self, config: MisoClientConfig):
         """
         Initialize MisoClient with configuration.
-        
+
         Args:
             config: MisoClient configuration including controller URL, client credentials, etc.
         """
         self.config = config
-        self.http_client = HttpClient(config)
+
+        # Create InternalHttpClient first (pure HTTP functionality, no logging)
+        self._internal_http_client = InternalHttpClient(config)
+
+        # Create Redis service
         self.redis = RedisService(config.redis)
+
+        # Create LoggerService with InternalHttpClient (to avoid circular dependency)
+        # LoggerService uses InternalHttpClient for sending logs to prevent audit loops
+        self.logger = LoggerService(self._internal_http_client, self.redis)
+
+        # Create public HttpClient wrapping InternalHttpClient with logger
+        # This HttpClient adds automatic ISO 27001 compliant audit and debug logging
+        self.http_client = HttpClient(config, self.logger)
+
         # Cache service (uses Redis if available, falls back to in-memory)
         self.cache = CacheService(self.redis)
+
+        # Services use public HttpClient (with audit logging)
         self.auth = AuthService(self.http_client, self.redis)
         self.roles = RoleService(self.http_client, self.cache)
         self.permissions = PermissionService(self.http_client, self.cache)
-        self.logger = LoggerService(self.http_client, self.redis)
+
         # Encryption service (reads ENCRYPTION_KEY from environment by default)
         self.encryption = EncryptionService()
         self.initialized = False
@@ -75,7 +92,7 @@ class MisoClient:
     async def initialize(self) -> None:
         """
         Initialize the client (connect to Redis if configured).
-        
+
         This method should be called before using the client. It will attempt
         to connect to Redis if configured, but will gracefully fall back to
         controller-only mode if Redis is unavailable.
@@ -105,16 +122,18 @@ class MisoClient:
     def get_token(self, req: dict) -> str | None:
         """
         Extract Bearer token from request headers.
-        
+
         Supports common request object patterns (dict with headers).
-        
+
         Args:
             req: Request object with headers dict containing 'authorization' key
-            
+
         Returns:
             Bearer token string or None if not found
         """
-        headers_obj = req.get("headers", {}) if isinstance(req, dict) else getattr(req, "headers", {})
+        headers_obj = (
+            req.get("headers", {}) if isinstance(req, dict) else getattr(req, "headers", {})
+        )
         headers: dict[str, Any] = headers_obj if isinstance(headers_obj, dict) else {}
         auth_value = headers.get("authorization") or headers.get("Authorization")
         if not isinstance(auth_value, str):
@@ -123,16 +142,16 @@ class MisoClient:
         # Support "Bearer <token>" format
         if auth_value.startswith("Bearer "):
             return auth_value[7:]
-        
+
         # If no Bearer prefix, assume the whole header is the token
         return auth_value
 
     async def get_environment_token(self) -> str:
         """
         Get environment token using client credentials.
-        
+
         This is called automatically by HttpClient but can be called manually.
-        
+
         Returns:
             Client token string
         """
@@ -141,12 +160,12 @@ class MisoClient:
     def login(self, redirect_uri: str) -> str:
         """
         Initiate login flow by redirecting to controller.
-        
+
         Returns the login URL for browser redirect or manual navigation.
-        
+
         Args:
             redirect_uri: URI to redirect to after successful login
-            
+
         Returns:
             Login URL string
         """
@@ -155,10 +174,10 @@ class MisoClient:
     async def validate_token(self, token: str) -> bool:
         """
         Validate token with controller.
-        
+
         Args:
             token: JWT token to validate
-            
+
         Returns:
             True if token is valid, False otherwise
         """
@@ -167,10 +186,10 @@ class MisoClient:
     async def get_user(self, token: str) -> UserInfo | None:
         """
         Get user information from token.
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             UserInfo if token is valid, None otherwise
         """
@@ -179,10 +198,10 @@ class MisoClient:
     async def get_user_info(self, token: str) -> UserInfo | None:
         """
         Get user information from GET /api/auth/user endpoint.
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             UserInfo if token is valid, None otherwise
         """
@@ -191,10 +210,10 @@ class MisoClient:
     async def is_authenticated(self, token: str) -> bool:
         """
         Check if user is authenticated.
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             True if user is authenticated, False otherwise
         """
@@ -209,10 +228,10 @@ class MisoClient:
     async def get_roles(self, token: str) -> list[str]:
         """
         Get user roles (cached in Redis if available).
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             List of user roles
         """
@@ -221,11 +240,11 @@ class MisoClient:
     async def has_role(self, token: str, role: str) -> bool:
         """
         Check if user has specific role.
-        
+
         Args:
             token: JWT token
             role: Role to check
-            
+
         Returns:
             True if user has the role, False otherwise
         """
@@ -234,11 +253,11 @@ class MisoClient:
     async def has_any_role(self, token: str, roles: list[str]) -> bool:
         """
         Check if user has any of the specified roles.
-        
+
         Args:
             token: JWT token
             roles: List of roles to check
-            
+
         Returns:
             True if user has any of the roles, False otherwise
         """
@@ -247,11 +266,11 @@ class MisoClient:
     async def has_all_roles(self, token: str, roles: list[str]) -> bool:
         """
         Check if user has all of the specified roles.
-        
+
         Args:
             token: JWT token
             roles: List of roles to check
-            
+
         Returns:
             True if user has all roles, False otherwise
         """
@@ -260,10 +279,10 @@ class MisoClient:
     async def refresh_roles(self, token: str) -> list[str]:
         """
         Force refresh roles from controller (bypass cache).
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             Fresh list of user roles
         """
@@ -272,10 +291,10 @@ class MisoClient:
     async def get_permissions(self, token: str) -> list[str]:
         """
         Get user permissions (cached in Redis if available).
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             List of user permissions
         """
@@ -284,11 +303,11 @@ class MisoClient:
     async def has_permission(self, token: str, permission: str) -> bool:
         """
         Check if user has specific permission.
-        
+
         Args:
             token: JWT token
             permission: Permission to check
-            
+
         Returns:
             True if user has the permission, False otherwise
         """
@@ -297,11 +316,11 @@ class MisoClient:
     async def has_any_permission(self, token: str, permissions: list[str]) -> bool:
         """
         Check if user has any of the specified permissions.
-        
+
         Args:
             token: JWT token
             permissions: List of permissions to check
-            
+
         Returns:
             True if user has any of the permissions, False otherwise
         """
@@ -310,11 +329,11 @@ class MisoClient:
     async def has_all_permissions(self, token: str, permissions: list[str]) -> bool:
         """
         Check if user has all of the specified permissions.
-        
+
         Args:
             token: JWT token
             permissions: List of permissions to check
-            
+
         Returns:
             True if user has all permissions, False otherwise
         """
@@ -323,10 +342,10 @@ class MisoClient:
     async def refresh_permissions(self, token: str) -> list[str]:
         """
         Force refresh permissions from controller (bypass cache).
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             Fresh list of user permissions
         """
@@ -335,7 +354,7 @@ class MisoClient:
     async def clear_permissions_cache(self, token: str) -> None:
         """
         Clear cached permissions for a user.
-        
+
         Args:
             token: JWT token
         """
@@ -347,7 +366,7 @@ class MisoClient:
     def log(self) -> LoggerService:
         """
         Get logger service for application logging.
-        
+
         Returns:
             LoggerService instance
         """
@@ -358,12 +377,12 @@ class MisoClient:
     def encrypt(self, plaintext: str) -> str:
         """
         Encrypt sensitive data.
-        
+
         Convenience method that delegates to encryption service.
-        
+
         Args:
             plaintext: Plain text string to encrypt
-            
+
         Returns:
             Base64-encoded encrypted string
         """
@@ -372,12 +391,12 @@ class MisoClient:
     def decrypt(self, encrypted_text: str) -> str:
         """
         Decrypt sensitive data.
-        
+
         Convenience method that delegates to encryption service.
-        
+
         Args:
             encrypted_text: Base64-encoded encrypted string
-            
+
         Returns:
             Decrypted plain text string
         """
@@ -388,12 +407,12 @@ class MisoClient:
     async def cache_get(self, key: str) -> Optional[Any]:
         """
         Get cached value.
-        
+
         Convenience method that delegates to cache service.
-        
+
         Args:
             key: Cache key
-            
+
         Returns:
             Cached value if found, None otherwise
         """
@@ -402,14 +421,14 @@ class MisoClient:
     async def cache_set(self, key: str, value: Any, ttl: int) -> bool:
         """
         Set cached value with TTL.
-        
+
         Convenience method that delegates to cache service.
-        
+
         Args:
             key: Cache key
             value: Value to cache
             ttl: Time to live in seconds
-            
+
         Returns:
             True if successful, False otherwise
         """
@@ -418,12 +437,12 @@ class MisoClient:
     async def cache_delete(self, key: str) -> bool:
         """
         Delete cached value.
-        
+
         Convenience method that delegates to cache service.
-        
+
         Args:
             key: Cache key
-            
+
         Returns:
             True if deleted, False otherwise
         """
@@ -432,7 +451,7 @@ class MisoClient:
     async def cache_clear(self) -> None:
         """
         Clear all cached values.
-        
+
         Convenience method that delegates to cache service.
         """
         await self.cache.clear()
@@ -442,7 +461,7 @@ class MisoClient:
     def get_config(self) -> MisoClientConfig:
         """
         Get current configuration.
-        
+
         Returns:
             Copy of current configuration
         """
@@ -451,7 +470,7 @@ class MisoClient:
     def is_redis_connected(self) -> bool:
         """
         Check if Redis is connected.
-        
+
         Returns:
             True if Redis is connected, False otherwise
         """
@@ -471,6 +490,7 @@ __all__ = [
     "ClientTokenResponse",
     "PerformanceMetrics",
     "ClientLoggingOptions",
+    "ErrorResponse",
     "AuthService",
     "RoleService",
     "PermissionService",

miso_client/errors.py

@@ -4,41 +4,67 @@ SDK exceptions and error handling.
 This module defines custom exceptions for the MisoClient SDK.
 """
 
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..models.error_response import ErrorResponse
+
 
 class MisoClientError(Exception):
     """Base exception for MisoClient SDK errors."""
-    
-    def __init__(self, message: str, status_code: int | None = None, error_body: dict | None = None):
+
+    def __init__(
+        self,
+        message: str,
+        status_code: int | None = None,
+        error_body: dict | None = None,
+        error_response: "ErrorResponse | None" = None,
+    ):
         """
         Initialize MisoClient error.
-        
+
         Args:
             message: Error message
             status_code: HTTP status code if applicable
             error_body: Sanitized error response body (secrets masked)
+            error_response: Structured error response object (RFC 7807-style)
         """
         super().__init__(message)
         self.message = message
         self.status_code = status_code
         self.error_body = error_body if error_body is not None else None
+        self.error_response = error_response
+
+        # Enhance message with structured error information if available
+        if error_response and error_response.errors:
+            if len(error_response.errors) == 1:
+                self.message = error_response.errors[0]
+            else:
+                self.message = f"{error_response.title}: {'; '.join(error_response.errors)}"
+            # Override status_code from structured response if available
+            if error_response.statusCode:
+                self.status_code = error_response.statusCode
 
 
 class AuthenticationError(MisoClientError):
     """Raised when authentication fails."""
+
     pass
 
 
 class AuthorizationError(MisoClientError):
     """Raised when authorization check fails."""
+
     pass
 
 
 class ConnectionError(MisoClientError):
     """Raised when connection to controller or Redis fails."""
+
     pass
 
 
 class ConfigurationError(MisoClientError):
     """Raised when configuration is invalid."""
-    pass
 
+    pass

miso_client/models/__init__.py

@@ -1 +1,5 @@
 """Pydantic models for MisoClient configuration and data types."""
+
+from .error_response import ErrorResponse
+
+__all__ = ["ErrorResponse"]