pg_sql_triggers 1.3.0 → 1.5.0

data/app/models/pg_sql_triggers/audit_log.rb

@@ -17,70 +17,52 @@ module PgSqlTriggers
     validates :operation, presence: true
     validates :status, presence: true, inclusion: { in: %w[success failure] }
 
+    # Known keyword options accepted by log_success / log_failure, in addition to
+    # +operation+ (required for both) and +error_message+ (required for log_failure).
+    SUCCESS_ATTRS = %i[trigger_name actor environment reason confirmation_text
+                       before_state after_state diff].freeze
+    FAILURE_ATTRS = %i[trigger_name actor environment reason confirmation_text before_state].freeze
+
     # Class methods for logging operations
     class << self
-      # Log a successful operation
+      # Log a successful operation.
       #
-      # @param operation [Symbol, String] The operation being performed
-      # @param trigger_name [String, nil] The trigger name (if applicable)
-      # @param actor [Hash] Information about who performed the action
-      # @param environment [String, nil] The environment
-      # @param reason [String, nil] Reason for the operation
-      # @param confirmation_text [String, nil] Confirmation text used
-      # @param before_state [Hash, nil] State before operation
-      # @param after_state [Hash, nil] State after operation
-      # @param diff [String, nil] Diff information
-      # rubocop:disable Metrics/ParameterLists
-      def log_success(operation:, trigger_name: nil, actor: nil, environment: nil,
-                      reason: nil, confirmation_text: nil, before_state: nil,
-                      after_state: nil, diff: nil)
+      # Required: +operation:+ (Symbol/String).
+      # Optional (all via keyword args): trigger_name, actor, environment, reason,
+      # confirmation_text, before_state, after_state, diff.
+      def log_success(operation:, **options)
+        attrs = options.slice(*SUCCESS_ATTRS)
         create!(
-          trigger_name: trigger_name,
-          operation: operation.to_s,
-          actor: serialize_actor(actor),
-          environment: environment,
-          status: "success",
-          reason: reason,
-          confirmation_text: confirmation_text,
-          before_state: before_state,
-          after_state: after_state,
-          diff: diff
+          attrs.merge(
+            operation: operation.to_s,
+            actor: serialize_actor(attrs[:actor]),
+            status: "success"
+          )
         )
       rescue StandardError => e
         Rails.logger.error("Failed to log audit entry: #{e.message}") if defined?(Rails.logger)
         nil
       end
-      # rubocop:enable Metrics/ParameterLists
 
-      # Log a failed operation
+      # Log a failed operation.
       #
-      # @param operation [Symbol, String] The operation being performed
-      # @param trigger_name [String, nil] The trigger name (if applicable)
-      # @param actor [Hash] Information about who performed the action
-      # @param environment [String, nil] The environment
-      # @param error_message [String] Error message
-      # @param reason [String, nil] Reason for the operation (if provided before failure)
-      # @param confirmation_text [String, nil] Confirmation text used
-      # @param before_state [Hash, nil] State before operation
-      # rubocop:disable Metrics/ParameterLists
-      def log_failure(operation:, error_message:, trigger_name: nil, actor: nil, environment: nil, reason: nil,
-                      confirmation_text: nil, before_state: nil)
+      # Required: +operation:+ (Symbol/String) and +error_message:+ (String).
+      # Optional (all via keyword args): trigger_name, actor, environment, reason,
+      # confirmation_text, before_state.
+      def log_failure(operation:, error_message:, **options)
+        attrs = options.slice(*FAILURE_ATTRS)
         create!(
-          trigger_name: trigger_name,
-          operation: operation.to_s,
-          actor: serialize_actor(actor),
-          environment: environment,
-          status: "failure",
-          error_message: error_message,
-          reason: reason,
-          confirmation_text: confirmation_text,
-          before_state: before_state
+          attrs.merge(
+            operation: operation.to_s,
+            actor: serialize_actor(attrs[:actor]),
+            status: "failure",
+            error_message: error_message
+          )
         )
       rescue StandardError => e
         Rails.logger.error("Failed to log audit entry: #{e.message}") if defined?(Rails.logger)
         nil
       end
-      # rubocop:enable Metrics/ParameterLists
 
       # Get audit log entries for a specific trigger
       #

data/app/models/pg_sql_triggers/trigger_registry.rb

@@ -21,7 +21,9 @@ module PgSqlTriggers
   # @example Drop and re-execute triggers
   #   trigger.drop!(reason: "No longer needed", actor: current_user, confirmation: "EXECUTE TRIGGER_DROP")
   #   trigger.re_execute!(reason: "Fix drift", actor: current_user, confirmation: "EXECUTE TRIGGER_RE_EXECUTE")
-  # rubocop:disable Metrics/ClassLength
+  # rubocop:disable Metrics/ClassLength -- core AR model: groups lifecycle operations
+  # (enable!/disable!/drop!/re_execute!), drift helpers, audit hooks, and SQL builders.
+  # Splitting further would fragment tightly-coupled state and audit concerns.
   class TriggerRegistry < PgSqlTriggers::ApplicationRecord
     self.table_name = "pg_sql_triggers_registry"
 
@@ -39,6 +41,16 @@ module PgSqlTriggers
     scope :for_environment, ->(env) { where(environment: [env, nil]) }
     scope :by_source, ->(source) { where(source: source) }
 
+    # Case-insensitive search on trigger name and table name (used by web dashboard).
+    scope :matching_search, lambda { |raw|
+      query = raw.to_s.strip
+      next all if query.blank?
+
+      sanitized = ActiveRecord::Base.sanitize_sql_like(query)
+      term = "%#{sanitized}%"
+      where("trigger_name ILIKE :term OR table_name ILIKE :term", term: term)
+    }
+
     # Returns the current drift state of this trigger.
     #
     # @return [String] One of: "in_sync", "drifted", "manual_override", "disabled", "dropped", "unknown"
@@ -119,32 +131,12 @@ module PgSqlTriggers
         end
       end
 
-      # Update the registry record (always update, even if trigger doesn't exist)
-      begin
-        update!(enabled: true)
-        after_state = capture_state
-        log_audit_success(:trigger_enable, actor, before_state: before_state, after_state: after_state)
-      rescue ActiveRecord::StatementInvalid, StandardError => e
-        # If update! fails, try update_column which bypasses validations and callbacks
-        # and might not use execute in the same way
-        Rails.logger.warn("Could not update registry via update!: #{e.message}") if defined?(Rails.logger)
-        begin
-          # rubocop:disable Rails/SkipsModelValidations
-          update_column(:enabled, true)
-          # rubocop:enable Rails/SkipsModelValidations
-          after_state = capture_state
-          log_audit_success(:trigger_enable, actor, before_state: before_state, after_state: after_state)
-        rescue StandardError => update_error
-          # If update_column also fails, just set the in-memory attribute
-          # The test might reload, but we've done our best
-          # rubocop:disable Layout/LineLength
-          Rails.logger.warn("Could not update registry via update_column: #{update_error.message}") if defined?(Rails.logger)
-          # rubocop:enable Layout/LineLength
-          self.enabled = true
-          after_state = capture_state
-          log_audit_success(:trigger_enable, actor, before_state: before_state, after_state: after_state)
-        end
-      end
+      # Update the registry record (always update, even if trigger doesn't exist).
+      # If persistence fails for any reason, fall back to the in-memory attribute so
+      # callers/observers still see a consistent state for this request.
+      persist_enabled_state(true)
+      after_state = capture_state
+      log_audit_success(:trigger_enable, actor, before_state: before_state, after_state: after_state)
     end
 
     # Disables this trigger in the database and updates the registry.
@@ -191,32 +183,12 @@ module PgSqlTriggers
         end
       end
 
-      # Update the registry record (always update, even if trigger doesn't exist)
-      begin
-        update!(enabled: false)
-        after_state = capture_state
-        log_audit_success(:trigger_disable, actor, before_state: before_state, after_state: after_state)
-      rescue ActiveRecord::StatementInvalid, StandardError => e
-        # If update! fails, try update_column which bypasses validations and callbacks
-        # and might not use execute in the same way
-        Rails.logger.warn("Could not update registry via update!: #{e.message}") if defined?(Rails.logger)
-        begin
-          # rubocop:disable Rails/SkipsModelValidations
-          update_column(:enabled, false)
-          # rubocop:enable Rails/SkipsModelValidations
-          after_state = capture_state
-          log_audit_success(:trigger_disable, actor, before_state: before_state, after_state: after_state)
-        rescue StandardError => update_error
-          # If update_column also fails, just set the in-memory attribute
-          # The test might reload, but we've done our best
-          # rubocop:disable Layout/LineLength
-          Rails.logger.warn("Could not update registry via update_column: #{update_error.message}") if defined?(Rails.logger)
-          # rubocop:enable Layout/LineLength
-          self.enabled = false
-          after_state = capture_state
-          log_audit_success(:trigger_disable, actor, before_state: before_state, after_state: after_state)
-        end
-      end
+      # Update the registry record (always update, even if trigger doesn't exist).
+      # If persistence fails for any reason, fall back to the in-memory attribute so
+      # callers/observers still see a consistent state for this request.
+      persist_enabled_state(false)
+      after_state = capture_state
+      log_audit_success(:trigger_disable, actor, before_state: before_state, after_state: after_state)
     end
 
     # Drops this trigger from the database and removes it from the registry.
@@ -247,7 +219,6 @@ module PgSqlTriggers
       # Execute DROP TRIGGER in transaction
       ActiveRecord::Base.transaction do
         drop_trigger_from_database
-        trigger_name
         destroy!
         log_drop_success
         log_audit_success(:trigger_drop, actor, reason: reason, confirmation_text: confirmation,
@@ -264,8 +235,9 @@ module PgSqlTriggers
     # @param reason [String] Required reason for re-executing the trigger
     # @param confirmation [String, nil] Optional confirmation text for kill switch protection
     # @param actor [Hash, nil] Information about who is performing the action (must have :type and :id keys)
-    # @raise [ArgumentError] If reason is missing or empty, or if function_body is blank
+    # @raise [ArgumentError] If reason is missing or empty
     # @raise [PgSqlTriggers::KillSwitchError] If kill switch blocks the operation
+    # @raise [StandardError] If SQL cannot be generated to recreate the trigger
     # @return [PgSqlTriggers::TriggerRegistry] self
     def re_execute!(reason:, confirmation: nil, actor: nil)
       actor ||= { type: "Console", id: "TriggerRegistry#re_execute!" }
@@ -286,7 +258,6 @@ module PgSqlTriggers
 
       # Validate reason is provided
       raise ArgumentError, "Reason is required" if reason.nil? || reason.to_s.strip.empty?
-      raise StandardError, "Cannot re-execute: missing function_body" if function_body.blank?
 
       log_re_execute_attempt(reason)
 
@@ -316,13 +287,22 @@ module PgSqlTriggers
     end
 
     def calculate_checksum
+      deferral = PgSqlTriggers::DeferralChecksum.parts(
+        constraint_trigger: constraint_trigger,
+        deferrable: deferrable,
+        initially: initially
+      )
+      events_segment = PgSqlTriggers::EventsChecksum.segment_from_definition_json(definition)
       Digest::SHA256.hexdigest([
         trigger_name,
         table_name,
         version,
         function_body || "",
         condition || "",
-        timing || "before"
+        timing || "before",
+        for_each || "row",
+        events_segment,
+        *deferral
       ].join)
     end
 
@@ -394,7 +374,17 @@ module PgSqlTriggers
     end
 
     def recreate_trigger
-      ActiveRecord::Base.connection.execute(function_body)
+      # DSL triggers are recreated from the stored JSON definition (+build_trigger_sql_from_definition+).
+      # Other sources may persist a full trigger SQL payload in +function_body+.
+      sql = if source == "dsl"
+              build_trigger_sql_from_definition
+            else
+              function_body.presence || build_trigger_sql_from_definition
+            end
+
+      raise StandardError, "Cannot re-execute: no SQL could be generated" if sql.blank?
+
+      ActiveRecord::Base.connection.execute(sql)
       if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
         Rails.logger.info "[TRIGGER_RE_EXECUTE] Re-created trigger"
       end
@@ -405,8 +395,71 @@ module PgSqlTriggers
       raise
     end
 
+    # Build a CREATE TRIGGER SQL statement from the stored DSL definition JSON.
+    # Used by re_execute! when function_body is absent (the normal case for DSL triggers).
+    def build_trigger_sql_from_definition
+      return nil if definition.blank?
+
+      defn = JSON.parse(definition)
+      fn_name = defn["function_name"]
+      return nil if fn_name.blank?
+
+      t_name = table_name
+      constraint = ActiveModel::Type::Boolean.new.cast(defn["constraint_trigger"])
+      timing_kw = if constraint
+                    "AFTER"
+                  else
+                    (defn["timing"] || timing || "before").to_s.upcase
+                  end
+      events_sql = PgSqlTriggers::EventsChecksum.events_sql_fragment(
+        defn,
+        quote_column: ->(col) { quote_identifier(col) }
+      )
+      cond = defn["condition"] || condition
+      for_each_kw = (defn["for_each"] || for_each || "row").upcase
+
+      create_kw = constraint ? "CREATE CONSTRAINT TRIGGER" : "CREATE TRIGGER"
+      sql = "#{create_kw} #{quote_identifier(trigger_name)} "
+      sql += "#{timing_kw} #{events_sql} ON #{quote_identifier(t_name)} "
+      deferral = deferral_sql_fragment(defn)
+      sql += "#{deferral} " if deferral.present?
+      sql += "FOR EACH #{for_each_kw} "
+      sql += "WHEN (#{cond}) " if cond.present?
+      sql += "EXECUTE FUNCTION #{fn_name}();"
+      sql
+    rescue JSON::ParserError
+      nil
+    end
+
+    def deferral_sql_fragment(defn)
+      return "" unless ActiveModel::Type::Boolean.new.cast(defn["constraint_trigger"])
+
+      case defn["deferrable"].to_s
+      when "not_deferrable"
+        "NOT DEFERRABLE"
+      when "deferrable"
+        case defn["initially"].to_s
+        when "deferred"
+          "DEFERRABLE INITIALLY DEFERRED"
+        when "immediate"
+          "DEFERRABLE INITIALLY IMMEDIATE"
+        else
+          "DEFERRABLE"
+        end
+      else
+        ""
+      end
+    end
+
     def update_registry_after_re_execute
-      update!(enabled: true, last_executed_at: Time.current)
+      update!(last_executed_at: Time.current)
+      if !enabled && ActiveRecord::Base.connection.table_exists?(table_name)
+        quoted_table   = quote_identifier(table_name)
+        quoted_trigger = quote_identifier(trigger_name)
+        ActiveRecord::Base.connection.execute(
+          "ALTER TABLE #{quoted_table} DISABLE TRIGGER #{quoted_trigger};"
+        )
+      end
       Rails.logger.info "[TRIGGER_RE_EXECUTE] Updated registry" if defined?(Rails.logger)
     end
 
@@ -419,13 +472,12 @@ module PgSqlTriggers
         table_name: table_name,
         source: source,
         environment: environment,
-        installed_at: installed_at&.iso8601
+        installed_at: installed_at&.iso8601,
+        function_body: function_body
       }
     end
 
-    # rubocop:disable Metrics/ParameterLists
-    def log_audit_success(operation, actor, reason: nil, confirmation_text: nil,
-                          before_state: nil, after_state: nil, diff: nil)
+    def log_audit_success(operation, actor, **options)
       return unless defined?(PgSqlTriggers::AuditLog)
 
       PgSqlTriggers::AuditLog.log_success(
@@ -433,18 +485,13 @@ module PgSqlTriggers
         trigger_name: trigger_name,
         actor: actor,
         environment: Rails.env,
-        reason: reason,
-        confirmation_text: confirmation_text,
-        before_state: before_state,
-        after_state: after_state,
-        diff: diff
+        **options
       )
     rescue StandardError => e
       Rails.logger.error("Failed to log audit entry: #{e.message}") if defined?(Rails.logger)
     end
 
-    def log_audit_failure(operation, actor, error_message, reason: nil,
-                          confirmation_text: nil, before_state: nil)
+    def log_audit_failure(operation, actor, error_message, **options)
       return unless defined?(PgSqlTriggers::AuditLog)
 
       PgSqlTriggers::AuditLog.log_failure(
@@ -453,14 +500,30 @@ module PgSqlTriggers
         actor: actor,
         environment: Rails.env,
         error_message: error_message,
-        reason: reason,
-        confirmation_text: confirmation_text,
-        before_state: before_state
+        **options
       )
     rescue StandardError => e
       Rails.logger.error("Failed to log audit entry: #{e.message}") if defined?(Rails.logger)
     end
-    # rubocop:enable Metrics/ParameterLists
+
+    # Persist the +enabled+ flag: +update!+, then +update_column+ if needed, then in-memory.
+    # Returns true when a DB write succeeded, false when only the in-memory value changed.
+    def persist_enabled_state(value)
+      update!(enabled: value)
+      true
+    rescue ActiveRecord::StatementInvalid, StandardError => e
+      Rails.logger.warn("Could not update registry via update!: #{e.message}") if defined?(Rails.logger)
+      begin
+        # rubocop:disable Rails/SkipsModelValidations -- fallback when update! fails (callbacks/validations/locks)
+        update_column(:enabled, value)
+        # rubocop:enable Rails/SkipsModelValidations
+        true
+      rescue ActiveRecord::StatementInvalid, StandardError => e2
+        Rails.logger.warn("Could not update registry via update_column: #{e2.message}") if defined?(Rails.logger)
+        self.enabled = value
+        false
+      end
+    end
   end
   # rubocop:enable Metrics/ClassLength
 end

data/app/views/layouts/pg_sql_triggers/application.html.erb

@@ -18,7 +18,6 @@
       <div>
         <%= link_to "Dashboard", root_path, style: "color: white; margin-right: 1rem;" %>
         <%= link_to "Tables", tables_path, style: "color: white; margin-right: 1rem;" %>
-        <%= link_to "Generator", new_generator_path, style: "color: white; margin-right: 1rem;" %>
         <%= link_to "Audit Log", audit_logs_path, style: "color: white;" %>
       </div>
     </div>

data/app/views/pg_sql_triggers/audit_logs/index.html.erb

@@ -4,7 +4,7 @@
     <h1 style="margin: 0;">Audit Log</h1>
     <div style="display: flex; gap: 1rem;">
       <%= link_to "Dashboard", dashboard_path, style: "padding: 0.5rem 1rem; background: #6c757d; color: white; text-decoration: none; border-radius: 4px; display: inline-block;" %>
-      <% csv_params = params.permit(:trigger_name, :operation, :status, :environment, :actor_id).to_h %>
+      <% csv_params = params.permit(:trigger_name, :operation, :status, :environment, :actor_id, :q).to_h %>
       <%= link_to "Export CSV", audit_logs_path(csv_params.merge(format: :csv)), style: "padding: 0.5rem 1rem; background: #28a745; color: white; text-decoration: none; border-radius: 4px; display: inline-block;" %>
     </div>
   </div>
@@ -13,6 +13,10 @@
   <div style="background: white; padding: 1.5rem; border-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); margin-bottom: 2rem;">
     <h3 style="margin-top: 0; margin-bottom: 1rem;">Filters</h3>
     <%= form_with url: audit_logs_path, method: :get, local: true, style: "display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem;" do |f| %>
+      <div style="grid-column: 1 / -1;">
+        <%= label_tag :q, "Search", style: "display: block; margin-bottom: 0.5rem; font-weight: 600;" %>
+        <%= text_field_tag :q, params[:q], placeholder: "Trigger, operation, reason, error…", style: "width: 100%; padding: 0.5rem; border: 1px solid #ced4da; border-radius: 4px;" %>
+      </div>
       <div>
         <%= f.label :trigger_name, "Trigger Name", style: "display: block; margin-bottom: 0.5rem; font-weight: 600;" %>
         <%= f.select :trigger_name, options_for_select([["All", ""]] + @available_trigger_names.map { |n| [n, n] }, params[:trigger_name]), {}, { style: "width: 100%; padding: 0.5rem; border: 1px solid #ced4da; border-radius: 4px;" } %>
@@ -48,7 +52,7 @@
   <!-- Results Summary -->
   <div style="background: #f8f9fa; padding: 1rem; border-radius: 4px; margin-bottom: 1rem;">
     <strong>Total Results:</strong> <%= @total_count %> entries
-    <% if params[:trigger_name].present? || params[:operation].present? || params[:status].present? || params[:environment].present? %>
+    <% if params[:trigger_name].present? || params[:operation].present? || params[:status].present? || params[:environment].present? || params[:q].present? %>
       <span style="color: #6c757d;">(filtered)</span>
     <% end %>
   </div>
@@ -144,7 +148,7 @@
     <% if @total_pages > 1 %>
       <div style="display: flex; justify-content: center; align-items: center; gap: 1rem; margin-top: 2rem;">
         <% if @page > 1 %>
-          <% prev_params = params.except(:page).permit(:trigger_name, :operation, :status, :environment, :sort, :per_page).to_h %>
+          <% prev_params = params.except(:page).permit(:trigger_name, :operation, :status, :environment, :sort, :per_page, :q).to_h %>
           <%= link_to "« Previous", audit_logs_path(prev_params.merge(page: @page - 1)), style: "padding: 0.5rem 1rem; background: #007bff; color: white; text-decoration: none; border-radius: 4px;" %>
         <% else %>
           <span style="padding: 0.5rem 1rem; background: #e9ecef; color: #6c757d; border-radius: 4px; cursor: not-allowed;">« Previous</span>
@@ -155,7 +159,7 @@
         </span>
 
         <% if @page < @total_pages %>
-          <% next_params = params.except(:page).permit(:trigger_name, :operation, :status, :environment, :sort, :per_page).to_h %>
+          <% next_params = params.except(:page).permit(:trigger_name, :operation, :status, :environment, :sort, :per_page, :q).to_h %>
           <%= link_to "Next »", audit_logs_path(next_params.merge(page: @page + 1)), style: "padding: 0.5rem 1rem; background: #007bff; color: white; text-decoration: none; border-radius: 4px;" %>
         <% else %>
           <span style="padding: 0.5rem 1rem; background: #e9ecef; color: #6c757d; border-radius: 4px; cursor: not-allowed;">Next »</span>
@@ -166,7 +170,7 @@
     <div style="background: white; padding: 3rem; border-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); text-align: center;">
       <h3 style="margin-top: 0; color: #6c757d;">No audit log entries found</h3>
       <p style="color: #6c757d;">
-        <% if params[:trigger_name].present? || params[:operation].present? || params[:status].present? || params[:environment].present? %>
+        <% if params[:trigger_name].present? || params[:operation].present? || params[:status].present? || params[:environment].present? || params[:q].present? %>
           Try adjusting your filters or <%= link_to "clear filters", audit_logs_path, style: "color: #007bff;" %>.
         <% else %>
           Audit log entries will appear here as operations are performed.