pg_sql_triggers 1.0.1 → 1.1.1

data/docs/usage-guide.md

@@ -26,6 +26,7 @@ PgSqlTriggers::DSL.pg_sql_trigger "users_email_validation" do
 
   version 1
   enabled false
+  timing :before
 
   when_env :production
 end
@@ -79,6 +80,14 @@ when_env :production           # Only in production
 when_env :staging, :production # Multiple environments
 ```
 
+#### `timing`
+Specifies when the trigger fires relative to the event (BEFORE or AFTER):
+
+```ruby
+timing :before  # Trigger fires before constraint checks (default)
+timing :after   # Trigger fires after constraint checks
+```
+
 ### Complete Example
 
 ```ruby
@@ -90,11 +99,75 @@ PgSqlTriggers::DSL.pg_sql_trigger "orders_billing_trigger" do
 
   version 2
   enabled true
+  timing :after
 
   when_env :production, :staging
 end
 ```
 
+## Trigger Generator
+
+PgSqlTriggers provides a web-based generator and Rails generators for creating trigger definitions and migrations quickly.
+
+### Web UI Generator
+
+The web UI generator provides a user-friendly interface for creating triggers:
+
+1. Navigate to `/pg_sql_triggers/generator/new` in your browser
+2. Fill in the trigger details:
+   - **Trigger Name**: Lowercase letters, numbers, and underscores only
+   - **Table Name**: The PostgreSQL table to attach the trigger to
+   - **Function Name**: The PostgreSQL function name (must match the function body)
+   - **Timing**: When the trigger fires - BEFORE (before constraint checks) or AFTER (after constraint checks)
+   - **Events**: Select one or more events (INSERT, UPDATE, DELETE, TRUNCATE)
+   - **Function Body**: The complete PostgreSQL function definition
+   - **Version**: Starting version number (default: 1)
+   - **Enabled**: Whether the trigger should be enabled initially
+   - **Environments**: Optional environment restrictions
+   - **Condition**: Optional WHEN condition for the trigger
+3. Preview the generated DSL and migration code (includes timing and condition display)
+4. Create the trigger files
+
+The generator creates:
+- A DSL definition file in `app/triggers/`
+- A migration file in `db/triggers/`
+- A registry entry in the database
+
+### Rails Generators
+
+You can also use Rails generators to create trigger migrations:
+
+```bash
+# Generate a trigger migration
+rails generate trigger:migration add_user_validation
+
+# Or using the full namespace
+rails generate pg_sql_triggers:trigger_migration add_user_validation
+```
+
+This creates a migration file in `db/triggers/` that you can edit to add your trigger logic.
+
+### Generator Features
+
+The generator handles:
+- **Function Name Formatting**: Automatically quotes function names with special characters
+- **Multiple Environments**: Supports multiple environment restrictions
+- **Condition Escaping**: Properly escapes quotes in WHEN conditions
+- **Event Combinations**: Handles single or multiple events (INSERT, UPDATE, DELETE, TRUNCATE)
+- **Migration Numbering**: Automatically generates sequential migration numbers
+- **Error Handling**: Graceful error handling with detailed error messages
+
+### Generator Edge Cases
+
+The generator properly handles:
+- Function names with special characters (quoted vs unquoted)
+- Multiple environments in a single trigger
+- Complex WHEN conditions with quotes
+- All event type combinations
+- Standalone gem usage (without Rails context)
+- Migration number collisions
+- Blank events and environments (filtered automatically)
+
 ## Trigger Migrations
 
 Trigger migrations work similarly to Rails schema migrations but are specifically for PostgreSQL triggers and functions.

data/docs/web-ui.md

@@ -289,6 +289,20 @@ end
 ![Main Dashboard](screenshots/dashboard.png)
 
 ### Trigger Generator
+
+The trigger generator provides a comprehensive form for creating triggers:
+
+1. **Basic Information**: Trigger name, table name, function name, and function body
+2. **Trigger Events**: Select timing (BEFORE/AFTER) and events (INSERT, UPDATE, DELETE, TRUNCATE)
+3. **Configuration**: Version, environments, WHEN condition, and enabled state
+4. **Preview**: Review generated DSL and migration code with timing and condition information
+
+The preview page displays:
+- Generated DSL code with timing
+- Trigger configuration summary (timing, events, table, function, condition)
+- PL/pgSQL function body (editable)
+- SQL validation results
+
 ![Trigger Generator](screenshots/generator.png)
 
 ### Migration Management

data/lib/generators/pg_sql_triggers/templates/README

@@ -31,6 +31,6 @@ Next steps:
 
 5. Visit http://localhost:3000/pg_sql_triggers to access the UI
 
-For more information, see: https://github.com/samaswin87/pg_sql_triggers
+For more information, see: https://github.com/samaswin/pg_sql_triggers
 
 ===============================================================================

data/lib/generators/pg_sql_triggers/templates/create_pg_sql_triggers_tables.rb

@@ -14,6 +14,7 @@ class CreatePgSqlTriggersTables < ActiveRecord::Migration[6.1]
       t.text :definition # Stored DSL or SQL definition
       t.text :function_body # The actual function body
       t.text :condition # Optional WHEN clause condition
+      t.string :timing, default: "before", null: false # Trigger timing: before or after
       t.datetime :installed_at
       t.datetime :last_verified_at
 
@@ -25,6 +26,7 @@ class CreatePgSqlTriggersTables < ActiveRecord::Migration[6.1]
     add_index :pg_sql_triggers_registry, :enabled
     add_index :pg_sql_triggers_registry, :source
     add_index :pg_sql_triggers_registry, :environment
+    add_index :pg_sql_triggers_registry, :timing
 
     # Trigger migrations table - tracks which trigger migrations have been run
     create_table :trigger_migrations do |t|

data/lib/generators/pg_sql_triggers/templates/initializer.rb

@@ -58,4 +58,12 @@ PgSqlTriggers.configure do |config|
   # Add additional tables you want to exclude:
   # config.excluded_tables = %w[audit_logs temporary_data]
   config.excluded_tables = []
+
+  # ========== Migration Safety Configuration ==========
+  # Prevent unsafe DROP + CREATE operations in migrations
+  # When false (default), migrations with DROP + CREATE patterns will be blocked
+  # Set to true to allow unsafe operations (not recommended)
+  # You can also override per-migration with ALLOW_UNSAFE_MIGRATIONS=true environment variable
+  # Default: false (recommended for safety)
+  config.allow_unsafe_migrations = false
 end

data/lib/pg_sql_triggers/drift/db_queries.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  module Drift
+    module DbQueries
+      class << self
+        # Fetch all triggers from database
+        def all_triggers
+          sql = <<~SQL.squish
+            SELECT
+              t.oid AS trigger_oid,
+              t.tgname AS trigger_name,
+              c.relname AS table_name,
+              n.nspname AS schema_name,
+              p.proname AS function_name,
+              pg_get_triggerdef(t.oid) AS trigger_definition,
+              pg_get_functiondef(p.oid) AS function_definition,
+              t.tgenabled AS enabled,
+              t.tgisinternal AS is_internal
+            FROM pg_trigger t
+            JOIN pg_class c ON t.tgrelid = c.oid
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            JOIN pg_proc p ON t.tgfoid = p.oid
+            WHERE NOT t.tgisinternal
+              AND n.nspname = 'public'
+              AND t.tgname NOT LIKE 'RI_%'
+            ORDER BY c.relname, t.tgname;
+          SQL
+
+          execute_query(sql)
+        end
+
+        # Fetch single trigger
+        def find_trigger(trigger_name)
+          sql = <<~SQL.squish
+            SELECT
+              t.oid AS trigger_oid,
+              t.tgname AS trigger_name,
+              c.relname AS table_name,
+              n.nspname AS schema_name,
+              p.proname AS function_name,
+              pg_get_triggerdef(t.oid) AS trigger_definition,
+              pg_get_functiondef(p.oid) AS function_definition,
+              t.tgenabled AS enabled,
+              t.tgisinternal AS is_internal
+            FROM pg_trigger t
+            JOIN pg_class c ON t.tgrelid = c.oid
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            JOIN pg_proc p ON t.tgfoid = p.oid
+            WHERE t.tgname = $1
+              AND NOT t.tgisinternal
+              AND n.nspname = 'public';
+          SQL
+
+          result = execute_query(sql, [trigger_name])
+          result.first
+        end
+
+        # Fetch triggers for a specific table
+        def find_triggers_for_table(table_name)
+          sql = <<~SQL.squish
+            SELECT
+              t.oid AS trigger_oid,
+              t.tgname AS trigger_name,
+              c.relname AS table_name,
+              n.nspname AS schema_name,
+              p.proname AS function_name,
+              pg_get_triggerdef(t.oid) AS trigger_definition,
+              pg_get_functiondef(p.oid) AS function_definition,
+              t.tgenabled AS enabled,
+              t.tgisinternal AS is_internal
+            FROM pg_trigger t
+            JOIN pg_class c ON t.tgrelid = c.oid
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            JOIN pg_proc p ON t.tgfoid = p.oid
+            WHERE c.relname = $1
+              AND NOT t.tgisinternal
+              AND n.nspname = 'public'
+              AND t.tgname NOT LIKE 'RI_%'
+            ORDER BY t.tgname;
+          SQL
+
+          execute_query(sql, [table_name])
+        end
+
+        # Fetch function body by function name
+        def find_function(function_name)
+          sql = <<~SQL.squish
+            SELECT
+              p.proname AS function_name,
+              pg_get_functiondef(p.oid) AS function_definition
+            FROM pg_proc p
+            JOIN pg_namespace n ON p.pronamespace = n.oid
+            WHERE p.proname = $1
+              AND n.nspname = 'public';
+          SQL
+
+          result = execute_query(sql, [function_name])
+          result.first
+        end
+
+        private
+
+        def execute_query(sql, params = [])
+          if params.any?
+            # Use ActiveRecord's connection to execute parameterized queries
+            result = ActiveRecord::Base.connection.exec_query(sql, "SQL", params)
+            result.to_a
+          else
+            ActiveRecord::Base.connection.execute(sql).to_a
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_sql_triggers/drift/detector.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "db_queries"
+
+module PgSqlTriggers
+  module Drift
+    class Detector
+      class << self
+        # Detect drift for a single trigger
+        def detect(trigger_name)
+          registry_entry = TriggerRegistry.find_by(trigger_name: trigger_name)
+          db_trigger = DbQueries.find_trigger(trigger_name)
+
+          # State 1: DISABLED - Registry entry disabled
+          return disabled_state(registry_entry, db_trigger) if registry_entry&.enabled == false
+
+          # State 2: MANUAL_OVERRIDE - Marked as manual SQL
+          return manual_override_state(registry_entry, db_trigger) if registry_entry&.source == "manual_sql"
+
+          # State 3: DROPPED - Registry entry exists, DB trigger missing
+          return dropped_state(registry_entry) if registry_entry && !db_trigger
+
+          # State 4: UNKNOWN - DB trigger exists, no registry entry
+          return unknown_state(db_trigger) if !registry_entry && db_trigger
+
+          # State 5: DRIFTED - Checksum mismatch
+          if registry_entry && db_trigger
+            checksum_match = checksums_match?(registry_entry, db_trigger)
+            return drifted_state(registry_entry, db_trigger) unless checksum_match
+          end
+
+          # State 6: IN_SYNC - Everything matches
+          in_sync_state(registry_entry, db_trigger)
+        end
+
+        # Detect drift for all triggers
+        def detect_all
+          registry_entries = TriggerRegistry.all.to_a
+          db_triggers = DbQueries.all_triggers
+
+          # Check each registry entry
+          results = registry_entries.map do |entry|
+            detect(entry.trigger_name)
+          end
+
+          # Find unknown (external) triggers not in registry
+          registry_trigger_names = registry_entries.map(&:trigger_name)
+          db_triggers.each do |db_trigger|
+            next if registry_trigger_names.include?(db_trigger["trigger_name"])
+
+            results << unknown_state(db_trigger)
+          end
+
+          results
+        end
+
+        # Detect drift for a specific table
+        def detect_for_table(table_name)
+          registry_entries = TriggerRegistry.for_table(table_name).to_a
+          db_triggers = DbQueries.find_triggers_for_table(table_name)
+
+          # Check each registry entry for this table
+          results = registry_entries.map do |entry|
+            detect(entry.trigger_name)
+          end
+
+          # Find unknown triggers on this table
+          registry_trigger_names = registry_entries.map(&:trigger_name)
+          db_triggers.each do |db_trigger|
+            next if registry_trigger_names.include?(db_trigger["trigger_name"])
+
+            results << unknown_state(db_trigger)
+          end
+
+          results
+        end
+
+        private
+
+        # Compare registry checksum with calculated DB checksum
+        def checksums_match?(registry_entry, db_trigger)
+          db_checksum = calculate_db_checksum(registry_entry, db_trigger)
+          registry_entry.checksum == db_checksum
+        end
+
+        # Calculate checksum from DB trigger (must match registry algorithm)
+        def calculate_db_checksum(registry_entry, db_trigger)
+          # Extract function body from the function definition
+          function_body = extract_function_body(db_trigger)
+
+          # Extract condition from trigger definition
+          condition = extract_trigger_condition(db_trigger)
+
+          # Use same algorithm as TriggerRegistry#calculate_checksum
+          Digest::SHA256.hexdigest([
+            registry_entry.trigger_name,
+            registry_entry.table_name,
+            registry_entry.version,
+            function_body || "",
+            condition || ""
+          ].join)
+        end
+
+        # Extract function body from pg_get_functiondef output
+        def extract_function_body(db_trigger)
+          function_def = db_trigger["function_definition"]
+          return nil unless function_def
+
+          # The function definition includes CREATE OR REPLACE FUNCTION header
+          # We need to extract just the body for comparison
+          # For now, return the full definition
+          # TODO: Parse and extract just the body if needed
+          function_def
+        end
+
+        # Extract WHEN condition from trigger definition
+        def extract_trigger_condition(db_trigger)
+          trigger_def = db_trigger["trigger_definition"]
+          return nil unless trigger_def
+
+          # Extract WHEN clause from trigger definition
+          # Example: "... WHEN ((new.email IS NOT NULL)) EXECUTE ..."
+          match = trigger_def.match(/WHEN\s+\((.+?)\)\s+EXECUTE/i)
+          match ? match[1].strip : nil
+        end
+
+        # State helper methods
+        def disabled_state(registry_entry, db_trigger)
+          {
+            state: PgSqlTriggers::DRIFT_STATE_DISABLED,
+            registry_entry: registry_entry,
+            db_trigger: db_trigger,
+            details: "Trigger is disabled in registry"
+          }
+        end
+
+        def manual_override_state(registry_entry, db_trigger)
+          {
+            state: PgSqlTriggers::DRIFT_STATE_MANUAL_OVERRIDE,
+            registry_entry: registry_entry,
+            db_trigger: db_trigger,
+            details: "Trigger marked as manual SQL override"
+          }
+        end
+
+        def dropped_state(registry_entry)
+          {
+            state: PgSqlTriggers::DRIFT_STATE_DROPPED,
+            registry_entry: registry_entry,
+            db_trigger: nil,
+            details: "Trigger exists in registry but not in database"
+          }
+        end
+
+        def unknown_state(db_trigger)
+          {
+            state: PgSqlTriggers::DRIFT_STATE_UNKNOWN,
+            registry_entry: nil,
+            db_trigger: db_trigger,
+            details: "Trigger exists in database but not in registry (external)"
+          }
+        end
+
+        def drifted_state(registry_entry, db_trigger)
+          {
+            state: PgSqlTriggers::DRIFT_STATE_DRIFTED,
+            registry_entry: registry_entry,
+            db_trigger: db_trigger,
+            checksum_match: false,
+            details: "Trigger has drifted (checksum mismatch between registry and database)"
+          }
+        end
+
+        def in_sync_state(registry_entry, db_trigger)
+          {
+            state: PgSqlTriggers::DRIFT_STATE_IN_SYNC,
+            registry_entry: registry_entry,
+            db_trigger: db_trigger,
+            checksum_match: true,
+            details: "Trigger matches registry (in sync)"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/pg_sql_triggers/drift/reporter.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require_relative "detector"
+
+module PgSqlTriggers
+  module Drift
+    class Reporter
+      class << self
+        # Generate a summary report
+        def summary
+          results = Detector.detect_all
+
+          {
+            total: results.count,
+            in_sync: results.count { |r| r[:state] == PgSqlTriggers::DRIFT_STATE_IN_SYNC },
+            drifted: results.count { |r| r[:state] == PgSqlTriggers::DRIFT_STATE_DRIFTED },
+            disabled: results.count { |r| r[:state] == PgSqlTriggers::DRIFT_STATE_DISABLED },
+            dropped: results.count { |r| r[:state] == PgSqlTriggers::DRIFT_STATE_DROPPED },
+            unknown: results.count { |r| r[:state] == PgSqlTriggers::DRIFT_STATE_UNKNOWN },
+            manual_override: results.count { |r| r[:state] == PgSqlTriggers::DRIFT_STATE_MANUAL_OVERRIDE }
+          }
+        end
+
+        # Generate detailed report for a trigger
+        def report(trigger_name)
+          result = Detector.detect(trigger_name)
+
+          output = []
+          output << ("=" * 80)
+          output << "Drift Report: #{trigger_name}"
+          output << ("=" * 80)
+          output << ""
+
+          # State
+          output << "State: #{format_state(result[:state])}"
+          output << ""
+
+          # Details
+          output << "Details: #{result[:details]}"
+          output << ""
+
+          # Registry info
+          if result[:registry_entry]
+            output << "Registry Information:"
+            output << "  Table: #{result[:registry_entry].table_name}"
+            output << "  Version: #{result[:registry_entry].version}"
+            output << "  Enabled: #{result[:registry_entry].enabled}"
+            output << "  Source: #{result[:registry_entry].source}"
+            output << "  Checksum: #{result[:registry_entry].checksum}"
+            output << ""
+          end
+
+          # Database info
+          if result[:db_trigger]
+            output << "Database Information:"
+            output << "  Table: #{result[:db_trigger]['table_name']}"
+            output << "  Function: #{result[:db_trigger]['function_name']}"
+            output << "  Enabled: #{result[:db_trigger]['enabled']}"
+            output << ""
+          end
+
+          # If drifted, show diff
+          output << diff(trigger_name) if result[:state] == PgSqlTriggers::DRIFT_STATE_DRIFTED
+
+          output << ("=" * 80)
+
+          output.join("\n")
+        end
+
+        # Generate diff view (expected vs actual)
+        def diff(trigger_name)
+          result = Detector.detect(trigger_name)
+
+          return "No drift detected" if result[:state] != PgSqlTriggers::DRIFT_STATE_DRIFTED
+
+          output = []
+          output << "Drift Comparison:"
+          output << ("-" * 80)
+
+          registry_entry = result[:registry_entry]
+          db_trigger = result[:db_trigger]
+
+          # Version comparison
+          output << "Version:"
+          output << "  Registry: #{registry_entry.version}"
+          output << "  Database: (version not stored in DB)"
+          output << ""
+
+          # Checksum comparison
+          output << "Checksum:"
+          output << "  Registry: #{registry_entry.checksum}"
+          output << "  Database: (calculated from current DB state)"
+          output << ""
+
+          # Function comparison
+          output << "Function:"
+          output << "  Registry Function Body:"
+          output << indent_text(registry_entry.function_body || "(not set)", 4)
+          output << ""
+          output << "  Database Function Definition:"
+          output << indent_text(db_trigger["function_definition"] || "(not found)", 4)
+          output << ""
+
+          # Condition comparison
+          if registry_entry.respond_to?(:condition) && registry_entry.condition.present?
+            output << "Condition:"
+            output << "  Registry: #{registry_entry.condition}"
+            # Extract condition from DB trigger definition
+            trigger_def = db_trigger["trigger_definition"]
+            db_condition = trigger_def.match(/WHEN\s+\((.+?)\)\s+EXECUTE/i)&.[](1)
+            output << "  Database: #{db_condition || '(none)'}"
+            output << ""
+          end
+
+          output << ("-" * 80)
+
+          output.join("\n")
+        end
+
+        # Generate simple text list of drifted triggers
+        def drifted_list
+          results = Detector.detect_all
+          drifted = results.select { |r| r[:state] == PgSqlTriggers::DRIFT_STATE_DRIFTED }
+
+          return "No drifted triggers found" if drifted.empty?
+
+          output = []
+          output << "Drifted Triggers (#{drifted.count}):"
+          output << ""
+
+          drifted.each do |result|
+            entry = result[:registry_entry]
+            output << "  - #{entry.trigger_name} (#{entry.table_name})"
+          end
+
+          output.join("\n")
+        end
+
+        # Generate problematic triggers list (for dashboard)
+        def problematic_list
+          results = Detector.detect_all
+          results.select do |r|
+            [
+              PgSqlTriggers::DRIFT_STATE_DRIFTED,
+              PgSqlTriggers::DRIFT_STATE_DROPPED,
+              PgSqlTriggers::DRIFT_STATE_UNKNOWN
+            ].include?(r[:state])
+          end
+        end
+
+        private
+
+        def format_state(state)
+          case state
+          when PgSqlTriggers::DRIFT_STATE_IN_SYNC
+            "IN SYNC"
+          when PgSqlTriggers::DRIFT_STATE_DRIFTED
+            "DRIFTED"
+          when PgSqlTriggers::DRIFT_STATE_DROPPED
+            "DROPPED"
+          when PgSqlTriggers::DRIFT_STATE_UNKNOWN
+            "UNKNOWN (External)"
+          when PgSqlTriggers::DRIFT_STATE_DISABLED
+            "DISABLED"
+          when PgSqlTriggers::DRIFT_STATE_MANUAL_OVERRIDE
+            "MANUAL OVERRIDE"
+          else
+            "UNKNOWN STATE"
+          end
+        end
+
+        def indent_text(text, spaces)
+          indent = " " * spaces
+          text.to_s.lines.map { |line| "#{indent}#{line}" }.join
+        end
+      end
+    end
+  end
+end

data/lib/pg_sql_triggers/drift.rb

@@ -2,23 +2,26 @@
 
 module PgSqlTriggers
   module Drift
+    autoload :DbQueries, "pg_sql_triggers/drift/db_queries"
     autoload :Detector, "pg_sql_triggers/drift/detector"
     autoload :Reporter, "pg_sql_triggers/drift/reporter"
 
-    # Drift states
-    MANAGED_IN_SYNC = "managed_in_sync"
-    MANAGED_DRIFTED = "managed_drifted"
-    MANUAL_OVERRIDE = "manual_override"
-    DISABLED = "disabled"
-    DROPPED = "dropped"
-    UNKNOWN = "unknown"
-
+    # Convenience method for detecting drift
     def self.detect(trigger_name = nil)
-      Detector.detect(trigger_name)
+      if trigger_name
+        Detector.detect(trigger_name)
+      else
+        Detector.detect_all
+      end
+    end
+
+    # Convenience method for reporting
+    def self.summary
+      Reporter.summary
     end
 
-    def self.report
-      Reporter.report
+    def self.report(trigger_name)
+      Reporter.report(trigger_name)
     end
   end
 end