Merge pull request #51 from alexander-zuev/fix/nonexistent-migrations-schema

fix(migrations): fix issue with cold start of migration schema

Author: alexander-zuev

CHANGELOG.MD

@@ -5,7 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 
-## [0.3.10] - Unreleased
+## [0.3.11] - 2025-03-10
+### Fixed
+- Fixed an error with creating a migration file when a user doesn't have `supabase_migrations` schema
+
+
+## [0.3.10] - 2025-03-09
 ### Added
 - Enhanced migration naming system with improved object type detection for procedures, functions, and views.
 - Expanded `retrieve_migrations` tool with pagination, name pattern filtering, and option to include full SQL queries.

pyproject.toml

@@ -19,7 +19,7 @@ dependencies = [
 authors = [
     {name = "Alexander Zuev", email = "azuev@outlook.com"}
 ]
-keywords = ["supabase", "mcp", "cursor", "windsurf"]
+keywords = ["supabase", "mcp", "cursor", "windsurf", "model-context-protocol", "claude", "cline"]
 license = "Apache-2.0"
 classifiers = [
     "Development Status :: 4 - Beta",

supabase_mcp/services/database/migration_manager.py

@@ -3,6 +3,7 @@
 import re
 
 from supabase_mcp.logger import logger
+from supabase_mcp.services.database.sql.loader import SQLLoader
 from supabase_mcp.services.database.sql.models import (
     QueryValidationResults,
     SQLQueryCategory,
@@ -13,6 +14,14 @@
 class MigrationManager:
     """Responsible for preparing migration scripts without executing them."""
 
+    def __init__(self, loader: SQLLoader | None = None):
+        """Initialize the migration manager with a SQL loader.
+
+        Args:
+            loader: The SQL loader to use for loading SQL queries
+        """
+        self.loader = loader or SQLLoader()
+
     def prepare_migration_query(
         self,
         validation_result: QueryValidationResults,
@@ -39,19 +48,15 @@ def prepare_migration_query(
             name = self.generate_descriptive_name(validation_result)
 
         # Generate migration version (timestamp)
-        query_timestamp = self.generate_query_timestamp()
+        version = self.generate_query_timestamp()
 
         # Escape single quotes in the query for SQL safety
-        escaped_query = original_query.replace("'", "''")
+        statements = original_query.replace("'", "''")
 
-        # Create the complete migration query with values directly embedded
-        migration_query = f"""
-        INSERT INTO supabase_migrations.schema_migrations
-        (version, name, statements)
-        VALUES ('{query_timestamp}', '{name}', ARRAY['{escaped_query}']);
-        """
+        # Get the migration query using the loader
+        migration_query = self.loader.get_create_migration_query(version, name, statements)
 
-        logger.info(f"Prepared migration: {query_timestamp}_{name}")
+        logger.info(f"Prepared migration: {version}_{name}")
 
         # Return the complete query
         return migration_query, name

supabase_mcp/services/database/postgres_client.py

@@ -276,9 +276,8 @@ async def execute_statement(self, conn: asyncpg.Connection[Any], query: str) ->
             # Return the result
             return StatementResult(rows=rows)
 
-        except asyncpg.PostgresError:
-            # Let the transaction handler deal with this
-            raise
+        except asyncpg.PostgresError as e:
+            await self._handle_postgres_error(e)
 
     @retry(
         retry=retry_if_exception_type(
@@ -293,7 +292,7 @@ async def execute_statement(self, conn: asyncpg.Connection[Any], query: str) ->
         wait=wait_exponential(multiplier=1, min=2, max=10),
         before_sleep=log_db_retry_attempt,
     )
-    async def execute_query_async(
+    async def execute_query(
         self,
         validated_query: QueryValidationResults,
         readonly: bool = True,  # Default to read-only for safety
@@ -339,79 +338,6 @@ async def transaction_operation():
         # Execute the operation with a connection
         return await self.with_connection(execute_all_statements)
 
-    # Keep the original methods but mark them as deprecated
-
-    # TODO: This method is now deprecated, use execute_query_async instead
-    async def _execute_statements(
-        self,
-        validated_query: QueryValidationResults,
-        readonly: bool = False,
-    ) -> QueryResult:
-        """Executes one or more statements in a transaction.
-
-        DEPRECATED: Use execute_query_async instead.
-
-        Args:
-            validated_query: QueryValidationResults containing parsed statements
-            readonly: Read-only mode override
-
-        Returns:
-            QueryResult containing combined rows from all statements
-        """
-        # This implementation is kept for backward compatibility
-        # but will be removed in a future version
-        async with self._pool.acquire() as conn:
-            logger.debug(f"Wrapping query in transaction (readonly={readonly})")
-            # Initialize results list
-            results: list[StatementResult] = []
-
-            async with conn.transaction(readonly=readonly):
-                for statement in validated_query.statements:
-                    if statement.query:
-                        result = await self._execute_raw_query(conn, statement.query)
-                        # Append each result inside the loop
-                        results.append(result)
-
-            # Return combined results
-            return QueryResult(results=results)
-
-    # TODO: This method is now deprecated, use execute_statement instead
-    async def _execute_raw_query(
-        self,
-        conn: asyncpg.Connection[Any],
-        query: str,
-    ) -> StatementResult:
-        """Execute the raw query and process results.
-
-        DEPRECATED: Use execute_statement instead.
-
-        Args:
-            conn: Database connection
-            query: SQL query to execute
-
-        Returns:
-            StatementResult containing rows and metadata
-        """
-        # This implementation is kept for backward compatibility
-        # but will be removed in a future version
-        try:
-            result = await conn.fetch(query)
-            logger.debug(f"Query executed successfully: {result}")
-
-            # Convert records to dictionaries
-            rows = [dict(record) for record in result]
-
-            return StatementResult(rows=rows)
-
-        except asyncpg.PostgresError as e:
-            logger.error(f"PostgreSQL error during query execution: {e}")
-            # Handle and convert exceptions - this will raise appropriate exceptions
-            await self._handle_postgres_error(e)
-
-            # This line will never be reached as _handle_postgres_error always raises an exception
-            # But we need it to satisfy the type checker
-            raise QueryError("Unexpected error occurred")
-
     async def _handle_postgres_error(self, error: asyncpg.PostgresError) -> None:
         """Handle PostgreSQL errors and convert to appropriate exceptions.
 
@@ -438,4 +364,4 @@ async def _handle_postgres_error(self, error: asyncpg.PostgresError) -> None:
             raise QueryError(str(error)) from error
         else:
             logger.error(f"Database error: {error}")
-            raise QueryError(f"Query failed: {str(error)}") from error
+            raise QueryError(f"Query execution failed: {str(error)}") from error

supabase_mcp/services/database/query_manager.py

@@ -1,9 +1,8 @@
-from pathlib import Path
-
 from supabase_mcp.exceptions import OperationNotAllowedError
 from supabase_mcp.logger import logger
 from supabase_mcp.services.database.migration_manager import MigrationManager
 from supabase_mcp.services.database.postgres_client import PostgresClient, QueryResult
+from supabase_mcp.services.database.sql.loader import SQLLoader
 from supabase_mcp.services.database.sql.models import QueryValidationResults
 from supabase_mcp.services.database.sql.validator import SQLValidator
 from supabase_mcp.services.safety.models import ClientType, SafetyMode
@@ -24,26 +23,29 @@ class QueryManager:
     validation and execution patterns.
     """
 
-    # Path to SQL files directory
-    SQL_DIR = Path(__file__).parent / "sql" / "queries"
-
     def __init__(
         self,
         postgres_client: PostgresClient,
         safety_manager: SafetyManager,
         sql_validator: SQLValidator | None = None,
         migration_manager: MigrationManager | None = None,
+        sql_loader: SQLLoader | None = None,
     ):
         """
         Initialize the QueryManager.
 
         Args:
-            db_client: The database client to use for executing queries
+            postgres_client: The database client to use for executing queries
+            safety_manager: The safety manager to use for validating operations
+            sql_validator: Optional SQL validator to use
+            migration_manager: Optional migration manager to use
+            sql_loader: Optional SQL loader to use
         """
         self.db_client = postgres_client
         self.safety_manager = safety_manager
         self.validator = sql_validator or SQLValidator()
-        self.migration_manager = migration_manager or MigrationManager()
+        self.sql_loader = sql_loader or SQLLoader()
+        self.migration_manager = migration_manager or MigrationManager(loader=self.sql_loader)
 
     def check_readonly(self) -> bool:
         """Returns true if current safety mode is SAFE."""
@@ -103,7 +105,7 @@ async def handle_query_execution(self, validated_query: QueryValidationResults)
             QueryResult: The result of the query execution
         """
         readonly = self.check_readonly()
-        result = await self.db_client.execute_query_async(validated_query, readonly)
+        result = await self.db_client.execute_query(validated_query, readonly)
         logger.debug(f"Query result: {result}")
         return result
 
@@ -120,24 +122,42 @@ async def handle_migration(
         """
         # 1. Check if migration is needed
         if not validation_result.needs_migration():
-            logger.info("No migration needed for this query")
+            logger.debug("No migration needed for this query")
             return
 
-        # 2. Create migration
-        try:
-            # Prepare the migration with the original query
-            migration_query, migration_name = self.migration_manager.prepare_migration_query(
-                validation_result, original_query, migration_name
-            )
+        # 2. Prepare migration query
+        migration_query, name = self.migration_manager.prepare_migration_query(
+            validation_result, original_query, migration_name
+        )
+        logger.debug("Migration query prepared")
 
-            # Validate migration query, since it's a raw query
-            validated_query = self.validator.validate_query(migration_query)
+        # 3. Execute migration query
+        try:
+            # First, ensure the migration schema exists
+            await self.init_migration_schema()
 
-            await self.handle_query_execution(validated_query)
-            logger.info(f"Successfully created migration: {migration_name}")
+            # Then execute the migration query
+            migration_validation = self.validator.validate_query(migration_query)
+            await self.db_client.execute_query(migration_validation, readonly=False)
+            logger.info(f"Migration '{name}' executed successfully")
         except Exception as e:
             logger.debug(f"Migration failure details: {str(e)}")
-            raise e
+            # We don't want to fail the main query if migration fails
+            # Just log the error and continue
+            logger.warning(f"Failed to record migration '{name}': {e}")
+
+    async def init_migration_schema(self) -> None:
+        """Initialize the migrations schema and table if they don't exist."""
+        try:
+            # Get the initialization query
+            init_query = self.sql_loader.get_init_migrations_query()
+
+            # Validate and execute it
+            init_validation = self.validator.validate_query(init_query)
+            await self.db_client.execute_query(init_validation, readonly=False)
+            logger.debug("Migrations schema initialized successfully")
+        except Exception as e:
+            logger.warning(f"Failed to initialize migrations schema: {e}")
 
     async def handle_confirmation(self, confirmation_id: str) -> QueryResult:
         """
@@ -163,101 +183,22 @@ async def handle_confirmation(self, confirmation_id: str) -> QueryResult:
         # Call handle_query with the query and has_confirmation=True
         return await self.handle_query(query, has_confirmation=True)
 
-    @classmethod
-    def load_sql(cls, filename: str) -> str:
-        """
-        Load SQL from a file in the sql directory.
-
-        Args:
-            filename: Name of the SQL file (with or without .sql extension)
-
-        Returns:
-            str: The SQL query from the file
-
-        Raises:
-            FileNotFoundError: If the SQL file doesn't exist
-        """
-        # Ensure the filename has .sql extension
-        if not filename.endswith(".sql"):
-            filename = f"{filename}.sql"
-
-        file_path = cls.SQL_DIR / filename
-
-        if not file_path.exists():
-            logger.error(f"SQL file not found: {file_path}")
-            raise FileNotFoundError(f"SQL file not found: {file_path}")
-
-        with open(file_path) as f:
-            sql = f.read().strip()
-            logger.debug(f"Loaded SQL file: {filename} ({len(sql)} chars)")
-            return sql
-
     def get_schemas_query(self) -> str:
-        """
-        Get SQL query to list all schemas with their sizes and table counts.
-
-        Returns:
-            str: SQL query for listing schemas
-        """
-        logger.debug("Getting schemas query")
-        return self.load_sql("get_schemas")
+        """Get a query to list all schemas."""
+        return self.sql_loader.get_schemas_query()
 
     def get_tables_query(self, schema_name: str) -> str:
-        """
-        Get SQL query to list all tables in a schema.
-
-        Args:
-            schema_name: Name of the schema
-
-        Returns:
-            str: SQL query for listing tables
-        """
-        logger.debug(f"Getting tables query for schema: {schema_name}")
-        sql = self.load_sql("get_tables")
-        return sql.format(schema_name=schema_name)
+        """Get a query to list all tables in a schema."""
+        return self.sql_loader.get_tables_query(schema_name)
 
     def get_table_schema_query(self, schema_name: str, table: str) -> str:
-        """
-        Get SQL query to get detailed table schema.
-
-        Args:
-            schema_name: Name of the schema
-            table: Name of the table
-
-        Returns:
-            str: SQL query for getting table schema
-        """
-        logger.debug(f"Getting table schema query for {schema_name}.{table}")
-        sql = self.load_sql("get_table_schema")
-        return sql.format(schema_name=schema_name, table=table)
+        """Get a query to get the schema of a table."""
+        return self.sql_loader.get_table_schema_query(schema_name, table)
 
     def get_migrations_query(
         self, limit: int = 50, offset: int = 0, name_pattern: str = "", include_full_queries: bool = False
     ) -> str:
-        """
-        Get a query to retrieve migrations from Supabase with filtering and pagination.
-
-        Args:
-            limit: Maximum number of migrations to return (default: 50)
-            offset: Number of migrations to skip (for pagination)
-            name_pattern: Optional pattern to filter migrations by name
-            include_full_queries: Whether to include the full SQL statements in the result
-
-        Returns:
-            str: SQL query to get migrations with the specified filters
-        """
-        logger.debug(f"Getting migrations query with limit={limit}, offset={offset}, name_pattern='{name_pattern}'")
-        sql = self.load_sql("get_migrations")
-
-        # Sanitize inputs to prevent SQL injection
-        sanitized_limit = max(1, min(100, limit))  # Limit between 1 and 100
-        sanitized_offset = max(0, offset)
-        sanitized_name_pattern = name_pattern.replace("'", "''")  # Escape single quotes
-
-        # Format the SQL query with the parameters
-        return sql.format(
-            limit=sanitized_limit,
-            offset=sanitized_offset,
-            name_pattern=sanitized_name_pattern,
-            include_full_queries="true" if include_full_queries else "false",
+        """Get a query to list migrations."""
+        return self.sql_loader.get_migrations_query(
+            limit=limit, offset=offset, name_pattern=name_pattern, include_full_queries=include_full_queries
         )