pg_sql_triggers 1.0.1 → 1.1.1

data/lib/pg_sql_triggers/migrator/pre_apply_diff_reporter.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  class Migrator
+    # Formats pre-apply comparison results into human-readable diff reports
+    class PreApplyDiffReporter
+      class << self
+        # Format diff result as a string report
+        def format(diff_result, migration_name: nil)
+          return "No differences detected. Migration is safe to apply." unless diff_result[:has_differences]
+
+          output = []
+          output << ("=" * 80)
+          output << "Pre-Apply Comparison Report"
+          output << "Migration: #{migration_name}" if migration_name
+          output << ("=" * 80)
+          output << ""
+
+          # Report on functions
+          if diff_result[:functions].any?
+            output << "Functions:"
+            output << ("-" * 80)
+            diff_result[:functions].each do |func_diff|
+              output.concat(format_function_diff(func_diff))
+              output << ""
+            end
+          end
+
+          # Report on triggers
+          if diff_result[:triggers].any?
+            output << "Triggers:"
+            output << ("-" * 80)
+            diff_result[:triggers].each do |trigger_diff|
+              output.concat(format_trigger_diff(trigger_diff))
+              output << ""
+            end
+          end
+
+          # Report on drops (for down migrations)
+          if diff_result[:drops]&.any?
+            output << "Drops:"
+            output << ("-" * 80)
+            diff_result[:drops].each do |drop|
+              output << "  - Will #{drop[:type] == :trigger ? 'drop trigger' : 'drop function'}: #{drop[:name]}"
+            end
+            output << ""
+          end
+
+          output << ("=" * 80)
+          output << ""
+          output << "⚠️  WARNING: This migration will modify existing database objects."
+          output << "Review the differences above before proceeding."
+
+          output.join("\n")
+        end
+
+        # Format a concise summary for console output
+        def format_summary(diff_result)
+          return "✓ No differences - safe to apply" unless diff_result[:has_differences]
+
+          summary = []
+          summary << "⚠️  Differences detected:"
+
+          new_count = diff_result[:functions].count { |f| f[:status] == :new } +
+                      diff_result[:triggers].count { |t| t[:status] == :new }
+          modified_count = diff_result[:functions].count { |f| f[:status] == :modified } +
+                           diff_result[:triggers].count { |t| t[:status] == :modified }
+
+          summary << "  - #{new_count} new object(s) will be created"
+          summary << "  - #{modified_count} existing object(s) will be modified"
+
+          summary.join("\n")
+        end
+
+        private
+
+        def format_function_diff(func_diff)
+          case func_diff[:status]
+          when :new
+            [
+              "  Function: #{func_diff[:function_name]}",
+              "    Status: NEW (will be created)"
+            ]
+          when :modified
+            [
+              "  Function: #{func_diff[:function_name]}",
+              "    Status: MODIFIED (will overwrite existing function)",
+              "    Expected:",
+              indent_text(func_diff[:expected], 6),
+              "    Current:",
+              indent_text(func_diff[:actual], 6)
+            ]
+          when :unchanged
+            [
+              "  Function: #{func_diff[:function_name]}",
+              "    Status: UNCHANGED"
+            ]
+          else
+            [
+              "  Function: #{func_diff[:function_name]}",
+              "    Status: #{func_diff[:status]}"
+            ]
+          end
+        end
+
+        def format_trigger_diff(trigger_diff)
+          output = []
+          output << "  Trigger: #{trigger_diff[:trigger_name]}"
+          case trigger_diff[:status]
+          when :new
+            output << "    Status: NEW (will be created)"
+            output << "    Definition:"
+            output << indent_text(trigger_diff[:expected], 6)
+          when :modified
+            output << "    Status: MODIFIED (will overwrite existing trigger)"
+
+            if trigger_diff[:differences]&.any?
+              output << "    Differences:"
+              trigger_diff[:differences].each do |diff|
+                output << "      - #{diff}"
+              end
+            end
+
+            output << "    Expected:"
+            output << indent_text(trigger_diff[:expected], 6)
+            output << "    Current:"
+            output << indent_text(trigger_diff[:actual], 6)
+          when :unchanged
+            output << "    Status: UNCHANGED"
+          else
+            output << "    Status: #{trigger_diff[:status]}"
+          end
+          output
+        end
+
+        def indent_text(text, spaces)
+          indent = " " * spaces
+          text.to_s.lines.map { |line| "#{indent}#{line.chomp}" }.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/pg_sql_triggers/migrator/safety_validator.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require_relative "../drift/db_queries"
+
+module PgSqlTriggers
+  class Migrator
+    # Validates that migrations don't blindly DROP + CREATE objects
+    # This ensures safety by detecting unsafe patterns and blocking them
+    class SafetyValidator
+      # Error raised when unsafe DROP + CREATE operations are detected
+      class UnsafeOperationError < PgSqlTriggers::UnsafeMigrationError
+        def initialize(message, violations)
+          super(message)
+          @violations = violations
+        end
+
+        attr_reader :violations
+
+        def violation_summary
+          @violations.map { |v| "  - #{v[:message]}" }.join("\n")
+        end
+      end
+
+      class << self
+        # Validate that a migration doesn't perform unsafe DROP + CREATE operations
+        # Raises UnsafeOperationError if unsafe patterns are detected
+        def validate!(migration_instance, direction: :up, allow_unsafe: false)
+          return if allow_unsafe
+
+          violations = detect_unsafe_patterns(migration_instance, direction)
+          return if violations.empty?
+
+          error_message = build_error_message(violations, migration_instance.class.name)
+          raise UnsafeOperationError.new(error_message, violations)
+        end
+
+        # Detect unsafe patterns in migration SQL
+        # Returns array of violation hashes
+        def detect_unsafe_patterns(migration_instance, direction)
+          violations = []
+
+          # Capture SQL that would be executed
+          captured_sql = capture_sql(migration_instance, direction)
+
+          # Parse SQL to detect unsafe patterns
+          sql_operations = parse_sql_operations(captured_sql)
+
+          # Check for explicit DROP + CREATE patterns (the main safety concern)
+          violations.concat(detect_drop_create_patterns(sql_operations))
+
+          violations
+        end
+
+        private
+
+        # Capture SQL that would be executed by the migration
+        def capture_sql(migration_instance, direction)
+          captured = []
+
+          # Override execute to capture SQL instead of executing
+          migration_instance.define_singleton_method(:execute) do |sql|
+            captured << sql.to_s.strip
+          end
+
+          # Call the migration method (up or down) to capture SQL
+          migration_instance.public_send(direction)
+
+          captured
+        end
+
+        # Parse SQL into structured operations
+        def parse_sql_operations(sql_array)
+          operations = {
+            drops: [],
+            creates: [],
+            replaces: []
+          }
+
+          sql_array.each do |sql|
+            sql_normalized = sql.squish
+
+            # Parse DROP statements
+            if sql_normalized.match?(/DROP\s+(TRIGGER|FUNCTION)/i)
+              drop_info = parse_drop(sql)
+              operations[:drops] << drop_info if drop_info
+            end
+
+            # Parse CREATE statements (without OR REPLACE)
+            if sql_normalized.match?(/CREATE\s+(?!OR\s+REPLACE)(TRIGGER|FUNCTION)/i)
+              create_info = parse_create(sql)
+              operations[:creates] << create_info if create_info
+            end
+
+            # Parse CREATE OR REPLACE statements
+            # (only for functions - PostgreSQL doesn't support CREATE OR REPLACE TRIGGER)
+            if sql_normalized.match?(/CREATE\s+OR\s+REPLACE\s+FUNCTION/i)
+              replace_info = parse_replace(sql)
+              operations[:replaces] << replace_info if replace_info
+            end
+          end
+
+          operations
+        end
+
+        # Parse DROP SQL statement
+        def parse_drop(sql)
+          if sql.match?(/DROP\s+TRIGGER/i)
+            match = sql.match(/DROP\s+TRIGGER\s+(?:IF\s+EXISTS\s+)?(\w+)\s+ON\s+(\w+)/i)
+            return nil unless match
+
+            {
+              type: :trigger,
+              name: match[1],
+              table_name: match[2],
+              sql: sql
+            }
+          elsif sql.match?(/DROP\s+FUNCTION/i)
+            match = sql.match(/DROP\s+FUNCTION\s+(?:IF\s+EXISTS\s+)?(\w+)\s*\(\)?/i)
+            return nil unless match
+
+            {
+              type: :function,
+              name: match[1],
+              sql: sql
+            }
+          end
+        end
+
+        # Parse CREATE SQL statement (without OR REPLACE)
+        def parse_create(sql)
+          if sql.match?(/CREATE\s+TRIGGER/i)
+            match = sql.match(/CREATE\s+TRIGGER\s+(\w+)\s+.*?\s+ON\s+(\w+)/i)
+            return nil unless match
+
+            {
+              type: :trigger,
+              name: match[1],
+              table_name: match[2],
+              sql: sql
+            }
+          elsif sql.match?(/CREATE\s+FUNCTION/i)
+            match = sql.match(/CREATE\s+FUNCTION\s+(\w+)\s*\([^)]*\)/i)
+            return nil unless match
+
+            # Extract function body for comparison
+            body_match = sql.match(/\$\$(.+?)\$\$/m) || sql.match(/AS\s+(.+)/im)
+            function_body = body_match ? body_match[1].strip : sql
+
+            {
+              type: :function,
+              name: match[1],
+              function_body: function_body,
+              sql: sql
+            }
+          end
+        end
+
+        # Parse CREATE OR REPLACE SQL statement (only for functions)
+        def parse_replace(sql)
+          # PostgreSQL doesn't support CREATE OR REPLACE TRIGGER, only functions
+          return unless sql.match?(/CREATE\s+OR\s+REPLACE\s+FUNCTION/i)
+
+          match = sql.match(/CREATE\s+OR\s+REPLACE\s+FUNCTION\s+(\w+)\s*\([^)]*\)/i)
+          return nil unless match
+
+          # Extract function body for comparison
+          body_match = sql.match(/\$\$(.+?)\$\$/m) || sql.match(/AS\s+(.+)/im)
+          function_body = body_match ? body_match[1].strip : sql
+
+          {
+            type: :function,
+            name: match[1],
+            function_body: function_body,
+            sql: sql
+          }
+        end
+
+        # Detect explicit DROP + CREATE patterns
+        # This is unsafe because it drops existing objects and recreates them without validation
+        def detect_drop_create_patterns(operations)
+          violations = []
+
+          # Check if any DROP is followed by a CREATE of the same object
+          operations[:drops].each do |drop|
+            matching_create = operations[:creates].find do |create|
+              type_match = create[:type] == drop[:type]
+              name_match = create[:name] == drop[:name]
+              # For triggers, also match on table_name
+              table_match = if drop[:type] == :trigger
+                              create[:table_name] == drop[:table_name]
+                            else
+                              true # Functions don't have table_name
+                            end
+              type_match && name_match && table_match
+            end
+
+            next unless matching_create
+
+            object_type = drop[:type] == :trigger ? "trigger" : "function"
+            existing_object = case drop[:type]
+                              when :function
+                                function_exists?(drop[:name])
+                              when :trigger
+                                trigger_exists?(drop[:name])
+                              end
+
+            # Only flag as unsafe if the object actually exists
+            next unless existing_object
+
+            violations << {
+              type: :drop_create_pattern,
+              message: "Unsafe DROP + CREATE pattern detected for #{object_type} '#{drop[:name]}'. " \
+                       "Migration will drop existing #{object_type} and recreate it. " \
+                       "For functions, use CREATE OR REPLACE FUNCTION instead. " \
+                       "For triggers, drop and recreate is sometimes necessary, but ensure this is intentional.",
+              drop_sql: drop[:sql],
+              create_sql: matching_create[:sql],
+              object_name: drop[:name],
+              object_type: drop[:type]
+            }
+          end
+
+          violations
+        end
+
+        # Check if function exists in database
+        def function_exists?(function_name)
+          Drift::DbQueries.find_function(function_name).present?
+        end
+
+        # Check if trigger exists in database
+        def trigger_exists?(trigger_name)
+          Drift::DbQueries.find_trigger(trigger_name).present?
+        end
+
+        # Build error message from violations
+        def build_error_message(violations, migration_class_name)
+          message = []
+          message << ("=" * 80)
+          message << "UNSAFE MIGRATION DETECTED"
+          message << "Migration: #{migration_class_name}"
+          message << ("=" * 80)
+          message << ""
+          message << "The migration contains unsafe DROP + CREATE operations that would:"
+          message << ""
+          message << violations.map { |v| "  - #{v[:message]}" }.join("\n")
+          message << ""
+          message << "To proceed despite these warnings, set ALLOW_UNSAFE_MIGRATIONS=true"
+          message << "or configure pg_sql_triggers to allow unsafe operations."
+          message << ""
+          message << ("=" * 80)
+
+          message.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/pg_sql_triggers/migrator.rb

@@ -3,8 +3,12 @@
 require "ostruct"
 require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/module/delegation"
+require_relative "migrator/pre_apply_comparator"
+require_relative "migrator/pre_apply_diff_reporter"
+require_relative "migrator/safety_validator"
 
 module PgSqlTriggers
+  # rubocop:disable Metrics/ClassLength
   class Migrator
     MIGRATIONS_TABLE_NAME = "trigger_migrations"
 
@@ -158,6 +162,7 @@ module PgSqlTriggers
         end
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def run_migration(migration, direction)
         require migration.path
 
@@ -186,7 +191,58 @@ module PgSqlTriggers
           end
         end
 
+        # Perform safety validation (prevent unsafe DROP + CREATE operations)
+        validation_instance = migration_class.new
+        begin
+          allow_unsafe = ENV["ALLOW_UNSAFE_MIGRATIONS"] == "true" ||
+                         (defined?(PgSqlTriggers) && PgSqlTriggers.allow_unsafe_migrations == true)
+
+          SafetyValidator.validate!(validation_instance, direction: direction, allow_unsafe: allow_unsafe)
+        rescue SafetyValidator::UnsafeOperationError => e
+          # Safety validation failed - block the migration
+          error_msg = "\n#{e.message}\n\n"
+          Rails.logger.error(error_msg) if defined?(Rails.logger)
+          Rails.logger.debug error_msg if ENV["VERBOSE"] != "false" || defined?(Rails::Console)
+          raise StandardError, "Migration blocked due to unsafe DROP + CREATE operations. " \
+                               "Review the errors above and set ALLOW_UNSAFE_MIGRATIONS=true if you must proceed."
+        rescue StandardError => e
+          # Don't fail the migration if validation fails for other reasons - just log it
+          if defined?(Rails.logger)
+            Rails.logger.warn("Safety validation failed for migration #{migration.name}: #{e.message}")
+          end
+        end
+
+        # Perform pre-apply comparison (diff expected vs actual)
+        # Create a separate instance for comparison to avoid side effects
+        comparison_instance = migration_class.new
+        begin
+          diff_result = PreApplyComparator.compare(comparison_instance, direction: direction)
+
+          # Log the comparison result
+          if diff_result[:has_differences]
+            diff_report = PreApplyDiffReporter.format(diff_result, migration_name: migration.name)
+            if defined?(Rails.logger)
+              Rails.logger.warn("Pre-apply comparison for migration #{migration.name}:\n#{diff_report}")
+            end
+
+            # In verbose mode or when called from console, print the diff
+            if ENV["VERBOSE"] != "false" || defined?(Rails::Console)
+              Rails.logger.debug { "\n#{PreApplyDiffReporter.format_summary(diff_result)}\n" }
+            end
+          elsif defined?(Rails.logger)
+            Rails.logger.info(
+              "Pre-apply comparison: No differences detected for migration #{migration.name}"
+            )
+          end
+        rescue StandardError => e
+          # Don't fail the migration if comparison fails - just log it
+          if defined?(Rails.logger)
+            Rails.logger.warn("Pre-apply comparison failed for migration #{migration.name}: #{e.message}")
+          end
+        end
+
         ActiveRecord::Base.transaction do
+          # Create a fresh instance for actual execution
           migration_instance = migration_class.new
           migration_instance.public_send(direction)
 
@@ -211,6 +267,7 @@ module PgSqlTriggers
         raise StandardError,
               "Error running trigger migration #{migration.filename}: #{e.message}\n#{e.backtrace.first(5).join("\n")}"
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       def status
         ensure_migrations_table!
@@ -258,4 +315,5 @@ module PgSqlTriggers
       end
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/pg_sql_triggers/registry/manager.rb

@@ -4,9 +4,40 @@ module PgSqlTriggers
   module Registry
     class Manager
       class << self
+        # Request-level cache to avoid N+1 queries when loading multiple trigger files
+        # This cache is cleared after each request/transaction to ensure data consistency
+        def _registry_cache
+          @_registry_cache ||= {}
+        end
+
+        def _clear_registry_cache
+          @_registry_cache = {}
+        end
+
+        # Batch load existing triggers into cache to avoid N+1 queries
+        # Call this before registering multiple triggers for better performance
+        def preload_triggers(trigger_names)
+          return if trigger_names.empty?
+
+          # Find all triggers that aren't already cached
+          uncached_names = trigger_names - _registry_cache.keys
+          return if uncached_names.empty?
+
+          # Batch load all uncached triggers in a single query
+          PgSqlTriggers::TriggerRegistry.where(trigger_name: uncached_names).find_each do |trigger|
+            _registry_cache[trigger.trigger_name] = trigger
+          end
+        end
+
         def register(definition)
           trigger_name = definition.name
-          existing = PgSqlTriggers::TriggerRegistry.find_by(trigger_name: trigger_name)
+
+          # Use cached lookup if available to avoid N+1 queries during trigger file loading
+          existing = _registry_cache[trigger_name] ||=
+            PgSqlTriggers::TriggerRegistry.find_by(trigger_name: trigger_name)
+
+          # Calculate checksum using field-concatenation (consistent with TriggerRegistry model)
+          checksum = calculate_checksum(definition)
 
           attributes = {
             trigger_name: definition.name,
@@ -15,14 +46,28 @@ module PgSqlTriggers
             enabled: definition.enabled,
             source: "dsl",
             environment: definition.environments.join(","),
-            definition: definition.to_h.to_json
+            definition: definition.to_h.to_json,
+            checksum: checksum
           }
 
           if existing
-            existing.update!(attributes)
-            existing
+            begin
+              existing.update!(attributes)
+              # Update cache with the modified record (reload to get fresh data)
+              reloaded = existing.reload
+              _registry_cache[trigger_name] = reloaded
+              reloaded
+            rescue ActiveRecord::RecordNotFound
+              # Cached record was deleted, create a new one
+              new_record = PgSqlTriggers::TriggerRegistry.create!(attributes)
+              _registry_cache[trigger_name] = new_record
+              new_record
+            end
           else
-            PgSqlTriggers::TriggerRegistry.create!(attributes.merge(checksum: "placeholder"))
+            new_record = PgSqlTriggers::TriggerRegistry.create!(attributes)
+            # Cache the newly created record
+            _registry_cache[trigger_name] = new_record
+            new_record
           end
         end
 
@@ -36,10 +81,52 @@ module PgSqlTriggers
 
         delegate :for_table, to: PgSqlTriggers::TriggerRegistry
 
-        def diff
-          # Compare DSL definitions with actual database state
-          # This will be implemented in the Drift::Detector
-          Drift.detect
+        def diff(trigger_name = nil)
+          PgSqlTriggers::Drift.detect(trigger_name)
+        end
+
+        def drifted
+          PgSqlTriggers::Drift::Detector.detect_all.select do |r|
+            r[:state] == PgSqlTriggers::DRIFT_STATE_DRIFTED
+          end
+        end
+
+        def in_sync
+          PgSqlTriggers::Drift::Detector.detect_all.select do |r|
+            r[:state] == PgSqlTriggers::DRIFT_STATE_IN_SYNC
+          end
+        end
+
+        def unknown_triggers
+          PgSqlTriggers::Drift::Detector.detect_all.select do |r|
+            r[:state] == PgSqlTriggers::DRIFT_STATE_UNKNOWN
+          end
+        end
+
+        def dropped
+          PgSqlTriggers::Drift::Detector.detect_all.select do |r|
+            r[:state] == PgSqlTriggers::DRIFT_STATE_DROPPED
+          end
+        end
+
+        private
+
+        def calculate_checksum(definition)
+          # DSL definitions don't have function_body, so use placeholder
+          # Generator forms have function_body, so calculate real checksum
+          function_body_value = definition.respond_to?(:function_body) ? definition.function_body : nil
+          return "placeholder" if function_body_value.blank?
+
+          # Use field-concatenation algorithm (consistent with TriggerRegistry#calculate_checksum)
+          require "digest"
+          Digest::SHA256.hexdigest([
+            definition.name,
+            definition.table_name,
+            definition.version,
+            function_body_value,
+            definition.condition || "",
+            definition.timing || "before"
+          ].join)
         end
       end
     end