wappa 0.1.0__py3-none-any.whl

wappa/core/plugins/cors_plugin.py

@@ -0,0 +1,128 @@
+"""
+CORS Plugin
+
+Plugin for adding Cross-Origin Resource Sharing (CORS) middleware to Wappa applications.
+Provides a simple wrapper around FastAPI's CORSMiddleware with sensible defaults.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from ...core.logging.logger import get_app_logger
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+    from ...core.factory.wappa_builder import WappaBuilder
+
+
+class CORSPlugin:
+    """
+    CORS middleware plugin for Wappa applications.
+
+    Provides Cross-Origin Resource Sharing support with configurable
+    origins, methods, and headers. Uses FastAPI's built-in CORSMiddleware
+    with sensible defaults for most use cases.
+
+    Example:
+        # Basic CORS (allow all origins)
+        cors_plugin = CORSPlugin(allow_origins=["*"])
+
+        # Production CORS (specific origins)
+        cors_plugin = CORSPlugin(
+            allow_origins=["https://myapp.com", "https://www.myapp.com"],
+            allow_credentials=True,
+            allow_methods=["GET", "POST", "PUT", "DELETE"],
+            allow_headers=["*"]
+        )
+    """
+
+    def __init__(
+        self,
+        allow_origins: list[str] = None,
+        allow_methods: list[str] = None,
+        allow_headers: list[str] = None,
+        allow_credentials: bool = False,
+        expose_headers: list[str] = None,
+        max_age: int = 600,
+        priority: int = 90,  # High priority - runs early (outer middleware)
+        **cors_kwargs: Any,
+    ):
+        """
+        Initialize CORS plugin.
+
+        Args:
+            allow_origins: List of allowed origins (defaults to ["*"])
+            allow_methods: List of allowed HTTP methods (defaults to ["GET"])
+            allow_headers: List of allowed headers (defaults to [])
+            allow_credentials: Whether to allow credentials
+            expose_headers: List of headers to expose to the browser
+            max_age: Maximum age for preflight requests
+            priority: Middleware priority (lower runs first/outer)
+            **cors_kwargs: Additional CORSMiddleware arguments
+        """
+        self.allow_origins = allow_origins or ["*"]
+        self.allow_methods = allow_methods or ["GET"]
+        self.allow_headers = allow_headers or []
+        self.allow_credentials = allow_credentials
+        self.expose_headers = expose_headers or []
+        self.max_age = max_age
+        self.priority = priority
+        self.cors_kwargs = cors_kwargs
+
+    def configure(self, builder: "WappaBuilder") -> None:
+        """
+        Configure CORS plugin with WappaBuilder.
+
+        Adds CORSMiddleware to the application with specified configuration.
+
+        Args:
+            builder: WappaBuilder instance
+        """
+        logger = get_app_logger()
+
+        try:
+            from fastapi.middleware.cors import CORSMiddleware
+        except ImportError:
+            logger.error(
+                "CORSMiddleware not available - ensure FastAPI is properly installed"
+            )
+            raise RuntimeError("CORSMiddleware not available")
+
+        # Build CORS configuration
+        cors_config = {
+            "allow_origins": self.allow_origins,
+            "allow_methods": self.allow_methods,
+            "allow_headers": self.allow_headers,
+            "allow_credentials": self.allow_credentials,
+            "expose_headers": self.expose_headers,
+            "max_age": self.max_age,
+            **self.cors_kwargs,
+        }
+
+        # Add middleware to builder with specified priority
+        builder.add_middleware(CORSMiddleware, priority=self.priority, **cors_config)
+
+        logger.debug(
+            f"CORSPlugin configured - Origins: {self.allow_origins}, "
+            f"Methods: {self.allow_methods}, Credentials: {self.allow_credentials}"
+        )
+
+    async def startup(self, app: "FastAPI") -> None:
+        """
+        CORS plugin startup - no startup tasks needed.
+
+        Args:
+            app: FastAPI application instance
+        """
+        logger = get_app_logger()
+        logger.debug("CORSPlugin startup completed")
+
+    async def shutdown(self, app: "FastAPI") -> None:
+        """
+        CORS plugin shutdown - no cleanup tasks needed.
+
+        Args:
+            app: FastAPI application instance
+        """
+        logger = get_app_logger()
+        logger.debug("CORSPlugin shutdown completed")

wappa/core/plugins/custom_middleware_plugin.py

@@ -0,0 +1,182 @@
+"""
+Custom Middleware Plugin
+
+Plugin for adding user-defined middleware to Wappa applications.
+Provides a flexible wrapper for any custom middleware implementation.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from ...core.logging.logger import get_app_logger
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+    from ...core.factory.wappa_builder import WappaBuilder
+
+
+class CustomMiddlewarePlugin:
+    """
+    Custom middleware plugin for Wappa applications.
+
+    Provides a flexible wrapper for any user-defined middleware,
+    allowing complete control over middleware configuration and behavior.
+
+    Example:
+        # Request logging middleware
+        logging_plugin = CustomMiddlewarePlugin(
+            RequestLoggingMiddleware,
+            priority=60,
+            log_level="INFO"
+        )
+
+        # Security headers middleware
+        security_plugin = CustomMiddlewarePlugin(
+            SecurityHeadersMiddleware,
+            priority=85,
+            include_hsts=True,
+            include_csp=True
+        )
+
+        # Performance monitoring middleware
+        monitoring_plugin = CustomMiddlewarePlugin(
+            PerformanceMonitoringMiddleware,
+            priority=10,  # Low priority - runs last (inner)
+            track_response_time=True
+        )
+    """
+
+    def __init__(
+        self,
+        middleware_class: type,
+        priority: int = 50,  # Default priority
+        name: str = None,
+        **middleware_kwargs: Any,
+    ):
+        """
+        Initialize custom middleware plugin.
+
+        Args:
+            middleware_class: Custom middleware class
+            priority: Middleware priority (lower runs first/outer)
+            name: Optional name for the middleware (for logging)
+            **middleware_kwargs: Arguments for the middleware class
+        """
+        self.middleware_class = middleware_class
+        self.priority = priority
+        self.name = name or middleware_class.__name__
+        self.middleware_kwargs = middleware_kwargs
+
+    async def configure(self, builder: "WappaBuilder") -> None:
+        """
+        Configure custom middleware plugin with WappaBuilder.
+
+        Adds the custom middleware to the application.
+
+        Args:
+            builder: WappaBuilder instance
+        """
+        logger = get_app_logger()
+
+        # Add custom middleware to builder
+        builder.add_middleware(
+            self.middleware_class, priority=self.priority, **self.middleware_kwargs
+        )
+
+        logger.debug(
+            f"CustomMiddlewarePlugin configured - {self.name} "
+            f"(priority: {self.priority})"
+        )
+
+    async def startup(self, app: "FastAPI") -> None:
+        """
+        Custom middleware plugin startup.
+
+        Can be used for middleware-specific initialization tasks.
+
+        Args:
+            app: FastAPI application instance
+        """
+        logger = get_app_logger()
+        logger.debug(f"CustomMiddlewarePlugin startup - {self.name}")
+
+    async def shutdown(self, app: "FastAPI") -> None:
+        """
+        Custom middleware plugin shutdown.
+
+        Can be used for middleware-specific cleanup tasks.
+
+        Args:
+            app: FastAPI application instance
+        """
+        logger = get_app_logger()
+        logger.debug(f"CustomMiddlewarePlugin shutdown - {self.name}")
+
+
+# Convenience functions for common custom middleware patterns
+
+
+def create_logging_middleware_plugin(
+    middleware_class: type, log_level: str = "INFO", priority: int = 60, **kwargs: Any
+) -> CustomMiddlewarePlugin:
+    """
+    Create a logging middleware plugin.
+
+    Args:
+        middleware_class: Logging middleware class
+        log_level: Logging level
+        priority: Middleware priority
+        **kwargs: Additional middleware arguments
+
+    Returns:
+        Configured CustomMiddlewarePlugin for logging
+    """
+    return CustomMiddlewarePlugin(
+        middleware_class,
+        priority=priority,
+        name="LoggingMiddleware",
+        log_level=log_level,
+        **kwargs,
+    )
+
+
+def create_security_middleware_plugin(
+    middleware_class: type,
+    priority: int = 85,  # High priority - runs early
+    **kwargs: Any,
+) -> CustomMiddlewarePlugin:
+    """
+    Create a security middleware plugin.
+
+    Args:
+        middleware_class: Security middleware class
+        priority: Middleware priority
+        **kwargs: Additional middleware arguments
+
+    Returns:
+        Configured CustomMiddlewarePlugin for security
+    """
+    return CustomMiddlewarePlugin(
+        middleware_class, priority=priority, name="SecurityMiddleware", **kwargs
+    )
+
+
+def create_monitoring_middleware_plugin(
+    middleware_class: type,
+    priority: int = 10,  # Low priority - runs last (inner)
+    **kwargs: Any,
+) -> CustomMiddlewarePlugin:
+    """
+    Create a monitoring/metrics middleware plugin.
+
+    Args:
+        middleware_class: Monitoring middleware class
+        priority: Middleware priority
+        **kwargs: Additional middleware arguments
+
+    Returns:
+        Configured CustomMiddlewarePlugin for monitoring
+    """
+    return CustomMiddlewarePlugin(
+        middleware_class, priority=priority, name="MonitoringMiddleware", **kwargs
+    )

wappa/core/plugins/database_plugin.py

@@ -0,0 +1,235 @@
+"""
+Database Plugin
+
+Core plugin for integrating SQLModel/SQLAlchemy database functionality
+with the Wappa framework. Supports multiple database engines through
+adapter pattern.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from ...core.logging.logger import get_app_logger
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+    from sqlmodel import SQLModel
+
+    from ...core.factory.wappa_builder import WappaBuilder
+    from ...database.adapter import DatabaseAdapter
+
+
+class DatabasePlugin:
+    """
+    Universal database plugin for SQLModel/SQLAlchemy integration.
+
+    This plugin provides database connectivity, session management, and
+    schema initialization for any supported database engine (PostgreSQL,
+    SQLite, MySQL) through the adapter pattern.
+
+    Example:
+        # PostgreSQL
+        db_plugin = DatabasePlugin(
+            "postgresql+asyncpg://user:pass@localhost/db",
+            PostgreSQLAdapter(),
+            models=[User, Order]
+        )
+
+        # SQLite
+        db_plugin = DatabasePlugin(
+            "sqlite+aiosqlite:///./app.db",
+            SQLiteAdapter(),
+            models=[User, Order]
+        )
+
+        # Usage in app
+        async with app.state.db_session() as session:
+            users = await session.exec(select(User))
+    """
+
+    def __init__(
+        self,
+        connection_string: str,
+        adapter: "DatabaseAdapter",
+        models: list[type["SQLModel"]] = None,
+        initialize_schema: bool = True,
+        **adapter_kwargs: Any,
+    ):
+        """
+        Initialize database plugin.
+
+        Args:
+            connection_string: Database connection URL
+            adapter: DatabaseAdapter implementation (PostgreSQL, SQLite, MySQL)
+            models: List of SQLModel classes to create tables for
+            initialize_schema: Whether to create tables on startup
+            **adapter_kwargs: Additional arguments for database adapter
+        """
+        self.connection_string = connection_string
+        self.adapter = adapter
+        self.models = models or []
+        self.initialize_schema = initialize_schema
+        self.adapter_kwargs = adapter_kwargs
+
+        self.engine = None
+        self.session_factory = None
+
+    async def configure(self, builder: "WappaBuilder") -> None:
+        """
+        Configure the database plugin with WappaBuilder.
+
+        This method is called during build phase - no configuration needed
+        for database plugin as it manages its own lifecycle.
+
+        Args:
+            builder: WappaBuilder instance
+        """
+        # Database plugin doesn't need to configure middleware/routes
+        pass
+
+    async def startup(self, app: "FastAPI") -> None:
+        """
+        Initialize database during application startup.
+
+        Creates the async engine, session factory, and optionally
+        initializes the database schema from SQLModel definitions.
+
+        Args:
+            app: FastAPI application instance
+        """
+        logger = get_app_logger()
+
+        try:
+            # Create async engine
+            logger.debug(
+                f"Creating database engine with adapter: {self.adapter.__class__.__name__}"
+            )
+            self.engine = await self.adapter.create_engine(
+                self.connection_string, **self.adapter_kwargs
+            )
+
+            # Create session factory
+            logger.debug("Creating database session factory...")
+            self.session_factory = await self.adapter.create_session_factory(
+                self.engine
+            )
+
+            # Perform health check
+            is_healthy = await self.adapter.health_check(self.engine)
+            if not is_healthy:
+                raise RuntimeError("Database health check failed")
+
+            # Initialize schema if requested and models provided
+            if self.initialize_schema and self.models:
+                logger.debug(f"Initializing schema for {len(self.models)} models...")
+                await self.adapter.initialize_schema(self.engine, self.models)
+                logger.info(
+                    f"Database schema initialized for models: {[m.__name__ for m in self.models]}"
+                )
+
+            # Store in app state for user access
+            app.state.db_engine = self.engine
+            app.state.db_session = self.session_factory
+            app.state.db_adapter = self.adapter
+
+            # Get connection info for logging
+            connection_info = await self.adapter.get_connection_info(self.engine)
+            logger.info(
+                f"Database plugin initialized successfully - "
+                f"Driver: {connection_info.get('driver')}, "
+                f"Database: {connection_info.get('database')}, "
+                f"Version: {connection_info.get('version', 'unknown')}"
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to initialize database plugin: {e}", exc_info=True)
+            raise RuntimeError(f"Database plugin startup failed: {e}") from e
+
+    async def shutdown(self, app: "FastAPI") -> None:
+        """
+        Clean up database resources during application shutdown.
+
+        Properly disposes of the async engine and cleans up connections.
+
+        Args:
+            app: FastAPI application instance
+        """
+        logger = get_app_logger()
+
+        try:
+            if self.engine:
+                logger.debug("Disposing database engine...")
+                await self.engine.dispose()
+                logger.info("Database engine disposed successfully")
+
+            # Clean up app state
+            if hasattr(app.state, "db_engine"):
+                del app.state.db_engine
+            if hasattr(app.state, "db_session"):
+                del app.state.db_session
+            if hasattr(app.state, "db_adapter"):
+                del app.state.db_adapter
+
+        except Exception as e:
+            logger.error(f"Error during database plugin shutdown: {e}", exc_info=True)
+
+    async def get_health_status(self, app: "FastAPI") -> dict[str, Any]:
+        """
+        Get database health status for monitoring.
+
+        Args:
+            app: FastAPI application instance
+
+        Returns:
+            Dictionary with database health information
+        """
+        if not self.engine:
+            return {
+                "healthy": False,
+                "error": "Database engine not initialized",
+                "adapter": self.adapter.__class__.__name__,
+            }
+
+        try:
+            is_healthy = await self.adapter.health_check(self.engine)
+            connection_info = await self.adapter.get_connection_info(self.engine)
+
+            return {
+                "healthy": is_healthy,
+                "adapter": self.adapter.__class__.__name__,
+                "connection_string": self._mask_connection_string(),
+                **connection_info,
+            }
+        except Exception as e:
+            return {
+                "healthy": False,
+                "error": str(e),
+                "adapter": self.adapter.__class__.__name__,
+            }
+
+    def _mask_connection_string(self) -> str:
+        """
+        Mask sensitive information in connection string for logging.
+
+        Returns:
+            Connection string with password masked
+        """
+        if "://" not in self.connection_string:
+            return self.connection_string
+
+        parts = self.connection_string.split("://", 1)
+        if len(parts) != 2:
+            return self.connection_string
+
+        scheme, rest = parts
+        if "@" not in rest:
+            return self.connection_string
+
+        # Mask password in user:pass@host format
+        user_part, host_part = rest.split("@", 1)
+        if ":" in user_part:
+            user, _ = user_part.split(":", 1)
+            masked_user_part = f"{user}:***"
+        else:
+            masked_user_part = user_part
+
+        return f"{scheme}://{masked_user_part}@{host_part}"