thoth-dbmanager 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

thoth_dbmanager/adapters/supabase.py

@@ -0,0 +1,249 @@
+"""
+Supabase adapter implementation.
+"""
+import logging
+from typing import Any, Dict, List, Optional, Union
+import psycopg2
+from psycopg2.extras import RealDictCursor
+from sqlalchemy import create_engine, text
+from sqlalchemy.exc import SQLAlchemyError
+from urllib.parse import urlparse, parse_qs
+
+from .postgresql import PostgreSQLAdapter
+from ..core.interfaces import DbAdapter
+from ..documents import (
+    TableDocument,
+    ColumnDocument,
+    SchemaDocument,
+    ForeignKeyDocument,
+    IndexDocument
+)
+
+logger = logging.getLogger(__name__)
+
+
+class SupabaseAdapter(PostgreSQLAdapter):
+    """
+    Supabase database adapter implementation.
+    Extends PostgreSQL adapter with Supabase-specific features.
+    """
+    
+    def __init__(self, connection_params: Dict[str, Any]):
+        super().__init__(connection_params)
+        self.supabase_url = None
+        self.api_key = None
+        self.use_rest_api = False
+        
+    def connect(self) -> None:
+        """Establish Supabase connection with SSL enforcement"""
+        try:
+            # Check if we should use REST API or direct database connection
+            self.use_rest_api = self.connection_params.get('use_rest_api', False)
+            
+            if self.use_rest_api:
+                # REST API connection setup
+                self.supabase_url = self.connection_params.get('project_url')
+                self.api_key = self.connection_params.get('api_key')
+                
+                if not self.supabase_url or not self.api_key:
+                    raise ValueError("project_url and api_key are required for REST API mode")
+                
+                logger.info("Supabase REST API connection established")
+            else:
+                # Direct database connection (PostgreSQL with SSL)
+                super().connect()
+                
+                # Ensure SSL is enabled for Supabase
+                if hasattr(self, 'engine') and self.engine:
+                    # Update connection string to enforce SSL
+                    connection_string = self._build_connection_string()
+                    if 'sslmode=' not in connection_string:
+                        connection_string += '?sslmode=require'
+                    
+                    self.engine = create_engine(connection_string, echo=False)
+                    
+                    # Test connection
+                    with self.engine.connect() as conn:
+                        conn.execute(text("SELECT 1"))
+                
+                logger.info("Supabase database connection established with SSL")
+                
+        except Exception as e:
+            logger.error(f"Failed to connect to Supabase: {e}")
+            raise
+    
+    def _build_connection_string(self) -> str:
+        """Build SQLAlchemy connection string with Supabase-specific parameters"""
+        params = self.connection_params
+        
+        if self.use_rest_api:
+            return params.get('project_url')
+        
+        # Direct database connection
+        host = params.get('host')
+        port = params.get('port', 5432)
+        database = params.get('database')
+        user = params.get('user')
+        password = params.get('password')
+        
+        if not all([host, database, user, password]):
+            raise ValueError("Missing required connection parameters: host, database, user, password")
+        
+        # Ensure SSL mode for Supabase
+        ssl_mode = params.get('sslmode', 'require')
+        
+        connection_string = f"postgresql://{user}:{password}@{host}:{port}/{database}?sslmode={ssl_mode}"
+        
+        # Add additional SSL parameters if provided
+        if params.get('sslcert'):
+            connection_string += f"&sslcert={params['sslcert']}"
+        if params.get('sslkey'):
+            connection_string += f"&sslkey={params['sslkey']}"
+        if params.get('sslrootcert'):
+            connection_string += f"&sslrootcert={params['sslrootcert']}"
+            
+        return connection_string
+    
+    def _get_psycopg2_params(self) -> Dict[str, Any]:
+        """Get parameters for psycopg2 connection with SSL"""
+        params = super()._get_psycopg2_params()
+        
+        # Ensure SSL is enabled for Supabase
+        params['sslmode'] = self.connection_params.get('sslmode', 'require')
+        
+        # Add SSL certificates if provided
+        if self.connection_params.get('sslcert'):
+            params['sslcert'] = self.connection_params['sslcert']
+        if self.connection_params.get('sslkey'):
+            params['sslkey'] = self.connection_params['sslkey']
+        if self.connection_params.get('sslrootcert'):
+            params['sslrootcert'] = self.connection_params['sslrootcert']
+            
+        return params
+    
+    def execute_query(self, query: str, params: Optional[Dict] = None, fetch: Union[str, int] = "all", timeout: int = 60) -> Any:
+        """Execute SQL queries with Supabase-specific optimizations"""
+        if self.use_rest_api:
+            return self._execute_rest_query(query, params, fetch, timeout)
+        else:
+            return super().execute_query(query, params, fetch, timeout)
+    
+    def _execute_rest_query(self, query: str, params: Optional[Dict] = None, fetch: Union[str, int] = "all", timeout: int = 60) -> Any:
+        """Execute query using Supabase REST API"""
+        try:
+            from supabase import create_client
+            from postgrest.exceptions import APIError
+            
+            # Create Supabase client
+            supabase = create_client(self.supabase_url, self.api_key)
+            
+            # For REST API, we need to convert SQL to Postgrest queries
+            # This is a simplified implementation - in practice, you'd need a SQL parser
+            if query.strip().upper().startswith('SELECT'):
+                # Extract table name and conditions from query
+                table_name = self._extract_table_name(query)
+                
+                # Build Postgrest query
+                result = supabase.table(table_name).select('*').execute()
+                
+                if fetch == "all":
+                    return result.data
+                elif fetch == "one":
+                    return result.data[0] if result.data else None
+                elif isinstance(fetch, int):
+                    return result.data[:fetch]
+                else:
+                    return result.data
+            else:
+                # For non-SELECT queries, use RPC
+                result = supabase.rpc('execute_sql', {'sql': query}).execute()
+                return result.data
+                
+        except ImportError:
+            raise RuntimeError("supabase-py package is required for REST API mode")
+        except APIError as e:
+            logger.error(f"Supabase REST API error: {e}")
+            raise
+    
+    def _extract_table_name(self, query: str) -> str:
+        """Extract table name from SQL query (simplified)"""
+        # This is a basic implementation - in practice, you'd use a proper SQL parser
+        query = query.upper()
+        from_index = query.find('FROM')
+        if from_index != -1:
+            after_from = query[from_index + 4:].strip()
+            # Find first space or end of string
+            space_index = after_from.find(' ')
+            if space_index != -1:
+                return after_from[:space_index].lower()
+            else:
+                return after_from.lower()
+        return "unknown"
+    
+    def get_tables_as_documents(self) -> List[TableDocument]:
+        """Get tables with Supabase schema considerations"""
+        tables = super().get_tables_as_documents()
+        
+        # Filter out Supabase system schemas
+        filtered_tables = []
+        for table in tables:
+            if table.schema_name not in ['auth', 'storage', 'realtime', 'supabase_functions']:
+                filtered_tables.append(table)
+        
+        return filtered_tables
+    
+    def get_columns_as_documents(self, table_name: str) -> List[ColumnDocument]:
+        """Get columns with Supabase-specific handling"""
+        columns = super().get_columns_as_documents(table_name)
+        
+        # Add Supabase-specific metadata
+        for column in columns:
+            if column.column_name in ['created_at', 'updated_at']:
+                column.comment = f"{column.comment} (Supabase auto-timestamp)"
+            elif column.column_name == 'id':
+                column.comment = f"{column.comment} (Supabase auto-increment)"
+        
+        return columns
+    
+    def get_unique_values(self) -> Dict[str, Dict[str, List[str]]]:
+        """Get unique values with Supabase schema filtering"""
+        result = super().get_unique_values()
+        
+        # Filter out Supabase system tables
+        filtered_result = {}
+        for table_name, columns in result.items():
+            if not table_name.startswith('auth_') and not table_name.startswith('storage_'):
+                filtered_result[table_name] = columns
+        
+        return filtered_result
+    
+    def get_example_data(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """Get example data with Supabase-specific handling"""
+        if self.use_rest_api:
+            return self._get_example_data_rest(table_name, number_of_rows)
+        else:
+            return super().get_example_data(table_name, number_of_rows)
+    
+    def _get_example_data_rest(self, table_name: str, number_of_rows: int = 30) -> Dict[str, List[Any]]:
+        """Get example data using REST API"""
+        try:
+            from supabase import create_client
+            
+            supabase = create_client(self.supabase_url, self.api_key)
+            
+            # Get data from REST API
+            result = supabase.table(table_name).select('*').limit(number_of_rows).execute()
+            
+            # Convert to the expected format
+            example_data = {}
+            if result.data:
+                for key in result.data[0].keys():
+                    example_data[key] = [row.get(key) for row in result.data]
+            
+            return example_data
+            
+        except ImportError:
+            raise RuntimeError("supabase-py package is required for REST API mode")
+        except Exception as e:
+            logger.error(f"Error getting example data via REST API: {e}")
+            return {}

thoth_dbmanager/core/__init__.py

@@ -0,0 +1,13 @@
+"""
+Core components for Thoth SQL Database Manager.
+"""
+from .interfaces import DbPlugin, DbAdapter
+from .registry import DbPluginRegistry
+from .factory import ThothDbFactory
+
+__all__ = [
+    "DbPlugin",
+    "DbAdapter", 
+    "DbPluginRegistry",
+    "ThothDbFactory",
+]

thoth_dbmanager/core/factory.py

@@ -0,0 +1,272 @@
+"""
+Factory for creating database manager instances with plugin support.
+"""
+import logging
+from typing import Any, Dict, List, Optional
+from .registry import DbPluginRegistry
+from .interfaces import DbPlugin
+
+logger = logging.getLogger(__name__)
+
+
+class ThothDbFactory:
+    """
+    Factory class for creating database manager instances.
+    Provides plugin-based instantiation with backward compatibility.
+    """
+    
+    @staticmethod
+    def create_manager(db_type: str, db_root_path: Optional[str] = None, db_mode: str = "dev", **kwargs) -> DbPlugin:
+        """
+        Create a database manager instance using the plugin system.
+        
+        Args:
+            db_type: Database type identifier (e.g., 'postgresql', 'sqlite')
+            db_root_path: Path to database root directory (can be in kwargs)
+            db_mode: Database mode (dev, prod, etc.)
+            **kwargs: Database-specific connection parameters
+            
+        Returns:
+            Database plugin instance
+            
+        Raises:
+            ValueError: If database type is not supported
+            RuntimeError: If plugin initialization fails
+        """
+        try:
+            # Handle db_root_path from kwargs for backward compatibility
+            if db_root_path is None:
+                db_root_path = kwargs.get('db_root_path')
+            if db_root_path is None:
+                raise ValueError("db_root_path is required")
+
+            # Handle db_mode from kwargs for backward compatibility
+            if 'db_mode' in kwargs:
+                db_mode = kwargs.get('db_mode', db_mode)
+
+            # Remove extracted parameters from kwargs to avoid duplicate parameter errors
+            kwargs_clean = kwargs.copy()
+            kwargs_clean.pop('db_root_path', None)
+            kwargs_clean.pop('db_mode', None)
+
+            # Create plugin instance
+            plugin = DbPluginRegistry.create_plugin(
+                db_type=db_type,
+                db_root_path=db_root_path,
+                db_mode=db_mode,
+                **kwargs_clean
+            )
+            
+            # Initialize the plugin
+            plugin.initialize(**kwargs_clean)
+            
+            logger.info(f"Successfully created {db_type} manager for {db_root_path}")
+            return plugin
+            
+        except Exception as e:
+            logger.error(f"Failed to create {db_type} manager: {e}")
+            raise RuntimeError(f"Failed to create {db_type} manager: {e}") from e
+    
+    @staticmethod
+    def list_available_databases() -> List[str]:
+        """
+        List all available database types.
+        
+        Returns:
+            List of supported database type identifiers
+        """
+        return DbPluginRegistry.list_plugins()
+    
+    @staticmethod
+    def get_database_info(db_type: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Get information about available database plugins.
+        
+        Args:
+            db_type: Specific database type, or None for all
+            
+        Returns:
+            Database plugin information
+        """
+        return DbPluginRegistry.get_plugin_info(db_type)
+    
+    @staticmethod
+    def validate_database_type(db_type: str) -> bool:
+        """
+        Check if a database type is supported.
+        
+        Args:
+            db_type: Database type identifier
+            
+        Returns:
+            True if supported, False otherwise
+        """
+        return db_type in DbPluginRegistry.list_plugins()
+    
+    @staticmethod
+    def get_required_parameters(db_type: str) -> Dict[str, Any]:
+        """
+        Get required connection parameters for a database type.
+        
+        Args:
+            db_type: Database type identifier
+            
+        Returns:
+            Dictionary describing required parameters
+        """
+        try:
+            plugin_class = DbPluginRegistry.get_plugin_class(db_type)
+            
+            # This would ideally be defined in the plugin class
+            # For now, return common parameters based on database type
+            common_params = {
+                "postgresql": {
+                    "required": ["host", "port", "database", "user", "password"],
+                    "optional": ["schema", "sslmode", "connect_timeout"]
+                },
+                "supabase": {
+                    "required": ["host", "port", "database", "user", "password"],
+                    "optional": ["schema", "sslmode", "connect_timeout", "project_url", "api_key", "use_rest_api"]
+                },
+                "sqlite": {
+                    "required": ["database_path"],
+                    "optional": ["timeout", "check_same_thread"]
+                },
+                "mysql": {
+                    "required": ["host", "port", "database", "user", "password"],
+                    "optional": ["charset", "autocommit", "connect_timeout"]
+                },
+                "mariadb": {
+                    "required": ["host", "port", "database", "user", "password"],
+                    "optional": ["charset", "autocommit", "connect_timeout"]
+                },
+                "sqlserver": {
+                    "required": ["server", "database", "user", "password"],
+                    "optional": ["driver", "trusted_connection", "timeout"]
+                },
+                "oracle": {
+                    "required": ["host", "port", "service_name", "user", "password"],
+                    "optional": ["encoding", "nencoding", "threaded"]
+                },
+                "informix": {
+                    "required": ["server", "database", "host", "user", "password"],
+                    "optional": ["protocol", "service", "timeout"]
+                }
+            }
+            
+            return common_params.get(db_type, {
+                "required": [],
+                "optional": [],
+                "note": f"Parameters for {db_type} not defined. Check plugin documentation."
+            })
+            
+        except ValueError:
+            return {
+                "error": f"Database type '{db_type}' not supported",
+                "available_types": DbPluginRegistry.list_plugins()
+            }
+    
+    @staticmethod
+    def create_with_validation(db_type: str, db_root_path: str, db_mode: str = "dev", **kwargs) -> DbPlugin:
+        """
+        Create a database manager with parameter validation.
+        
+        Args:
+            db_type: Database type identifier
+            db_root_path: Path to database root directory
+            db_mode: Database mode
+            **kwargs: Connection parameters
+            
+        Returns:
+            Database plugin instance
+            
+        Raises:
+            ValueError: If parameters are invalid
+            RuntimeError: If creation fails
+        """
+        # Validate database type
+        if not ThothDbFactory.validate_database_type(db_type):
+            available = ThothDbFactory.list_available_databases()
+            raise ValueError(f"Unsupported database type '{db_type}'. Available: {available}")
+        
+        # Get required parameters
+        param_info = ThothDbFactory.get_required_parameters(db_type)
+        
+        if "required" in param_info:
+            # Check required parameters
+            missing_params = []
+            for param in param_info["required"]:
+                if param not in kwargs:
+                    missing_params.append(param)
+            
+            if missing_params:
+                raise ValueError(f"Missing required parameters for {db_type}: {missing_params}")
+        
+        # Create the manager
+        return ThothDbFactory.create_manager(db_type, db_root_path, db_mode, **kwargs)
+    
+    @staticmethod
+    def create_from_config(config: Dict[str, Any]) -> DbPlugin:
+        """
+        Create a database manager from a configuration dictionary.
+        
+        Args:
+            config: Configuration dictionary containing all parameters
+            
+        Returns:
+            Database plugin instance
+            
+        Example config:
+            {
+                "db_type": "postgresql",
+                "db_root_path": "/path/to/db",
+                "db_mode": "dev",
+                "host": "localhost",
+                "port": 5432,
+                "database": "mydb",
+                "user": "user",
+                "password": "pass"
+            }
+        """
+        # Extract factory parameters
+        db_type = config.pop("db_type")
+        db_root_path = config.pop("db_root_path")
+        db_mode = config.pop("db_mode", "dev")
+        
+        # Remaining parameters are connection parameters
+        return ThothDbFactory.create_with_validation(
+            db_type=db_type,
+            db_root_path=db_root_path,
+            db_mode=db_mode,
+            **config
+        )
+    
+    @staticmethod
+    def get_plugin_status() -> Dict[str, Any]:
+        """
+        Get status information about all registered plugins.
+        
+        Returns:
+            Status information for all plugins
+        """
+        plugins = DbPluginRegistry.list_plugins()
+        status = {
+            "total_plugins": len(plugins),
+            "available_types": plugins,
+            "plugins": {}
+        }
+        
+        for db_type in plugins:
+            try:
+                plugin_info = DbPluginRegistry.get_plugin_info(db_type)
+                status["plugins"][db_type] = {
+                    "status": "available",
+                    "info": plugin_info
+                }
+            except Exception as e:
+                status["plugins"][db_type] = {
+                    "status": "error",
+                    "error": str(e)
+                }
+        
+        return status