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

miso_client/models/config.py

@@ -5,13 +5,14 @@ This module contains Pydantic models that define the configuration structure
 and data types used throughout the MisoClient SDK.
 """
 
-from typing import Optional, Dict, Any, List, Literal
+from typing import Any, Dict, List, Literal, Optional
+
 from pydantic import BaseModel, Field
 
 
 class RedisConfig(BaseModel):
     """Redis connection configuration."""
-    
+
     host: str = Field(..., description="Redis host")
     port: int = Field(default=6379, description="Redis port")
     password: Optional[str] = Field(default=None, description="Redis password")
@@ -21,38 +22,42 @@ class RedisConfig(BaseModel):
 
 class MisoClientConfig(BaseModel):
     """Main MisoClient configuration.
-    
+
     Required fields:
     - controller_url: Miso Controller base URL
     - client_id: Client identifier for authentication
     - client_secret: Client secret for authentication
-    
+
     Optional fields:
     - redis: Redis configuration for caching
     - log_level: Logging level (debug, info, warn, error)
     - cache: Cache TTL settings for roles and permissions
+    - api_key: API key for testing (bypasses OAuth2 authentication)
     """
-    
+
     controller_url: str = Field(..., description="Miso Controller base URL")
     client_id: str = Field(..., description="Client identifier for authentication")
     client_secret: str = Field(..., description="Client secret for authentication")
     redis: Optional[RedisConfig] = Field(default=None, description="Optional Redis configuration")
     log_level: Literal["debug", "info", "warn", "error"] = Field(
-        default="info", 
-        description="Log level"
+        default="info", description="Log level"
     )
     cache: Optional[Dict[str, int]] = Field(
         default=None,
-        description="Cache TTL settings: permission_ttl, role_ttl (default: 900 seconds)"
+        description="Cache TTL settings: permission_ttl, role_ttl (default: 900 seconds)",
     )
-    
+    api_key: Optional[str] = Field(
+        default=None,
+        description="API key for testing - when set, bearer tokens matching this key bypass OAuth2 validation",
+    )
+
     @property
     def role_ttl(self) -> int:
         """Get role cache TTL in seconds."""
         if self.cache and "role_ttl" in self.cache:
             return self.cache["role_ttl"]
         return self.cache.get("roleTTL", 900) if self.cache else 900  # 15 minutes default
-    
+
     @property
     def permission_ttl(self) -> int:
         """Get permission cache TTL in seconds."""
@@ -63,21 +68,21 @@ class MisoClientConfig(BaseModel):
 
 class UserInfo(BaseModel):
     """User information from token validation."""
-    
+
     id: str = Field(..., description="User ID")
     username: str = Field(..., description="Username")
     email: Optional[str] = Field(default=None, description="User email")
     firstName: Optional[str] = Field(default=None, alias="first_name", description="First name")
     lastName: Optional[str] = Field(default=None, alias="last_name", description="Last name")
     roles: Optional[List[str]] = Field(default=None, description="User roles")
-    
+
     class Config:
         populate_by_name = True  # Allow both snake_case and camelCase
 
 
 class AuthResult(BaseModel):
     """Authentication result."""
-    
+
     authenticated: bool = Field(..., description="Whether authentication was successful")
     user: Optional[UserInfo] = Field(default=None, description="User information if authenticated")
     error: Optional[str] = Field(default=None, description="Error message if authentication failed")
@@ -85,90 +90,106 @@ class AuthResult(BaseModel):
 
 class LogEntry(BaseModel):
     """Log entry structure."""
-    
+
     timestamp: str = Field(..., description="ISO timestamp")
     level: Literal["error", "audit", "info", "debug"] = Field(..., description="Log level")
     environment: str = Field(..., description="Environment name (extracted by backend)")
     application: str = Field(..., description="Application identifier (clientId)")
-    applicationId: Optional[str] = Field(default=None, alias="application_id", description="Application ID")
+    applicationId: Optional[str] = Field(
+        default=None, alias="application_id", description="Application ID"
+    )
     userId: Optional[str] = Field(default=None, alias="user_id", description="User ID if available")
     message: str = Field(..., description="Log message")
     context: Optional[Dict[str, Any]] = Field(default=None, description="Additional context")
-    correlationId: Optional[str] = Field(default=None, alias="correlation_id", description="Correlation ID for tracing")
+    correlationId: Optional[str] = Field(
+        default=None, alias="correlation_id", description="Correlation ID for tracing"
+    )
     requestId: Optional[str] = Field(default=None, alias="request_id", description="Request ID")
     sessionId: Optional[str] = Field(default=None, alias="session_id", description="Session ID")
-    stackTrace: Optional[str] = Field(default=None, alias="stack_trace", description="Stack trace for errors")
+    stackTrace: Optional[str] = Field(
+        default=None, alias="stack_trace", description="Stack trace for errors"
+    )
     ipAddress: Optional[str] = Field(default=None, alias="ip_address", description="IP address")
     userAgent: Optional[str] = Field(default=None, alias="user_agent", description="User agent")
     hostname: Optional[str] = Field(default=None, description="Hostname")
-    
+
     class Config:
         populate_by_name = True
 
 
 class RoleResult(BaseModel):
     """Role query result."""
-    
+
     userId: str = Field(..., alias="user_id", description="User ID")
     roles: List[str] = Field(..., description="List of user roles")
     environment: str = Field(..., description="Environment name")
     application: str = Field(..., description="Application name")
-    
+
     class Config:
         populate_by_name = True
 
 
 class PermissionResult(BaseModel):
     """Permission query result."""
-    
+
     userId: str = Field(..., alias="user_id", description="User ID")
     permissions: List[str] = Field(..., description="List of user permissions")
     environment: str = Field(..., description="Environment name")
     application: str = Field(..., description="Application name")
-    
+
     class Config:
         populate_by_name = True
 
 
 class ClientTokenResponse(BaseModel):
     """Client token response."""
-    
+
     success: bool = Field(..., description="Whether token request was successful")
     token: str = Field(..., description="Client token")
     expiresIn: int = Field(..., alias="expires_in", description="Token expiration in seconds")
     expiresAt: str = Field(..., alias="expires_at", description="Token expiration ISO timestamp")
-    
+
     class Config:
         populate_by_name = True
 
 
 class PerformanceMetrics(BaseModel):
     """Performance metrics for logging."""
-    
+
     startTime: int = Field(..., alias="start_time", description="Start time in milliseconds")
-    endTime: Optional[int] = Field(default=None, alias="end_time", description="End time in milliseconds")
+    endTime: Optional[int] = Field(
+        default=None, alias="end_time", description="End time in milliseconds"
+    )
     duration: Optional[int] = Field(default=None, description="Duration in milliseconds")
     memoryUsage: Optional[Dict[str, int]] = Field(
-        default=None, 
+        default=None,
         alias="memory_usage",
-        description="Memory usage metrics (rss, heapTotal, heapUsed, external, arrayBuffers)"
+        description="Memory usage metrics (rss, heapTotal, heapUsed, external, arrayBuffers)",
     )
-    
+
     class Config:
         populate_by_name = True
 
 
 class ClientLoggingOptions(BaseModel):
     """Options for client logging."""
-    
-    applicationId: Optional[str] = Field(default=None, alias="application_id", description="Application ID")
+
+    applicationId: Optional[str] = Field(
+        default=None, alias="application_id", description="Application ID"
+    )
     userId: Optional[str] = Field(default=None, alias="user_id", description="User ID")
-    correlationId: Optional[str] = Field(default=None, alias="correlation_id", description="Correlation ID")
+    correlationId: Optional[str] = Field(
+        default=None, alias="correlation_id", description="Correlation ID"
+    )
     requestId: Optional[str] = Field(default=None, alias="request_id", description="Request ID")
     sessionId: Optional[str] = Field(default=None, alias="session_id", description="Session ID")
     token: Optional[str] = Field(default=None, description="JWT token for context extraction")
-    maskSensitiveData: Optional[bool] = Field(default=None, alias="mask_sensitive_data", description="Enable data masking")
-    performanceMetrics: Optional[bool] = Field(default=None, alias="performance_metrics", description="Include performance metrics")
-    
+    maskSensitiveData: Optional[bool] = Field(
+        default=None, alias="mask_sensitive_data", description="Enable data masking"
+    )
+    performanceMetrics: Optional[bool] = Field(
+        default=None, alias="performance_metrics", description="Include performance metrics"
+    )
+
     class Config:
         populate_by_name = True

miso_client/models/error_response.py

@@ -0,0 +1,41 @@
+"""
+Structured error response model following RFC 7807-style format.
+
+This module provides a generic error response interface that can be used
+across different applications for consistent error handling.
+"""
+
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class ErrorResponse(BaseModel):
+    """
+    Structured error response following RFC 7807-style format.
+
+    This model represents a standardized error response structure that includes:
+    - Multiple error messages
+    - Error type identifier
+    - Human-readable title
+    - HTTP status code
+    - Request instance URI (optional)
+
+    Example:
+        {
+            "errors": ["Error message 1", "Error message 2"],
+            "type": "/Errors/Bad Input",
+            "title": "Bad Request",
+            "statusCode": 400,
+            "instance": "/OpenApi/rest/Xzy"
+        }
+    """
+
+    errors: List[str] = Field(..., description="List of error messages")
+    type: str = Field(..., description="Error type URI (e.g., '/Errors/Bad Input')")
+    title: str = Field(..., description="Human-readable error title")
+    statusCode: int = Field(..., alias="status_code", description="HTTP status code")
+    instance: Optional[str] = Field(default=None, description="Request instance URI")
+
+    class Config:
+        populate_by_name = True  # Allow both camelCase and snake_case

miso_client/services/__init__.py

@@ -1,12 +1,12 @@
 """Service implementations for MisoClient SDK."""
 
 from .auth import AuthService
-from .role import RoleService
+from .cache import CacheService
+from .encryption import EncryptionService
+from .logger import LoggerChain, LoggerService
 from .permission import PermissionService
-from .logger import LoggerService, LoggerChain
 from .redis import RedisService
-from .encryption import EncryptionService
-from .cache import CacheService
+from .role import RoleService
 
 __all__ = [
     "AuthService",
@@ -17,4 +17,4 @@ __all__ = [
     "RedisService",
     "EncryptionService",
     "CacheService",
-]
+]

miso_client/services/auth.py

@@ -6,18 +6,19 @@ token validation, user information retrieval, and logout functionality.
 """
 
 from typing import Optional
-from ..models.config import UserInfo, AuthResult
+
+from ..models.config import AuthResult, UserInfo
 from ..services.redis import RedisService
 from ..utils.http_client import HttpClient
 
 
 class AuthService:
     """Authentication service for token validation and user management."""
-    
+
     def __init__(self, http_client: HttpClient, redis: RedisService):
         """
         Initialize authentication service.
-        
+
         Args:
             http_client: HTTP client instance
             redis: Redis service instance
@@ -25,117 +26,132 @@ class AuthService:
         self.config = http_client.config
         self.http_client = http_client
         self.redis = redis
-    
+
     async def get_environment_token(self) -> str:
         """
         Get environment token using client credentials.
-        
+
         This is called automatically by HttpClient, but can be called manually if needed.
-        
+
         Returns:
             Client token string
-            
+
         Raises:
             AuthenticationError: If token fetch fails
         """
         return await self.http_client.get_environment_token()
-    
+
     def login(self, redirect_uri: str) -> str:
         """
         Initiate login flow by redirecting to controller.
-        
+
         Returns the login URL for browser redirect or manual navigation.
         Backend will extract environment and application from client token.
-        
+
         Args:
             redirect_uri: URI to redirect to after successful login
-            
+
         Returns:
             Login URL string
         """
         return f"{self.config.controller_url}/api/auth/login?redirect={redirect_uri}"
-    
+
     async def validate_token(self, token: str) -> bool:
         """
         Validate token with controller.
-        
+
+        If API_KEY is configured and token matches it, bypasses OAuth2 validation.
+
         Args:
-            token: JWT token to validate
-            
+            token: JWT token to validate (or API_KEY for testing)
+
         Returns:
             True if token is valid, False otherwise
         """
+        # Check API_KEY first (for testing)
+        if self.config.api_key and token == self.config.api_key:
+            return True
+
+        # Fall back to OAuth2 validation
         try:
             result = await self.http_client.authenticated_request(
-                "POST",
-                "/api/auth/validate",  # Backend knows app/env from client token
-                token
+                "POST", "/api/auth/validate", token  # Backend knows app/env from client token
             )
-            
+
             auth_result = AuthResult(**result)
             return auth_result.authenticated
-            
+
         except Exception:
             # Token validation failed, return false
             return False
-    
+
     async def get_user(self, token: str) -> Optional[UserInfo]:
         """
         Get user information from token.
-        
+
+        If API_KEY is configured and token matches it, returns None (no user info for API key auth).
+
         Args:
-            token: JWT token
-            
+            token: JWT token (or API_KEY for testing)
+
         Returns:
             UserInfo if token is valid, None otherwise
         """
+        # Check API_KEY first (for testing)
+        if self.config.api_key and token == self.config.api_key:
+            # API key authentication doesn't provide user info
+            return None
+
+        # Fall back to OAuth2 validation
         try:
             result = await self.http_client.authenticated_request(
-                "POST",
-                "/api/auth/validate",
-                token
+                "POST", "/api/auth/validate", token
             )
-            
+
             auth_result = AuthResult(**result)
-            
+
             if auth_result.authenticated and auth_result.user:
                 return auth_result.user
-            
+
             return None
-            
+
         except Exception:
             # Failed to get user info, return null
             return None
-    
+
     async def get_user_info(self, token: str) -> Optional[UserInfo]:
         """
         Get user information from GET /api/auth/user endpoint.
-        
+
+        If API_KEY is configured and token matches it, returns None (no user info for API key auth).
+
         Args:
-            token: JWT token
-            
+            token: JWT token (or API_KEY for testing)
+
         Returns:
             UserInfo if token is valid, None otherwise
         """
+        # Check API_KEY first (for testing)
+        if self.config.api_key and token == self.config.api_key:
+            # API key authentication doesn't provide user info
+            return None
+
+        # Fall back to OAuth2 validation
         try:
-            user_data = await self.http_client.authenticated_request(
-                "GET",
-                "/api/auth/user",
-                token
-            )
-            
+            user_data = await self.http_client.authenticated_request("GET", "/api/auth/user", token)
+
             return UserInfo(**user_data)
-            
+
         except Exception:
             # Failed to get user info, return None
             return None
-    
+
     async def logout(self) -> None:
         """
         Logout user.
-        
+
         Backend extracts app/env from client token (no body needed).
-        
+
         Raises:
             MisoClientError: If logout fails
         """
@@ -145,15 +161,16 @@ class AuthService:
         except Exception as e:
             # Logout failed, re-raise error for application to handle
             from ..errors import MisoClientError
+
             raise MisoClientError(f"Logout failed: {str(e)}")
-    
+
     async def is_authenticated(self, token: str) -> bool:
         """
         Check if user is authenticated (has valid token).
-        
+
         Args:
             token: JWT token
-            
+
         Returns:
             True if user is authenticated, False otherwise
         """