wappa 0.1.0__py3-none-any.whl

wappa/api/dependencies/whatsapp_dependencies.py

@@ -0,0 +1,220 @@
+"""
+WhatsApp messaging dependency injection.
+
+Provides dependency injection for WhatsApp messaging services including
+factory pattern, client management, and messenger implementations.
+"""
+
+from fastapi import Depends, Request
+
+# Note: Using context-based tenant access instead of request-based
+from wappa.core.logging.logger import get_logger
+from wappa.domain.builders.message_builder import MessageBuilder
+from wappa.domain.factories.message_factory import (
+    MessageFactory,
+    WhatsAppMessageFactory,
+)
+from wappa.domain.interfaces.messaging_interface import IMessenger
+from wappa.domain.services.tenant_credentials_service import TenantCredentialsService
+from wappa.messaging.whatsapp.client.whatsapp_client import WhatsAppClient
+from wappa.messaging.whatsapp.handlers.whatsapp_interactive_handler import (
+    WhatsAppInteractiveHandler,
+)
+from wappa.messaging.whatsapp.handlers.whatsapp_media_handler import (
+    WhatsAppMediaHandler,
+)
+from wappa.messaging.whatsapp.handlers.whatsapp_specialized_handler import (
+    WhatsAppSpecializedHandler,
+)
+from wappa.messaging.whatsapp.handlers.whatsapp_template_handler import (
+    WhatsAppTemplateHandler,
+)
+from wappa.messaging.whatsapp.messenger.whatsapp_messenger import WhatsAppMessenger
+
+
+async def get_whatsapp_message_factory() -> MessageFactory:
+    """Get WhatsApp message factory.
+
+    Returns:
+        MessageFactory implementation for WhatsApp platform
+    """
+    return WhatsAppMessageFactory()
+
+
+async def get_whatsapp_client(request: Request) -> WhatsAppClient:
+    """Get configured WhatsApp client with tenant-specific credentials.
+
+    Args:
+        request: FastAPI request object containing HTTP session
+
+    Returns:
+        Configured WhatsApp client with persistent session and tenant credentials
+
+    Raises:
+        ValueError: If tenant credentials are invalid
+    """
+    from wappa.core.logging.context import get_current_tenant_context
+
+    # Get persistent HTTP session from app state (created in main.py lifespan)
+    session = request.app.state.http_session
+
+    # Get tenant ID from context (set by webhook processing)
+    tenant_id = get_current_tenant_context()
+    if not tenant_id:
+        raise ValueError("No tenant context available - webhook processing required")
+
+    # Get tenant-specific access token (future: from database)
+    access_token = TenantCredentialsService.get_whatsapp_access_token(tenant_id)
+
+    # Validate tenant
+    if not TenantCredentialsService.validate_tenant(tenant_id):
+        raise ValueError(f"Invalid or inactive tenant: {tenant_id}")
+
+    # Create tenant-aware logger
+    logger = get_logger(__name__)
+
+    # Create WhatsApp client with dependency injection
+    client = WhatsAppClient(
+        session=session,
+        access_token=access_token,
+        phone_number_id=tenant_id,  # tenant_id IS the phone_number_id
+        logger=logger,
+    )
+
+    return client
+
+
+async def get_whatsapp_media_handler(
+    client: WhatsAppClient = Depends(get_whatsapp_client),
+) -> WhatsAppMediaHandler:
+    """Get configured WhatsApp media handler with tenant-specific context.
+
+    Args:
+        client: Configured WhatsApp client with persistent session
+
+    Returns:
+        Configured WhatsApp media handler for upload/download operations
+    """
+    from wappa.core.logging.context import get_current_tenant_context
+
+    tenant_id = get_current_tenant_context()
+    if not tenant_id:
+        raise ValueError("No tenant context available")
+    return WhatsAppMediaHandler(client=client, tenant_id=tenant_id)
+
+
+async def get_whatsapp_interactive_handler(
+    client: WhatsAppClient = Depends(get_whatsapp_client),
+) -> WhatsAppInteractiveHandler:
+    """Get configured WhatsApp interactive handler with tenant-specific context.
+
+    Args:
+        client: Configured WhatsApp client with persistent session
+
+    Returns:
+        Configured WhatsApp interactive handler for button/list/CTA operations
+    """
+    from wappa.core.logging.context import get_current_tenant_context
+
+    tenant_id = get_current_tenant_context()
+    if not tenant_id:
+        raise ValueError("No tenant context available")
+    return WhatsAppInteractiveHandler(client=client, tenant_id=tenant_id)
+
+
+async def get_whatsapp_template_handler(
+    client: WhatsAppClient = Depends(get_whatsapp_client),
+) -> WhatsAppTemplateHandler:
+    """Get configured WhatsApp template handler with tenant-specific context.
+
+    Args:
+        client: Configured WhatsApp client with persistent session
+
+    Returns:
+        Configured WhatsApp template handler for business template operations
+    """
+    from wappa.core.logging.context import get_current_tenant_context
+
+    tenant_id = get_current_tenant_context()
+    if not tenant_id:
+        raise ValueError("No tenant context available")
+    return WhatsAppTemplateHandler(client=client, tenant_id=tenant_id)
+
+
+async def get_whatsapp_specialized_handler(
+    client: WhatsAppClient = Depends(get_whatsapp_client),
+) -> WhatsAppSpecializedHandler:
+    """Get configured WhatsApp specialized handler with tenant-specific context.
+
+    Args:
+        client: Configured WhatsApp client with persistent session
+
+    Returns:
+        Configured WhatsApp specialized handler for contact and location operations
+    """
+    from wappa.core.logging.context import get_current_tenant_context
+
+    tenant_id = get_current_tenant_context()
+    if not tenant_id:
+        raise ValueError("No tenant context available")
+    return WhatsAppSpecializedHandler(client=client, tenant_id=tenant_id)
+
+
+async def get_whatsapp_messenger(
+    client: WhatsAppClient = Depends(get_whatsapp_client),
+    media_handler: WhatsAppMediaHandler = Depends(get_whatsapp_media_handler),
+    interactive_handler: WhatsAppInteractiveHandler = Depends(
+        get_whatsapp_interactive_handler
+    ),
+    template_handler: WhatsAppTemplateHandler = Depends(get_whatsapp_template_handler),
+    specialized_handler: WhatsAppSpecializedHandler = Depends(
+        get_whatsapp_specialized_handler
+    ),
+) -> IMessenger:
+    """Get unified WhatsApp messenger implementation with complete functionality.
+
+    Args:
+        client: Configured WhatsApp client
+        media_handler: Configured media handler for upload operations
+        interactive_handler: Configured interactive handler for button/list/CTA operations
+        template_handler: Configured template handler for business template operations
+        specialized_handler: Configured specialized handler for contact/location operations
+
+    Returns:
+        Complete IMessenger implementation for WhatsApp messaging (text + media + interactive + template + specialized)
+    """
+    from wappa.core.logging.context import get_current_tenant_context
+
+    tenant_id = get_current_tenant_context()
+    if not tenant_id:
+        raise ValueError("No tenant context available")
+
+    return WhatsAppMessenger(
+        client=client,
+        media_handler=media_handler,
+        interactive_handler=interactive_handler,
+        template_handler=template_handler,
+        specialized_handler=specialized_handler,
+        tenant_id=tenant_id,
+    )
+
+
+async def get_message_builder(
+    factory: MessageFactory = Depends(get_whatsapp_message_factory),
+) -> MessageBuilder:
+    """Get message builder for fluent message construction.
+
+    Args:
+        factory: Message factory for creating platform-specific payloads
+
+    Returns:
+        MessageBuilder instance for fluent message construction
+
+    Note: The recipient should be set when using the builder
+    """
+
+    # Return a builder factory function since recipient is set per message
+    def create_builder(recipient: str) -> MessageBuilder:
+        return MessageBuilder(factory, recipient)
+
+    return create_builder

wappa/api/dependencies/whatsapp_media_dependencies.py

@@ -0,0 +1,26 @@
+"""
+WhatsApp media messaging dependency injection.
+
+Provides dependency injection for WhatsApp media services including
+media handlers, media messengers, and media factories.
+"""
+
+from wappa.domain.factories.media_factory import MediaFactory, WhatsAppMediaFactory
+
+# WhatsAppMediaMessenger removed - using unified WhatsAppMessenger instead
+
+
+async def get_whatsapp_media_factory() -> MediaFactory:
+    """Get WhatsApp media factory.
+
+    Returns:
+        MediaFactory implementation for WhatsApp platform
+    """
+    return WhatsAppMediaFactory()
+
+
+# get_whatsapp_media_handler moved to whatsapp_dependencies.py to eliminate duplication
+
+
+# WhatsAppMediaMessenger dependency removed - using unified WhatsAppMessenger from whatsapp_dependencies.py instead
+# This eliminates DRY violation and architectural redundancy

wappa/api/middleware/__init__.py

@@ -0,0 +1,7 @@
+"""Middleware module for Wappa API."""
+
+from .error_handler import ErrorHandlerMiddleware
+from .owner import OwnerMiddleware
+from .request_logging import RequestLoggingMiddleware
+
+__all__ = ["ErrorHandlerMiddleware", "RequestLoggingMiddleware", "OwnerMiddleware"]

wappa/api/middleware/error_handler.py

@@ -0,0 +1,158 @@
+"""
+Global error handling middleware with tenant and context awareness.
+
+Provides structured error responses and comprehensive logging for Wappa framework.
+"""
+
+import traceback
+from typing import Any
+
+from fastapi import HTTPException, Request
+from fastapi.responses import JSONResponse
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import Response
+
+from wappa.core.logging.logger import get_logger
+
+
+class ErrorHandlerMiddleware(BaseHTTPMiddleware):
+    """
+    Global error handling middleware with tenant-aware logging.
+
+    Catches all unhandled exceptions and provides structured error responses
+    while maintaining security by not exposing internal details in production.
+    """
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        """Process request with comprehensive error handling."""
+        try:
+            response = await call_next(request)
+            return response
+
+        except HTTPException as http_exc:
+            # HTTP exceptions are handled by FastAPI, but we log them with context
+            await self._log_http_exception(request, http_exc)
+            raise  # Re-raise to let FastAPI handle the response
+
+        except Exception as exc:
+            # Handle unexpected exceptions
+            return await self._handle_unexpected_exception(request, exc)
+
+    async def _log_http_exception(self, request: Request, exc: HTTPException) -> None:
+        """Log HTTP exceptions with tenant context."""
+        tenant_id = getattr(request.state, "tenant_id", "unknown")
+        logger = get_logger(__name__)
+
+        # Extract user context from request if available
+        user_id = getattr(request.state, "user_id", "unknown")
+
+        logger.warning(
+            f"HTTP {exc.status_code} - {request.method} {request.url.path} - "
+            f"Detail: {exc.detail}"
+        )
+
+    async def _handle_unexpected_exception(
+        self, request: Request, exc: Exception
+    ) -> JSONResponse:
+        """Handle unexpected exceptions with proper logging and response."""
+        tenant_id = getattr(request.state, "tenant_id", "unknown")
+        user_id = getattr(request.state, "user_id", "unknown")
+
+        # Get context-aware logger
+        logger = get_logger(__name__)
+
+        # Log the full exception with context
+        logger.error(
+            f"Unhandled exception in {request.method} {request.url.path}: {exc}",
+            exc_info=True,
+        )
+
+        # Determine error response based on environment
+        if self._is_webhook_endpoint(request.url.path):
+            # Webhook endpoints need specific error handling
+            return await self._create_webhook_error_response(exc)
+        else:
+            # Regular API endpoints
+            return await self._create_api_error_response(exc)
+
+    def _is_webhook_endpoint(self, path: str) -> bool:
+        """Check if the request is to a webhook endpoint."""
+        return path.startswith("/webhook/")
+
+    async def _create_webhook_error_response(self, exc: Exception) -> JSONResponse:
+        """
+        Create error response for webhook endpoints.
+
+        Webhook providers expect specific response formats and status codes.
+        """
+        error_response = {
+            "status": "error",
+            "message": "Webhook processing failed",
+            "type": "webhook_error",
+        }
+
+        # In development, add more details
+        from wappa.core.config.settings import settings
+
+        if settings.is_development:
+            error_response["debug"] = {
+                "exception_type": type(exc).__name__,
+                "exception_message": str(exc),
+            }
+
+        return JSONResponse(status_code=500, content=error_response)
+
+    async def _create_api_error_response(self, exc: Exception) -> JSONResponse:
+        """Create error response for regular API endpoints."""
+        from wappa.core.config.settings import settings
+
+        # Base error response
+        error_response: dict[str, Any] = {
+            "detail": "Internal server error",
+            "type": "internal_error",
+            "timestamp": self._get_current_timestamp(),
+        }
+
+        # Add development-specific debugging information
+        if settings.is_development:
+            error_response["debug"] = {
+                "exception_type": type(exc).__name__,
+                "exception_message": str(exc),
+                "traceback": traceback.format_exc().split("\n"),
+            }
+
+        return JSONResponse(status_code=500, content=error_response)
+
+    def _get_current_timestamp(self) -> float:
+        """Get current timestamp for error responses."""
+        import time
+
+        return time.time()
+
+
+class ValidationErrorHandler:
+    """
+    Custom handler for Pydantic validation errors.
+
+    Provides more user-friendly validation error messages.
+    """
+
+    @staticmethod
+    def format_validation_error(exc: any) -> dict[str, Any]:
+        """Format Pydantic validation errors for API responses."""
+        errors = []
+
+        for error in exc.errors():
+            errors.append(
+                {
+                    "field": " -> ".join(str(loc) for loc in error["loc"]),
+                    "message": error["msg"],
+                    "type": error["type"],
+                }
+            )
+
+        return {
+            "detail": "Validation failed",
+            "type": "validation_error",
+            "errors": errors,
+        }

wappa/api/middleware/owner.py

@@ -0,0 +1,99 @@
+"""
+Owner middleware for extracting owner ID from webhook URLs.
+
+Simple middleware that extracts the owner_id from webhook URL paths and sets it in context.
+This replaces the over-complicated tenant middleware with a focused single-purpose solution.
+"""
+
+from fastapi import HTTPException, Request
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import Response
+
+from wappa.core.config.settings import settings
+from wappa.core.logging.context import set_request_context
+from wappa.core.logging.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class OwnerMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware to extract owner_id from webhook URLs and set in context.
+
+    URL Pattern: /webhook/messenger/{owner_id}/whatsapp
+    Purpose: Extract owner_id and set it in the context system.
+
+    That's it. Nothing more.
+    """
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        """Extract owner_id from URL path and set in context."""
+        owner_id = None
+
+        try:
+            # ENHANCED DEBUGGING: Log all request details
+            logger.debug(f"🔍 OwnerMiddleware processing: {request.method} {request.url.path}")
+            
+            # Extract owner_id from webhook URL pattern: /webhook/messenger/{owner_id}/{platform}
+            if request.url.path.startswith("/webhook/"):
+                logger.debug(f"🎯 Webhook request detected: {request.url.path}")
+                path_parts = request.url.path.strip("/").split("/")
+                logger.debug(f"📋 Path parts: {path_parts} (length: {len(path_parts)})")
+                
+                if len(path_parts) >= 4:
+                    # path_parts = ["webhook", "messenger", "owner_id", "platform"]
+                    owner_id = path_parts[2]
+                    logger.debug(f"🔑 Extracted owner_id from URL: '{owner_id}'")
+
+                    # Validate basic format
+                    if self._is_valid_owner_id(owner_id):
+                        # Set owner_id context from URL
+                        set_request_context(owner_id=owner_id)
+                        logger.debug(f"✅ Owner ID context set successfully: {owner_id}")
+                    else:
+                        logger.error(f"❌ Invalid owner ID format: {owner_id}")
+                        raise HTTPException(
+                            status_code=400, detail=f"Invalid owner ID: {owner_id}"
+                        )
+                else:
+                    logger.warning(f"⚠️ Webhook URL does not have enough parts: {path_parts}")
+
+            # For non-webhook endpoints, use default owner from settings
+            elif not self._is_public_endpoint(request.url.path):
+                default_owner = settings.owner_id
+                set_request_context(owner_id=default_owner)
+                logger.debug(f"Using default owner ID: {default_owner}")
+
+            # Process request
+            response = await call_next(request)
+            return response
+
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Error in owner middleware: {e}", exc_info=True)
+            raise HTTPException(status_code=500, detail="Internal server error") from e
+
+    def _is_valid_owner_id(self, owner_id: str) -> bool:
+        """Validate owner ID format."""
+        if not owner_id or not isinstance(owner_id, str):
+            return False
+
+        # Basic format validation - alphanumeric and underscores only
+        if not owner_id.replace("_", "").replace("-", "").isalnum():
+            return False
+
+        # Length validation
+        return not (len(owner_id) < 3 or len(owner_id) > 50)
+
+    def _is_public_endpoint(self, path: str) -> bool:
+        """Check if endpoint is public and doesn't require owner context."""
+        public_paths = [
+            "/",
+            "/health",
+            "/health/detailed",
+            "/docs",
+            "/redoc",
+            "/openapi.json",
+        ]
+        return any(path.startswith(p) for p in public_paths)

wappa/api/middleware/request_logging.py

@@ -0,0 +1,184 @@
+"""
+Request and response logging middleware with tenant and user context.
+
+Provides comprehensive logging for monitoring, debugging, and audit trails for Wappa framework.
+"""
+
+import time
+from typing import Any
+
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import Response
+
+
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware for logging HTTP requests and responses with context.
+
+    Features:
+    - Tenant-aware logging
+    - Request/response timing
+    - Privacy-conscious logging (excludes sensitive data)
+    - Structured log format for monitoring
+    """
+
+    def __init__(self, app, log_requests: bool = True, log_responses: bool = True):
+        super().__init__(app)
+        self.log_requests = log_requests
+        self.log_responses = log_responses
+        # Sensitive headers to exclude from logs
+        self.sensitive_headers = {
+            "authorization",
+            "x-api-key",
+            "cookie",
+            "set-cookie",
+            "x-access-token",
+            "x-auth-token",
+            "x-whatsapp-hub-signature",
+        }
+
+    async def dispatch(self, request: Request, call_next) -> Response:
+        """Process request with comprehensive logging."""
+        # Start timing
+        start_time = time.time()
+
+        # Get logger with context (context is set by OwnerMiddleware and processors)
+        from wappa.core.logging.logger import get_logger
+
+        logger = get_logger(__name__)
+
+        # Log incoming request
+        if self.log_requests and not self._should_skip_logging(request.url.path):
+            await self._log_request(request, logger)
+
+        # Process request
+        response = await call_next(request)
+
+        # Calculate processing time
+        process_time = time.time() - start_time
+
+        # Add processing time to response headers (in development)
+        from wappa.core.config.settings import settings
+
+        if settings.is_development:
+            response.headers["X-Process-Time"] = str(round(process_time * 1000, 2))
+
+        # Log response
+        if self.log_responses and not self._should_skip_logging(request.url.path):
+            await self._log_response(request, response, process_time, logger)
+
+        return response
+
+    def _extract_user_id(self, request: Request) -> str:
+        """
+        Extract user ID from request context.
+
+        This will be populated by webhook processing or API authentication.
+        For now, returns 'unknown' as we haven't implemented user extraction yet.
+        """
+        return getattr(request.state, "user_id", "unknown")
+
+    def _should_skip_logging(self, path: str) -> bool:
+        """Check if we should skip logging for this path."""
+        # Skip logging for health checks and static assets to reduce noise
+        skip_paths = ["/health", "/docs", "/redoc", "/openapi.json", "/favicon.ico"]
+        return any(path.startswith(skip_path) for skip_path in skip_paths)
+
+    async def _log_request(self, request: Request, logger) -> None:
+        """Log incoming request with sanitized information."""
+        # Safely read body for logging (only for small payloads)
+        body_info = await self._get_request_body_info(request)
+
+        # Sanitized headers (exclude sensitive ones)
+        safe_headers = {
+            k: v
+            for k, v in request.headers.items()
+            if k.lower() not in self.sensitive_headers
+        }
+
+        log_data = {
+            "method": request.method,
+            "url": str(request.url),
+            "path": request.url.path,
+            "query_params": dict(request.query_params),
+            "headers": safe_headers,
+            "client_host": request.client.host if request.client else "unknown",
+            "user_agent": request.headers.get("user-agent", "unknown"),
+            **body_info,
+        }
+
+        logger.info(
+            f"Incoming {request.method} {request.url.path}", extra={"request": log_data}
+        )
+
+    async def _log_response(
+        self, request: Request, response: Response, process_time: float, logger
+    ) -> None:
+        """Log response with timing and status information."""
+        # Determine log level based on status code
+        status_code = response.status_code
+
+        if status_code >= 500:
+            log_level = "error"
+        elif status_code >= 400:
+            log_level = "warning"
+        else:
+            log_level = "info"
+
+        log_data = {
+            "status_code": status_code,
+            "process_time_ms": round(process_time * 1000, 2),
+            "content_length": response.headers.get("content-length", "unknown"),
+            "content_type": response.headers.get("content-type", "unknown"),
+        }
+
+        message = (
+            f"Response {status_code} for {request.method} {request.url.path} "
+            f"({log_data['process_time_ms']}ms)"
+        )
+
+        # Log with appropriate level
+        getattr(logger, log_level)(message, extra={"response": log_data})
+
+    async def _get_request_body_info(self, request: Request) -> dict[str, Any]:
+        """
+        Get safe information about request body.
+
+        Returns body size and type information without logging sensitive content.
+        """
+        try:
+            # Only read body for non-streaming requests and if small enough
+            content_length = request.headers.get("content-length")
+            content_type = request.headers.get("content-type", "unknown")
+
+            body_info = {"content_type": content_type, "content_length": content_length}
+
+            # For webhook endpoints, we might want to log structure but not content
+            if request.url.path.startswith("/webhook/"):
+                body_info["is_webhook"] = True
+                # Don't log webhook payload content for privacy/security
+                body_info["body_logged"] = False
+            else:
+                # For API endpoints, we could log small bodies in development
+                from wappa.core.config.settings import settings
+
+                if (
+                    settings.is_development
+                    and content_length
+                    and int(content_length) < 1000
+                ):  # Only log small payloads
+                    # Read body (this consumes the stream, so we need to be careful)
+                    # For now, just log that we could log it
+                    body_info["body_loggable"] = True
+                else:
+                    body_info["body_logged"] = False
+
+            return body_info
+
+        except Exception as e:
+            # If we can't read body info, just return basic info
+            return {
+                "content_type": request.headers.get("content-type", "unknown"),
+                "body_read_error": str(e),
+            }