fix: Fix PostgreSQL migration 014 trigger function syntax error

Fixed critical bug where sqlparser was dropping empty parentheses from
EXECUTE FUNCTION in CREATE TRIGGER statements. PostgreSQL requires ()
after function names in trigger definitions even when there are no parameters.

Migration 014 was failing with "syntax error at or near ';'" due to missing
parentheses in trigger creation. Added automatic detection and restoration
of missing parentheses for EXECUTE FUNCTION statements.

Changes:
- Enhanced migration parsing to handle both CREATE FUNCTION and CREATE TRIGGER sqlparser bugs
- Improved debug logging for migration statement parsing
- Updated migration 014 to use correct PostgreSQL function syntax
- This ensures migration 014 (queue pause functionality) executes correctly in production

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: CodingAnarchy

CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.15.4] - 2025-08-26
+
+### Fixed
+- **🔧 PostgreSQL Migration 014 Trigger Function Syntax Fix**
+  - Fixed critical bug where sqlparser was dropping empty parentheses from `EXECUTE FUNCTION` in CREATE TRIGGER statements
+  - PostgreSQL requires `()` after function names in trigger definitions even when there are no parameters
+  - Migration 014 was failing with "syntax error at or near ';'" due to missing parentheses in trigger creation
+  - Added automatic detection and restoration of missing parentheses for `EXECUTE FUNCTION` statements
+  - Enhanced migration parsing to handle both CREATE FUNCTION and CREATE TRIGGER sqlparser bugs
+  - This fix ensures migration 014 (queue pause functionality) executes correctly in production environments
+  - Improved debug logging for migration statement parsing to aid in future troubleshooting
+
 ## [1.15.3] - 2025-01-25
 
 ### Fixed

Cargo.toml

@@ -9,7 +9,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "1.15.3"
+version = "1.15.4"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/CodingAnarchy/hammerwork"

src/migrations/014_add_queue_pause.postgres.sql

@@ -16,12 +16,13 @@ CREATE INDEX IF NOT EXISTS idx_hammerwork_queue_pause_paused_at ON hammerwork_qu
 
 -- Add function to automatically update the updated_at timestamp
 CREATE OR REPLACE FUNCTION update_hammerwork_queue_pause_updated_at()
-RETURNS TRIGGER AS $$
+RETURNS TRIGGER
+LANGUAGE plpgsql AS $BODY$
 BEGIN
     NEW.updated_at = NOW();
     RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
+END
+$BODY$;
 
 -- Create trigger to automatically update updated_at
 DROP TRIGGER IF EXISTS trigger_update_hammerwork_queue_pause_updated_at ON hammerwork_queue_pause;

src/migrations/postgres.rs

@@ -5,18 +5,26 @@ use crate::Result;
 use chrono::Utc;
 use sqlparser::{dialect::PostgreSqlDialect, parser::Parser};
 use sqlx::{PgPool, Row};
-use tracing::{debug, info, warn};
+use tracing::{debug, error, info, warn};
 
 /// Parse SQL text into individual statements using sqlparser-rs
 /// This properly handles quoted strings, dollar-quoted strings, and comments
 fn parse_sql_statements(
     sql: &str,
 ) -> std::result::Result<Vec<String>, sqlparser::parser::ParserError> {
+    debug!(
+        "parse_sql_statements called with {} characters of SQL",
+        sql.len()
+    );
     let dialect = PostgreSqlDialect {};
 
     // First, try to parse the entire SQL as a series of statements
     match Parser::parse_sql(&dialect, sql) {
         Ok(statements) => {
+            debug!(
+                "Successfully parsed {} statements with sqlparser",
+                statements.len()
+            );
             // Convert parsed statements back to SQL strings
             Ok(statements
                 .iter()
@@ -41,13 +49,44 @@ fn parse_sql_statements(
                         }
                     }
 
+                    // Fix sqlparser bug: it drops empty parentheses from EXECUTE FUNCTION in triggers
+                    // PostgreSQL requires () even when there are no parameters
+                    if sql_string.contains("EXECUTE FUNCTION") {
+                        debug!("Before EXECUTE FUNCTION fix: {}", sql_string);
+                        // Pattern: "EXECUTE FUNCTION function_name" should be "EXECUTE FUNCTION function_name()"
+                        // Note: semicolon might not be present yet since it's added later
+                        if let Some(execute_pos) = sql_string.find("EXECUTE FUNCTION ") {
+                            let after_execute = &sql_string[execute_pos + 17..]; // Skip "EXECUTE FUNCTION "
+
+                            // Find the end of the function name (could be end of line, semicolon, or whitespace)
+                            let end_pos = after_execute
+                                .find(';')
+                                .or_else(|| after_execute.find('\n'))
+                                .unwrap_or(after_execute.len());
+
+                            let function_part = &after_execute[..end_pos];
+                            debug!("Function part: '{}'", function_part.trim());
+
+                            // If function name doesn't end with ), add ()
+                            if !function_part.trim().ends_with(')') {
+                                let insert_pos = execute_pos + 17 + function_part.trim().len();
+                                debug!("Adding () at position {}", insert_pos);
+                                sql_string.insert_str(insert_pos, "()");
+                                debug!("After EXECUTE FUNCTION fix: {}", sql_string);
+                            }
+                        }
+                    }
+
                     format!("{};", sql_string)
                 })
                 .collect())
         }
-        Err(_) => {
+        Err(e) => {
+            error!("sqlparser failed to parse SQL: {}", e);
+            debug!("Failed SQL content: {}", sql);
             // If parsing fails, try to split manually while respecting SQL syntax
             // This is a more conservative approach for complex migrations
+            debug!("Falling back to manual SQL splitting");
             Ok(split_sql_respecting_quotes(sql))
         }
     }
@@ -195,7 +234,16 @@ impl MigrationRunner<sqlx::Postgres> for PostgresMigrationRunner {
 
         // Parse SQL using sqlparser-rs for proper statement splitting
         let statements = match parse_sql_statements(sql) {
-            Ok(stmts) => stmts,
+            Ok(stmts) => {
+                debug!(
+                    "sqlparser-rs successfully parsed {} statements",
+                    stmts.len()
+                );
+                for (i, stmt) in stmts.iter().enumerate() {
+                    debug!("Parsed statement {}: '{}'", i + 1, stmt.trim());
+                }
+                stmts
+            }
             Err(e) => {
                 warn!(
                     "Failed to parse SQL with sqlparser, falling back to naive splitting: {}",
@@ -209,6 +257,15 @@ impl MigrationRunner<sqlx::Postgres> for PostgresMigrationRunner {
             }
         };
 
+        debug!(
+            "Parsed {} statements for migration {}",
+            statements.len(),
+            migration.id
+        );
+        for (i, statement) in statements.iter().enumerate() {
+            debug!("Statement {}: '{}'", i + 1, statement.trim());
+        }
+
         for (i, statement) in statements.iter().enumerate() {
             // Add semicolon back if it was removed by split
             let full_statement = if statement.ends_with(';') {
@@ -218,13 +275,22 @@ impl MigrationRunner<sqlx::Postgres> for PostgresMigrationRunner {
             };
 
             debug!(
-                "Executing statement {} of {} for migration {}",
+                "Executing statement {} of {} for migration {}: {}",
                 i + 1,
                 statements.len(),
-                migration.id
+                migration.id,
+                full_statement
             );
 
-            sqlx::query(&full_statement).execute(&mut *tx).await?;
+            if let Err(e) = sqlx::query(&full_statement).execute(&mut *tx).await {
+                error!(
+                    "Failed to execute statement {}: {} - Error: {}",
+                    i + 1,
+                    full_statement,
+                    e
+                );
+                return Err(e.into());
+            }
         }
 
         tx.commit().await?;