pg_sql_triggers 1.0.0 → 1.1.0

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

data/lib/pg_sql_triggers/dsl/trigger_definition.rb

@@ -12,6 +12,7 @@ module PgSqlTriggers
         @enabled = false
         @environments = []
         @condition = nil
+        @timing = "before"
       end
 
       def table(table_name)
@@ -50,6 +51,18 @@ module PgSqlTriggers
         @condition = condition_sql
       end
 
+      def timing(timing_value = nil)
+        if timing_value.nil?
+          @timing
+        else
+          @timing = timing_value.to_s
+        end
+      end
+
+      def function_body
+        nil # DSL definitions don't include function_body directly
+      end
+
       def to_h
         {
           name: @name,
@@ -59,7 +72,8 @@ module PgSqlTriggers
           version: @version,
           enabled: @enabled,
           environments: @environments,
-          condition: @condition
+          condition: @condition,
+          timing: @timing
         }
       end
     end

data/lib/pg_sql_triggers/generator/form.rb

@@ -6,7 +6,7 @@ module PgSqlTriggers
       include ActiveModel::Model
 
       attr_accessor :trigger_name, :table_name, :function_name,
-                    :version, :enabled, :condition,
+                    :version, :enabled, :condition, :timing,
                     :generate_function_stub, :events, :environments,
                     :function_body
 
@@ -23,6 +23,7 @@ module PgSqlTriggers
                                 }
       validates :version, presence: true, numericality: { only_integer: true, greater_than: 0 }
       validates :function_body, presence: true
+      validates :timing, inclusion: { in: %w[before after], message: "must be 'before' or 'after'" }
       validate :at_least_one_event
       validate :function_name_matches_body
 
@@ -38,6 +39,7 @@ module PgSqlTriggers
         @generate_function_stub = true if @generate_function_stub.nil?
         @events ||= []
         @environments ||= []
+        @timing ||= "before" # Default to "before" if not specified
       end
 
       def default_function_body

data/lib/pg_sql_triggers/generator/service.rb

@@ -6,6 +6,7 @@ require "active_support/core_ext/string/inflections"
 
 module PgSqlTriggers
   module Generator
+    # rubocop:disable Metrics/ClassLength
     class Service
       class << self
         def generate_dsl(form)
@@ -31,6 +32,7 @@ module PgSqlTriggers
             #{'  '}
               version #{form.version}
               enabled #{form.enabled}
+              timing :#{form.timing || 'before'}
           RUBY
 
           code += "  when_env #{environments_list}\n" if form.environments.compact_blank.any?
@@ -51,8 +53,9 @@ module PgSqlTriggers
           function_body_sql = form.function_body.strip
 
           # Build the trigger creation SQL
+          timing_value = (form.timing || "before").upcase
           trigger_sql = "CREATE TRIGGER #{form.trigger_name}\n"
-          trigger_sql += "BEFORE #{events_sql} ON #{form.table_name}\n"
+          trigger_sql += "#{timing_value} #{events_sql} ON #{form.table_name}\n"
           trigger_sql += "FOR EACH ROW\n"
           trigger_sql += "WHEN (#{form.condition})\n" if form.condition.present?
           trigger_sql += "EXECUTE FUNCTION #{form.function_name}();"
@@ -61,6 +64,11 @@ module PgSqlTriggers
           down_sql = "DROP TRIGGER IF EXISTS #{form.trigger_name} ON #{form.table_name};\n"
           down_sql += "DROP FUNCTION IF EXISTS #{form.function_name}();"
 
+          # Indent SQL strings to match heredoc indentation (18 spaces)
+          indented_function_body = indent_sql(function_body_sql, 18)
+          indented_trigger_sql = indent_sql(trigger_sql, 18)
+          indented_down_sql = indent_sql(down_sql, 18)
+
           <<~RUBY
             # frozen_string_literal: true
 
@@ -69,18 +77,18 @@ module PgSqlTriggers
               def up
                 # Create the function
                 execute <<-SQL
-                  #{function_body_sql}
+                  #{indented_function_body}
                 SQL
 
                 # Create the trigger
                 execute <<-SQL
-                  #{trigger_sql}
+                  #{indented_trigger_sql}
                 SQL
               end
 
               def down
                 execute <<-SQL
-                  #{down_sql}
+                  #{indented_down_sql}
                 SQL
               end
             end
@@ -140,31 +148,55 @@ module PgSqlTriggers
           }
         end
 
-        def create_trigger(form, _actor: nil)
+        def create_trigger(form, actor: nil) # rubocop:disable Lint/UnusedMethodArgument
           paths = file_paths(form)
+          base_path = rails_base_path
 
-          # Determine if we're in a Rails app context or standalone gem
-          base_path = defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : Pathname.new(Dir.pwd)
+          create_trigger_files(form, paths, base_path)
+          registry = register_trigger(form)
+
+          build_success_response(registry, paths, form)
+        rescue StandardError => e
+          log_error(e)
+          build_error_response(e)
+        end
+
+        private
+
+        def indent_sql(sql_string, indent_level)
+          indent = " " * indent_level
+          sql_string.lines.map do |line|
+            stripped = line.chomp
+            stripped.empty? ? "" : indent + stripped
+          end.join("\n")
+        end
 
+        def rails_base_path
+          defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : Pathname.new(Dir.pwd)
+        end
+
+        def create_trigger_files(form, paths, base_path)
           full_migration_path = base_path.join(paths[:migration])
           full_dsl_path = base_path.join(paths[:dsl])
 
-          # Create directories
           FileUtils.mkdir_p(full_migration_path.dirname)
           FileUtils.mkdir_p(full_dsl_path.dirname)
 
-          # Generate content
           migration_content = generate_migration(form)
           dsl_content = generate_dsl(form)
-          # Use function_body (required field)
-          function_content = form.function_body
 
-          # Write both files
           File.write(full_migration_path, migration_content)
           File.write(full_dsl_path, dsl_content)
+        end
 
-          # Register in TriggerRegistry
-          definition = {
+        def register_trigger(form)
+          definition = build_trigger_definition(form)
+          attributes = build_registry_attributes(form, definition)
+          TriggerRegistry.create!(attributes)
+        end
+
+        def build_trigger_definition(form)
+          {
             name: form.trigger_name,
             table_name: form.table_name,
             events: form.events.compact_blank,
@@ -172,9 +204,13 @@ module PgSqlTriggers
             version: form.version,
             enabled: form.enabled,
             environments: form.environments.compact_blank,
-            condition: form.condition
+            condition: form.condition,
+            timing: form.timing || "before",
+            function_body: form.function_body
           }
+        end
 
+        def build_registry_attributes(form, definition)
           attributes = {
             trigger_name: form.trigger_name,
             table_name: form.table_name,
@@ -183,15 +219,22 @@ module PgSqlTriggers
             source: "dsl",
             environment: form.environments.compact_blank.join(",").presence,
             definition: definition.to_json,
-            function_body: function_content,
+            function_body: form.function_body,
             checksum: calculate_checksum(definition)
           }
 
-          # Only include condition if the column exists and value is present
-          attributes[:condition] = form.condition.presence if TriggerRegistry.column_names.include?("condition")
+          add_conditional_attributes(attributes, form)
+          attributes
+        end
 
-          registry = TriggerRegistry.create!(attributes)
+        def add_conditional_attributes(attributes, form)
+          column_names = TriggerRegistry.column_names
 
+          attributes[:condition] = form.condition.presence if column_names.include?("condition")
+          attributes[:timing] = (form.timing || "before") if column_names.include?("timing")
+        end
+
+        def build_success_response(registry, paths, form)
           {
             success: true,
             registry_id: registry.id,
@@ -204,18 +247,22 @@ module PgSqlTriggers
               files_created: [paths[:migration], paths[:dsl]]
             }
           }
-        rescue StandardError => e
-          Rails.logger.error("Trigger generation failed: #{e.message}") if defined?(Rails)
-          Rails.logger.error(e.backtrace.join("\n")) if defined?(Rails)
+        end
+
+        def log_error(error)
+          return unless defined?(Rails)
+
+          Rails.logger.error("Trigger generation failed: #{error.message}")
+          Rails.logger.error(error.backtrace.join("\n"))
+        end
 
+        def build_error_response(error)
           {
             success: false,
-            error: e.message
+            error: error.message
           }
         end
 
-        private
-
         def next_migration_number
           # Determine if we're in a Rails app context or standalone gem
           base_path = defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : Pathname.new(Dir.pwd)
@@ -243,9 +290,18 @@ module PgSqlTriggers
         end
 
         def calculate_checksum(definition)
-          Digest::SHA256.hexdigest(definition.to_json)
+          # Use field-concatenation algorithm (consistent with TriggerRegistry#calculate_checksum)
+          Digest::SHA256.hexdigest([
+            definition[:name],
+            definition[:table_name],
+            definition[:version],
+            definition[:function_body] || "",
+            definition[:condition] || "",
+            definition[:timing] || "before"
+          ].join)
         end
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/pg_sql_triggers/migration.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module PgSqlTriggers
-  class Migration < ActiveRecord::Migration[6.0]
+  class Migration < ActiveRecord::Migration[6.1]
     # Base class for trigger migrations
     # Similar to ActiveRecord::Migration but for trigger-specific migrations