miso-client 0.1.0__py3-none-any.whl → 0.2.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/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
         """

miso_client/services/cache.py

@@ -8,17 +8,18 @@ in-memory TTL-based caching when Redis is unavailable.
 
 import json
 import time
-from typing import Any, Optional, Dict, Tuple
+from typing import Any, Dict, Optional, Tuple
+
 from ..services.redis import RedisService
 
 
 class CacheService:
     """Cache service with Redis and in-memory TTL fallback."""
-    
+
     def __init__(self, redis: Optional[RedisService] = None):
         """
         Initialize cache service.
-        
+
         Args:
             redis: Optional RedisService instance. If provided, Redis will be used
                   as primary cache with in-memory as fallback. If None, only
@@ -29,31 +30,32 @@ class CacheService:
         self._memory_cache: Dict[str, Tuple[Any, float]] = {}
         # Cleanup threshold: clean expired entries if cache exceeds this size
         self._cleanup_threshold = 1000
-    
+
     def _is_expired(self, expiration: float) -> bool:
         """Check if entry has expired."""
         return time.time() > expiration
-    
+
     def _cleanup_expired(self) -> None:
         """Remove expired entries from memory cache."""
         if len(self._memory_cache) <= self._cleanup_threshold:
             return
-        
+
         expired_keys = [
-            key for key, (_, expiration) in self._memory_cache.items()
+            key
+            for key, (_, expiration) in self._memory_cache.items()
             if self._is_expired(expiration)
         ]
-        
+
         for key in expired_keys:
             del self._memory_cache[key]
-    
+
     def _serialize_value(self, value: Any) -> str:
         """
         Serialize value to JSON string.
-        
+
         Args:
             value: Value to serialize (can be any JSON-serializable type)
-            
+
         Returns:
             JSON string representation
         """
@@ -62,23 +64,23 @@ class CacheService:
             if isinstance(value, str):
                 return value
             return json.dumps(value)
-        
+
         # For complex types, use JSON serialization with a marker
         return json.dumps({"__cached_value__": value})
-    
+
     def _deserialize_value(self, value_str: str) -> Any:
         """
         Deserialize JSON string back to original value.
-        
+
         Args:
             value_str: JSON string to deserialize
-            
+
         Returns:
             Deserialized value
         """
         if not value_str:
             return None
-        
+
         try:
             # Try to parse as JSON
             parsed = json.loads(value_str)
@@ -90,16 +92,16 @@ class CacheService:
         except (json.JSONDecodeError, TypeError):
             # If JSON parsing fails, assume it's a plain string
             return value_str
-    
+
     async def get(self, key: str) -> Optional[Any]:
         """
         Get cached value.
-        
+
         Checks Redis first (if available), then falls back to in-memory cache.
-        
+
         Args:
             key: Cache key
-            
+
         Returns:
             Cached value if found, None otherwise
         """
@@ -112,7 +114,7 @@ class CacheService:
             except Exception:
                 # Redis operation failed, fall through to memory cache
                 pass
-        
+
         # Fallback to in-memory cache
         if key in self._memory_cache:
             value, expiration = self._memory_cache[key]
@@ -121,26 +123,26 @@ class CacheService:
             else:
                 # Entry expired, remove it
                 del self._memory_cache[key]
-        
+
         return None
-    
+
     async def set(self, key: str, value: Any, ttl: int) -> bool:
         """
         Set cached value with TTL.
-        
+
         Stores in both Redis (if available) and in-memory cache.
-        
+
         Args:
             key: Cache key
             value: Value to cache (any JSON-serializable type)
             ttl: Time to live in seconds
-            
+
         Returns:
             True if successful, False otherwise
         """
         serialized_value = self._serialize_value(value)
         success = False
-        
+
         # Store in Redis if available
         if self.redis and self.redis.is_connected():
             try:
@@ -148,57 +150,56 @@ class CacheService:
             except Exception:
                 # Redis operation failed, continue to memory cache
                 pass
-        
+
         # Also store in memory cache
         expiration = time.time() + ttl
         self._memory_cache[key] = (value, expiration)
-        
+
         # Cleanup expired entries periodically
         self._cleanup_expired()
-        
+
         return success or True  # Return True if at least memory cache succeeded
-    
+
     async def delete(self, key: str) -> bool:
         """
         Delete cached value.
-        
+
         Deletes from both Redis (if available) and in-memory cache.
-        
+
         Args:
             key: Cache key
-            
+
         Returns:
             True if deleted from at least one cache, False otherwise
         """
         deleted = False
-        
+
         # Delete from Redis if available
         if self.redis and self.redis.is_connected():
             try:
                 deleted = await self.redis.delete(key)
             except Exception:
                 pass
-        
+
         # Delete from memory cache
         if key in self._memory_cache:
             del self._memory_cache[key]
             deleted = True
-        
+
         return deleted
-    
+
     async def clear(self) -> None:
         """
         Clear all cached values.
-        
+
         Clears both Redis (if available) and in-memory cache.
         Note: Redis clear operation only clears keys with the configured prefix,
         not the entire Redis database.
         """
         # Clear memory cache
         self._memory_cache.clear()
-        
+
         # For Redis, we would need to delete all keys with the prefix
         # This is more complex and potentially dangerous, so we'll skip it
         # Users should use delete() for specific keys or clear Redis manually
         # if needed
-