pg_sql_triggers 1.3.0 → 1.5.0

data/lib/pg_sql_triggers/engine.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "schema_dumper_extension"
+require_relative "trigger_structure_dumper"
+
 module PgSqlTriggers
   class Engine < ::Rails::Engine
     isolate_namespace PgSqlTriggers
@@ -25,5 +28,51 @@ module PgSqlTriggers
     rake_tasks do
       load root.join("lib/tasks/trigger_migrations.rake")
     end
+
+    initializer "pg_sql_triggers.schema_integration", before: :load_config_initializers do
+      ActiveSupport.on_load(:active_record) do
+        unless ActiveRecord::SchemaDumper.ancestors.include?(PgSqlTriggers::SchemaDumperExtension)
+          ActiveRecord::SchemaDumper.prepend(PgSqlTriggers::SchemaDumperExtension)
+        end
+      end
+    end
+
+    # Warn at startup if no permission_checker is set in a protected environment.
+    # The default is to allow all actions (including admin-level ones), which is
+    # unsafe in production without an explicit checker configured.
+    config.after_initialize do
+      install_schema_load_trigger_hook
+
+      if PgSqlTriggers.permission_checker.nil? && defined?(Rails) && Rails.env.production?
+        Rails.logger.warn(
+          "[PgSqlTriggers] SECURITY WARNING: No permission_checker is configured. " \
+          "All actions are permitted by default, including admin-level operations " \
+          "(drop_trigger, execute_sql, override_drift). " \
+          "Set PgSqlTriggers.permission_checker in an initializer before deploying to production."
+        )
+      end
+    end
+
+    def self.install_schema_load_trigger_hook
+      return if @schema_load_trigger_hook_installed
+      return unless PgSqlTriggers.migrate_triggers_after_schema_load
+      return if ENV["SKIP_TRIGGER_MIGRATE_AFTER_SCHEMA_LOAD"].present?
+      return unless defined?(Rake::Task)
+
+      if defined?(Rails.application) && Rails.application.respond_to?(:load_tasks)
+        Rails.application.load_tasks
+      end
+
+      return unless Rake::Task.task_defined?("db:schema:load")
+
+      @schema_load_trigger_hook_installed = true
+
+      Rake::Task["db:schema:load"].enhance do
+        next unless PgSqlTriggers.migrate_triggers_after_schema_load
+        next if ENV["SKIP_TRIGGER_MIGRATE_AFTER_SCHEMA_LOAD"].present?
+
+        Rake::Task["trigger:migrate"].invoke
+      end
+    end
   end
 end

data/lib/pg_sql_triggers/events_checksum.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  # Normalizes trigger event lists (including PostgreSQL +UPDATE OF col1, col2+) for checksums so
+  # {TriggerRegistry#calculate_checksum}, {Registry::Manager#calculate_checksum}, and
+  # {Drift::Detector#calculate_db_checksum} stay aligned.
+  module EventsChecksum
+    module_function
+
+    # @param defn [Hash] parsed registry +definition+ JSON (string or symbol keys)
+    # @return [String] canonical token string, or empty when +events+ is missing/empty
+    def canonical_from_definition(defn)
+      hash = stringify(defn)
+      events = Array(hash["events"]).map(&:to_s).map(&:downcase)
+      return "" if events.empty?
+
+      columns = normalized_columns(hash["columns"])
+      build_tokens(events, columns).sort.join("|")
+    end
+
+    # @param definition_json [String, nil]
+    def segment_from_definition_json(definition_json)
+      return "" if definition_json.blank?
+
+      canonical_from_definition(JSON.parse(definition_json))
+    rescue JSON::ParserError
+      ""
+    end
+
+    # @param trigger_def [String] +pg_get_triggerdef+ output
+    def canonical_from_pg_triggerdef(trigger_def)
+      return "" if trigger_def.blank?
+
+      clause = extract_events_clause(trigger_def)
+      return "" if clause.blank?
+
+      parse_events_clause(clause).sort.join("|")
+    end
+
+    # SQL fragment for the event list (e.g. +INSERT OR UPDATE OF "email"+), preserving DSL event order.
+    def events_sql_fragment(defn, quote_column:)
+      hash = stringify(defn)
+      events = Array(hash["events"]).map(&:to_s).map(&:downcase)
+      columns = ordered_columns(hash["columns"])
+      return "INSERT" if events.empty?
+
+      events.map do |ev|
+        if ev == "update" && columns.any?
+          quoted = columns.map { |c| quote_column.call(c) }.join(", ")
+          "UPDATE OF #{quoted}"
+        else
+          ev.upcase
+        end
+      end.join(" OR ")
+    end
+
+    def normalized_columns(raw)
+      ordered_columns(raw).map(&:downcase).sort
+    end
+
+    def ordered_columns(raw)
+      Array(raw).flatten.compact.map { |c| c.to_s.strip }.reject(&:empty?)
+    end
+
+    def build_tokens(events, sorted_lowercase_columns)
+      cols_join = sorted_lowercase_columns.join(",")
+      events.map do |ev|
+        if ev == "update" && cols_join.present?
+          "update:#{cols_join}"
+        else
+          ev
+        end
+      end
+    end
+
+    def extract_events_clause(trigger_def)
+      s = trigger_def.to_s.squish
+      m = s.match(/(?:BEFORE|AFTER|INSTEAD\s+OF)\s+(.+?)\s+ON\s+/i)
+      return "" unless m
+
+      m.captures.first.to_s.strip
+    end
+
+    def parse_events_clause(clause)
+      clause.split(/\s+OR\s+/i).filter_map do |part|
+        part = part.strip
+        next if part.empty?
+
+        um = part.match(/\AUPDATE\s+OF\s+(.+)\z/i)
+        if um
+          cols = um[1].split(",").map { |c| normalize_pg_identifier(c) }.sort
+          "update:#{cols.join(',')}"
+        else
+          part.downcase
+        end
+      end
+    end
+
+    def normalize_pg_identifier(fragment)
+      f = fragment.to_s.strip
+      if f.start_with?('"') && f.end_with?('"') && f.length >= 2
+        f[1...-1].gsub('""', '"').downcase
+      else
+        f.downcase
+      end
+    end
+
+    def stringify(defn)
+      return {} if defn.nil?
+
+      defn.transform_keys(&:to_s)
+    end
+  end
+end

data/lib/pg_sql_triggers/migration.rb

@@ -4,12 +4,11 @@ module PgSqlTriggers
   class Migration < ActiveRecord::Migration[6.1]
     # Base class for trigger migrations
     # Similar to ActiveRecord::Migration but for trigger-specific migrations
-
-    # rubocop:disable Rails/Delegate
-    # delegate doesn't work here due to argument forwarding issues in this context
-    def execute(sql)
-      connection.execute(sql)
+    #
+    # Cannot use `delegate` here: ActiveRecord::Migration defines a class-method
+    # `delegate` (schema DSL) that shadows Module's `delegate` on Rails 8+.
+    def execute(...)
+      connection.execute(...)
     end
-    # rubocop:enable Rails/Delegate
   end
 end

data/lib/pg_sql_triggers/migrator/pre_apply_comparator.rb

@@ -5,32 +5,32 @@ require_relative "../drift/db_queries"
 module PgSqlTriggers
   class Migrator
     # Pre-apply comparator that extracts expected SQL from migrations
-    # and compares it with the current database state
-    # rubocop:disable Metrics/ClassLength
+    # and compares it with the current database state.
+    # rubocop:disable Metrics/ClassLength -- all SQL parsing + diffing lives here so the two
+    # halves (parse migration SQL -> expected state, diff against actual) stay co-located.
     class PreApplyComparator
       class << self
         # Compare expected state from migration with actual database state
         # Returns a comparison result with diff information
         def compare(migration_instance, direction: :up)
-          expected = extract_expected_state(migration_instance, direction)
+          captured_sql = capture_sql(migration_instance, direction)
+          compare_sql(captured_sql)
+        end
+
+        # Compare using pre-captured SQL (avoids re-instantiating the migration class).
+        # Returns a comparison result with diff information.
+        def compare_sql(captured_sql)
+          expected = parse_sql_to_state(captured_sql)
           actual = extract_actual_state(expected)
           generate_diff(expected, actual)
         end
 
         private
 
-        # Extract expected SQL and state from migration instance
-        def extract_expected_state(migration_instance, direction)
-          captured_sql = capture_sql(migration_instance, direction)
-          parse_sql_to_state(captured_sql)
-        end
-
         # Capture SQL that would be executed by the migration
         def capture_sql(migration_instance, direction)
           captured = []
 
-          # Override execute to capture SQL instead of executing
-          # Since we use a separate instance for comparison, we don't need to restore
           migration_instance.define_singleton_method(:execute) do |sql|
             captured << sql.to_s.strip
           end
@@ -57,8 +57,8 @@ module PgSqlTriggers
               state[:functions] << function_info if function_info
             end
 
-            # Parse CREATE TRIGGER statements
-            if sql_normalized.match?(/CREATE\s+TRIGGER/i)
+            # Parse CREATE [CONSTRAINT] TRIGGER statements
+            if sql_normalized.match?(/CREATE\s+(?:CONSTRAINT\s+)?TRIGGER/i)
               trigger_info = parse_trigger_sql(sql)
               state[:triggers] << trigger_info if trigger_info
             end
@@ -95,8 +95,8 @@ module PgSqlTriggers
 
         # Parse trigger SQL to extract trigger details
         def parse_trigger_sql(sql)
-          # Match CREATE TRIGGER trigger_name BEFORE/AFTER events ON table_name ...
-          match = sql.match(/CREATE\s+TRIGGER\s+(\w+)\s+(BEFORE|AFTER)\s+(.+?)\s+ON\s+(\w+)/i)
+          # Match CREATE [CONSTRAINT] TRIGGER trigger_name BEFORE/AFTER events ON table_name ...
+          match = sql.match(/CREATE\s+(?:CONSTRAINT\s+)?TRIGGER\s+(\w+)\s+(BEFORE|AFTER)\s+(.+?)\s+ON\s+(\w+)/i)
           return nil unless match
 
           trigger_name = match[1]
@@ -194,7 +194,6 @@ module PgSqlTriggers
         end
 
         # Generate diff between expected and actual state
-        # rubocop:disable Metrics/MethodLength
         def generate_diff(expected, actual)
           diff = {
             has_differences: false,
@@ -203,80 +202,84 @@ module PgSqlTriggers
             drops: expected[:drops] || []
           }
 
-          # Compare functions
           expected[:functions].each do |expected_func|
-            func_name = expected_func[:function_name]
-            actual_func = actual[:functions][func_name]
-
-            if !actual_func || !actual_func[:exists]
-              diff[:functions] << {
-                function_name: func_name,
-                status: :new,
-                expected: expected_func[:function_body],
-                actual: nil,
-                message: "Function will be created"
-              }
-              diff[:has_differences] = true
-            elsif actual_func[:function_body] != expected_func[:function_body]
-              diff[:functions] << {
-                function_name: func_name,
-                status: :modified,
-                expected: expected_func[:function_body],
-                actual: actual_func[:function_body],
-                message: "Function body differs from expected"
-              }
-              diff[:has_differences] = true
-            else
-              diff[:functions] << {
-                function_name: func_name,
-                status: :unchanged,
-                message: "Function matches expected state"
-              }
-            end
+            diff_entry = diff_function_entry(expected_func, actual[:functions][expected_func[:function_name]])
+            diff[:functions] << diff_entry
+            diff[:has_differences] = true if diff_entry[:status] != :unchanged
           end
 
-          # Compare triggers
           expected[:triggers].each do |expected_trigger|
-            trigger_name = expected_trigger[:trigger_name]
-            actual_trigger = actual[:triggers][trigger_name]
-
-            if !actual_trigger || !actual_trigger[:exists]
-              diff[:triggers] << {
-                trigger_name: trigger_name,
-                status: :new,
-                expected: expected_trigger[:full_sql],
-                actual: nil,
-                message: "Trigger will be created"
-              }
-              diff[:has_differences] = true
-            else
-              # Compare trigger definitions
-              expected_def = normalize_trigger_definition(expected_trigger)
-              actual_def = normalize_trigger_definition_from_db(actual_trigger)
-
-              if expected_def == actual_def
-                diff[:triggers] << {
-                  trigger_name: trigger_name,
-                  status: :unchanged,
-                  message: "Trigger matches expected state"
-                }
-              else
-                diff[:triggers] << {
-                  trigger_name: trigger_name,
-                  status: :modified,
-                  expected: expected_trigger[:full_sql],
-                  actual: actual_trigger[:trigger_definition],
-                  message: "Trigger definition differs from expected",
-                  differences: compare_trigger_details(expected_trigger, actual_trigger)
-                }
-                diff[:has_differences] = true
-              end
-            end
+            diff_entry = diff_trigger_entry(expected_trigger, actual[:triggers][expected_trigger[:trigger_name]])
+            diff[:triggers] << diff_entry
+            diff[:has_differences] = true if diff_entry[:status] != :unchanged
           end
 
           diff
         end
-        # rubocop:enable Metrics/MethodLength
+
+        # Build a single function diff entry (:new / :modified / :unchanged).
+        def diff_function_entry(expected_func, actual_func)
+          func_name = expected_func[:function_name]
+
+          if !actual_func || !actual_func[:exists]
+            {
+              function_name: func_name,
+              status: :new,
+              expected: expected_func[:function_body],
+              actual: nil,
+              message: "Function will be created"
+            }
+          elsif actual_func[:function_body] != expected_func[:function_body]
+            {
+              function_name: func_name,
+              status: :modified,
+              expected: expected_func[:function_body],
+              actual: actual_func[:function_body],
+              message: "Function body differs from expected"
+            }
+          else
+            {
+              function_name: func_name,
+              status: :unchanged,
+              message: "Function matches expected state"
+            }
+          end
+        end
+
+        # Build a single trigger diff entry (:new / :modified / :unchanged).
+        def diff_trigger_entry(expected_trigger, actual_trigger)
+          trigger_name = expected_trigger[:trigger_name]
+
+          if !actual_trigger || !actual_trigger[:exists]
+            return {
+              trigger_name: trigger_name,
+              status: :new,
+              expected: expected_trigger[:full_sql],
+              actual: nil,
+              message: "Trigger will be created"
+            }
+          end
+
+          expected_def = normalize_trigger_definition(expected_trigger)
+          actual_def = normalize_trigger_definition_from_db(actual_trigger)
+
+          if expected_def == actual_def
+            {
+              trigger_name: trigger_name,
+              status: :unchanged,
+              message: "Trigger matches expected state"
+            }
+          else
+            {
+              trigger_name: trigger_name,
+              status: :modified,
+              expected: expected_trigger[:full_sql],
+              actual: actual_trigger[:trigger_definition],
+              message: "Trigger definition differs from expected",
+              differences: compare_trigger_details(expected_trigger, actual_trigger)
+            }
+          end
+        end
 
         # Normalize trigger definition for comparison
         def normalize_trigger_definition(trigger)

data/lib/pg_sql_triggers/migrator/safety_validator.rb

@@ -34,26 +34,43 @@ module PgSqlTriggers
           raise UnsafeOperationError.new(error_message, violations)
         end
 
+        # Validate using pre-captured SQL (avoids re-instantiating the migration class).
+        # Direction is intentionally not a parameter here – the captured SQL already reflects
+        # the direction that was executed to produce it.
+        # Raises UnsafeOperationError if unsafe patterns are detected.
+        def validate_sql!(captured_sql, allow_unsafe: false)
+          return if allow_unsafe
+
+          violations = detect_unsafe_patterns_from_sql(captured_sql)
+          return if violations.empty?
+
+          error_message = build_error_message(violations, "(migration)")
+          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)
+          detect_unsafe_patterns_from_sql(captured_sql)
+        end
 
-          # Parse SQL to detect unsafe patterns
-          sql_operations = parse_sql_operations(captured_sql)
+        private
 
-          # Check for explicit DROP + CREATE patterns (the main safety concern)
+        # Core detection logic that works on pre-captured SQL.
+        def detect_unsafe_patterns_from_sql(captured_sql)
+          violations = []
+          sql_operations = parse_sql_operations(captured_sql)
           violations.concat(detect_drop_create_patterns(sql_operations))
-
           violations
         end
 
-        private
-
-        # Capture SQL that would be executed by the migration
+        # Capture SQL that would be executed by the migration.
+        # Runs the migration inside a transaction that is always rolled back so
+        # that any ActiveRecord migration helpers (add_column, create_table, …)
+        # that are called alongside explicit +execute+ calls produce no lasting
+        # side effects.  The singleton override of +execute+ still intercepts
+        # raw SQL strings before they reach the database.
         def capture_sql(migration_instance, direction)
           captured = []
 
@@ -62,8 +79,13 @@ module PgSqlTriggers
             captured << sql.to_s.strip
           end
 
-          # Call the migration method (up or down) to capture SQL
-          migration_instance.public_send(direction)
+          # Run inside a transaction and roll it back so that any AR helpers
+          # called by the migration (add_column, create_table, etc.) do not
+          # persist their side effects during the capture phase.
+          ActiveRecord::Base.transaction do
+            migration_instance.public_send(direction)
+            raise ActiveRecord::Rollback
+          end
 
           captured
         end