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

miso_client/utils/filter_parser.py

@@ -0,0 +1,110 @@
+"""
+Filter parsing utilities for MisoClient SDK.
+
+This module provides utilities for parsing filter parameters from query strings
+and converting them into FilterOption objects.
+"""
+
+from typing import Any, List, Optional, Union, cast
+from urllib.parse import unquote
+
+from ..models.filter import FilterOperator, FilterOption
+
+
+def parse_filter_params(params: dict) -> List[FilterOption]:
+    """
+    Parse filter query parameters into FilterOption list.
+
+    Parses `?filter=field:op:value` format into FilterOption objects.
+    Supports multiple filter parameters (array of filter strings).
+
+    Args:
+        params: Dictionary with query parameters (e.g., {'filter': ['status:eq:active', 'region:in:eu,us']})
+
+    Returns:
+        List of FilterOption objects
+
+    Examples:
+        >>> parse_filter_params({'filter': ['status:eq:active']})
+        [FilterOption(field='status', op='eq', value='active')]
+        >>> parse_filter_params({'filter': ['region:in:eu,us']})
+        [FilterOption(field='region', op='in', value=['eu', 'us'])]
+    """
+    filters: List[FilterOption] = []
+
+    # Get filter parameter (can be string or list)
+    filter_param = params.get("filter") or params.get("filters")
+    if not filter_param:
+        return filters
+
+    # Normalize to list
+    if isinstance(filter_param, str):
+        filter_strings = [filter_param]
+    elif isinstance(filter_param, list):
+        filter_strings = filter_param
+    else:
+        return filters
+
+    # Parse each filter string
+    for filter_str in filter_strings:
+        if not isinstance(filter_str, str):
+            continue
+
+        # Split by colon (field:op:value)
+        # For isNull/isNotNull, value part may be empty or missing
+        parts = filter_str.split(":", 2)
+        if len(parts) < 2:
+            continue  # Skip invalid filter format
+
+        field = unquote(parts[0].strip())
+        op = parts[1].strip()
+        value_str = unquote(parts[2].strip()) if len(parts) > 2 else ""
+
+        # Validate operator
+        valid_operators = [
+            "eq",
+            "neq",
+            "in",
+            "nin",
+            "gt",
+            "lt",
+            "gte",
+            "lte",
+            "contains",
+            "like",
+            "isNull",
+            "isNotNull",
+        ]
+        if op not in valid_operators:
+            continue  # Skip invalid operator
+
+        # Parse value based on operator
+        parsed_value: Optional[Union[str, int, float, bool, List[Any]]] = None
+        if op in ("isNull", "isNotNull"):
+            # Null check operators don't need values
+            parsed_value = None
+        elif op in ("in", "nin"):
+            # Array values: comma-separated
+            parsed_value = [v.strip() for v in value_str.split(",") if v.strip()]
+        else:
+            # Single value: try to parse as number/boolean, fallback to string
+            single_value: Union[str, int, float, bool] = value_str
+            # Try to parse as integer
+            try:
+                if "." not in value_str:
+                    single_value = int(value_str)
+                else:
+                    single_value = float(value_str)
+            except (ValueError, TypeError):
+                # Try boolean
+                if value_str.lower() in ("true", "false"):
+                    single_value = value_str.lower() == "true"
+                else:
+                    single_value = value_str
+            parsed_value = single_value
+
+        value = parsed_value
+
+        filters.append(FilterOption(field=field, op=cast(FilterOperator, op), value=value))
+
+    return filters

miso_client/utils/flask_endpoints.py

@@ -0,0 +1,169 @@
+"""
+Flask endpoint utilities for client token endpoint.
+
+Provides server-side route handlers for creating client token endpoints
+that return client token + DataClient configuration to frontend clients.
+"""
+
+import asyncio
+from typing import Any, Callable, Optional
+
+from ..errors import AuthenticationError
+from ..models.config import (
+    ClientTokenEndpointOptions,
+    ClientTokenEndpointResponse,
+    DataClientConfigResponse,
+    MisoClientConfig,
+)
+from ..utils.environment_token import get_environment_token
+
+
+def create_flask_client_token_endpoint(
+    miso_client: Any, options: Optional[ClientTokenEndpointOptions] = None
+) -> Callable[[], Any]:
+    """
+    Create Flask route handler for client-token endpoint.
+
+    Automatically enriches response with DataClient configuration including
+    controllerPublicUrl for frontend client initialization.
+
+    Args:
+        miso_client: MisoClient instance (must be initialized)
+        options: Optional configuration for endpoint
+
+    Returns:
+        Flask route handler function
+
+    Example:
+        >>> from flask import Flask
+        >>> from miso_client import MisoClient, create_flask_client_token_endpoint, load_config
+        >>>
+        >>> app = Flask(__name__)
+        >>> client = MisoClient(load_config())
+        >>> await client.initialize()
+        >>>
+        >>> app.post('/api/v1/auth/client-token')(create_flask_client_token_endpoint(client))
+    """
+    opts = ClientTokenEndpointOptions(
+        clientTokenUri=options.clientTokenUri if options else "/api/v1/auth/client-token",
+        expiresIn=options.expiresIn if options else 1800,
+        includeConfig=options.includeConfig if options else True,
+    )
+
+    def handler() -> tuple[dict[str, Any], int]:
+        """
+        Flask route handler for client token endpoint.
+
+        Returns:
+            Tuple of (response_dict, status_code)
+        """
+        try:
+            # Check if misoClient is initialized
+            if not miso_client.is_initialized():
+                return (
+                    {
+                        "error": "Service Unavailable",
+                        "message": "MisoClient is not initialized",
+                    },
+                    503,
+                )
+
+            # Get Flask request object
+            try:
+                from flask import request
+            except ImportError:
+                return (
+                    {
+                        "error": "Internal Server Error",
+                        "message": "Flask is not installed",
+                    },
+                    500,
+                )
+
+            # Get token with origin validation (raises AuthenticationError if validation fails)
+            # Run async function in sync context
+            # Handle both sync and async Flask contexts
+            try:
+                # Try to get existing event loop
+                _ = asyncio.get_running_loop()
+                # If we get here, we're in an async context (Flask 2.0+ async handler)
+                # In this case, we need to await, but Flask async handlers handle this
+                # For now, create a new event loop in a thread
+                import concurrent.futures
+
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(
+                        asyncio.run, get_environment_token(miso_client, request.headers)
+                    )
+                    token = future.result()
+            except RuntimeError:
+                # No running loop, safe to use asyncio.run()
+                token = asyncio.run(get_environment_token(miso_client, request.headers))
+
+            # Build response
+            response: ClientTokenEndpointResponse = ClientTokenEndpointResponse(
+                token=token, expiresIn=opts.expiresIn or 1800
+            )
+
+            # Include config if requested
+            if opts.includeConfig:
+                config: MisoClientConfig = miso_client.config
+
+                # Derive baseUrl from request
+                base_url = f"{request.scheme}://{request.host or 'localhost'}"
+
+                # Get controller URL (prefer controllerPublicUrl for browser, fallback to controller_url)
+                controller_url = config.controllerPublicUrl or config.controller_url
+
+                if not controller_url:
+                    return (
+                        {
+                            "error": "Internal Server Error",
+                            "message": "Controller URL not configured",
+                        },
+                        500,
+                    )
+
+                response.config = DataClientConfigResponse(
+                    baseUrl=base_url,
+                    controllerUrl=controller_url,
+                    controllerPublicUrl=config.controllerPublicUrl,
+                    clientId=config.client_id,
+                    clientTokenUri=opts.clientTokenUri or "/api/v1/auth/client-token",
+                )
+
+            return response.model_dump(exclude_none=True), 200
+
+        except AuthenticationError as error:
+            # Origin validation failed (403)
+            error_message = str(error)
+            if "Origin validation failed" in error_message:
+                return (
+                    {
+                        "error": "Forbidden",
+                        "message": error_message,
+                    },
+                    403,
+                )
+
+            # Other authentication errors (500)
+            return (
+                {
+                    "error": "Internal Server Error",
+                    "message": error_message,
+                },
+                500,
+            )
+
+        except Exception as error:
+            # Other errors (500)
+            error_message = str(error) if error else "Unknown error"
+            return (
+                {
+                    "error": "Internal Server Error",
+                    "message": error_message,
+                },
+                500,
+            )
+
+    return handler