pg_sql_triggers 1.3.0 → 1.5.0

data/README.md

@@ -42,6 +42,8 @@ rails generate pg_sql_triggers:install
 rails db:migrate
 ```
 
+Schema migrations bundled with the gem are listed in [Getting Started — Gem schema migrations](docs/getting-started.md#gem-schema-migrations) (ordered `db/migrate/*.rb` filenames).
+
 ### Define a Trigger
 
 ```ruby
@@ -50,16 +52,18 @@ PgSqlTriggers::DSL.pg_sql_trigger "users_email_validation" do
   table :users
   on :insert, :update
   function :validate_user_email
-  version 1
-  enabled false
-  when_env :production
+  self.version = 1
+  self.enabled = true
+  timing :before
 end
 ```
 
-### Create and Run Migration
+### Generate and Run Migration
 
 ```bash
-rails generate trigger:migration add_email_validation
+# Generate a DSL stub + migration in one command
+rails generate pg_sql_triggers:trigger users_email_validation users insert update --timing before --function validate_user_email
+
 rake trigger:migrate
 ```
 
@@ -83,39 +87,62 @@ Comprehensive documentation is available in the [docs](docs/) directory:
 ## Key Features
 
 ### Trigger DSL
-Define triggers using a Rails-native Ruby DSL with versioning and environment control.
+Define triggers using a Rails-native Ruby DSL with versioning, row/statement-level granularity, and timing control.
+
+### CLI Generator
+Scaffold a DSL stub and migration in one command:
+```bash
+rails generate pg_sql_triggers:trigger TRIGGER_NAME TABLE_NAME [EVENTS...] [--timing before|after] [--function fn_name]
+```
+Files land in `app/triggers/` and `db/triggers/` for code review like any other source change.
 
 ### Migration System
 Manage trigger functions and definitions with a migration system similar to Rails schema migrations.
 
+### schema.rb, structure.sql, and trigger snapshots
+
+`db:schema:dump` does not capture PostgreSQL triggers. This gem addresses that in three ways:
+
+1. **Comments in `schema.rb`** — When using the default Ruby schema format, `rails db:schema:dump` appends a short note listing managed triggers and pointing to `trigger:migrate` / `trigger:load`. Disable with `PgSqlTriggers.append_trigger_notes_to_schema_dump = false`.
+2. **`db/trigger_structure.sql`** — Run `rails trigger:dump` to write `CREATE FUNCTION` / `CREATE TRIGGER` statements for registered triggers (or all non-internal triggers in `public` if the registry table is absent). Apply on a fresh DB with `rails trigger:load` (runs arbitrary SQL; kill switch applies in protected environments). Override the path with `FILE=...` or `TRIGGER_STRUCTURE_SQL=...`, or set `PgSqlTriggers.trigger_structure_sql_path`.
+3. **`db:schema:load`** — After loading `schema.rb`, `trigger:migrate` runs automatically so pending trigger migrations apply. Opt out with `SKIP_TRIGGER_MIGRATE_AFTER_SCHEMA_LOAD=1` or `PgSqlTriggers.migrate_triggers_after_schema_load = false`.
+
+For a single SQL artifact that includes tables and triggers, set `config.active_record.schema_format = :sql` and use Rails’ `structure.sql` workflow; keep `db/triggers` migrations as the source of truth and refresh `db/trigger_structure.sql` when you want a portable trigger-only snapshot.
+
 ### Drift Detection
-Automatically detect when database triggers drift from your DSL definitions.
+Automatically detect when database triggers drift from your DSL definitions. N+1-free bulk detection across all triggers.
+
+### Drift Alerting
+Configure `PgSqlTriggers.drift_notifier` to push alerts to Slack, PagerDuty, email, or any external system when drift detection finds drifted, dropped, or unknown triggers. Schedule `rake trigger:check_drift` (with optional `FAIL_ON_DRIFT=1`) for CI or cron-based monitoring. An `ActiveSupport::Notifications` event `pg_sql_triggers.drift_check` is emitted on every run for APM instrumentation.
+
+### Advanced PostgreSQL Trigger Features
+- **Column-level `UPDATE OF` triggers** — `on_update_of(:email, :status)` fires only when specific columns change, a common audit/performance optimisation.
+- **Constraint triggers with deferral** — `constraint_trigger!` plus `deferrable` / `initially` options emit `CREATE CONSTRAINT TRIGGER ... DEFERRABLE INITIALLY DEFERRED` for referential-integrity patterns that need to fire at transaction commit.
+- **Ordering hints** — `depends_on "other_trigger"` captures intended firing order among same-table triggers. PostgreSQL fires same-kind triggers alphabetically; `rake trigger:validate_order` (and `Registry.validate!`) verifies declared dependencies, flags cycles, and enforces name-ordering so declared order matches execution order.
 
 ### Production Kill Switch
 Multi-layered safety mechanism preventing accidental destructive operations in production environments.
 
 ### Web Dashboard
-Visual interface for managing triggers, running migrations, and executing SQL capsules. Includes:
+Visual interface for managing triggers and running migrations. Includes:
 - **Quick Actions**: Enable/disable, drop, and re-execute triggers from dashboard
 - **Last Applied Tracking**: See when triggers were last applied with human-readable timestamps
 - **Breadcrumb Navigation**: Easy navigation between dashboard, tables, and triggers
 - **Permission-Aware UI**: Buttons show/hide based on user role
+- **Search, Filter, and Pagination**: Filter triggers by table, drift state, or source; full-text search on name/table; offset/limit pagination (`?table=users&state=drifted&source=dsl&q=email&trigger_page=2&trigger_per_page=20`)
 
 ### Audit Logging
 Comprehensive audit trail for all trigger operations:
 - Track who performed each operation (actor tracking)
-- Before and after state capture
+- Before and after state capture (including function body)
 - Success/failure logging with error messages
 - Reason tracking for drop and re-execute operations
 
-### SQL Capsules
-Emergency SQL execution feature for critical operations with Admin permission requirements, kill switch protection, and comprehensive logging.
-
 ### Drop & Re-Execute Flow
 Operational controls for trigger lifecycle management with drop and re-execute capabilities, drift comparison, and required reason logging.
 
 ### Permissions
-Three-tier permission system (Viewer, Operator, Admin) with customizable authorization.
+Three-tier permission system (Viewer, Operator, Admin) with customizable authorization. A startup warning is emitted in production when no `permission_checker` is configured.
 
 ## Console API
 
@@ -142,15 +169,6 @@ PgSqlTriggers::Registry.disable("users_email_validation", actor: current_user, c
 # Drop and re-execute triggers
 PgSqlTriggers::Registry.drop("old_trigger", actor: current_user, reason: "No longer needed", confirmation: "EXECUTE TRIGGER_DROP")
 PgSqlTriggers::Registry.re_execute("drifted_trigger", actor: current_user, reason: "Fix drift", confirmation: "EXECUTE TRIGGER_RE_EXECUTE")
-
-# Execute SQL capsules
-capsule = PgSqlTriggers::SQL::Capsule.new(
-  name: "emergency_fix",
-  environment: "production",
-  purpose: "Fix critical data issue",
-  sql: "UPDATE users SET status = 'active' WHERE id = 123"
-)
-PgSqlTriggers::SQL::Executor.execute(capsule, actor: current_user, confirmation: "EXECUTE SQL")
 ```
 
 See the [API Reference](docs/api-reference.md) for complete documentation of all console APIs.
@@ -164,7 +182,7 @@ For working examples and complete demonstrations, check out the [example reposit
 - **Rails-native**: Works seamlessly with Rails conventions
 - **Explicit over magic**: No automatic execution
 - **Safe by default**: Requires explicit confirmation for destructive actions
-- **Power with guardrails**: Emergency SQL escape hatches with safety checks
+- **Code review first**: Generator produces files into working tree; no server-side file writes
 
 ## Development
 
@@ -174,9 +192,9 @@ To install this gem locally, run `bundle exec rake install`. To release a new ve
 
 ## Test Coverage
 
-See [COVERAGE.md](COVERAGE.md) for detailed coverage information.
-
-**Total Coverage: 84.97%**
+See [COVERAGE.md](COVERAGE.md) for detailed coverage information. The bundled report was
+generated against an earlier tree and will be regenerated as part of the next release cycle
+(run `bundle exec rspec` with SimpleCov, then `ruby scripts/generate_coverage_report.rb`).
 
 ## Contributing
 

data/Rakefile

@@ -6,6 +6,11 @@
 # - rake release: Build, tag, push to git, and publish to RubyGems.org
 require "bundler/gem_tasks"
 
+# Minimal Rails + engine task load so `bundle exec rake trigger:*` works from this repo
+# (host apps load these via Rails::Engine#rake_tasks instead).
+Dir[File.expand_path("rakelib/**/*.rake", __dir__)].each { |f| load f }
+load File.expand_path("lib/tasks/trigger_migrations.rake", __dir__)
+
 # RSpec tasks:
 # - rake spec: Run the test suite
 require "rspec/core/rake_task"

data/app/controllers/concerns/pg_sql_triggers/permission_checking.rb

@@ -7,7 +7,7 @@ module PgSqlTriggers
     included do
       # Helper methods available in views
       helper_method :current_actor, :can_view_triggers?, :can_enable_disable_triggers?,
-                    :can_drop_triggers?, :can_execute_sql?, :can_generate_triggers?, :can_apply_triggers?
+                    :can_drop_triggers?, :can_execute_sql_operations?, :can_generate_triggers?, :can_apply_triggers?
     end
 
     # Returns the current actor (user) performing the action.
@@ -67,7 +67,7 @@ module PgSqlTriggers
       redirect_to root_path, alert: "Insufficient permissions. Operator role required."
     end
 
-    # Checks if current actor has admin permissions (drop/re-execute/execute SQL).
+    # Checks if current actor has admin permissions (drop/re-execute).
     #
     # @raise [ActionController::RedirectError] Redirects if permission denied
     def check_admin_permission
@@ -99,14 +99,15 @@ module PgSqlTriggers
       PgSqlTriggers::Permissions.can?(current_actor, :drop_trigger, environment: current_environment)
     end
 
-    # @return [Boolean] true if current actor can execute SQL capsules
-    def can_execute_sql?
+    # @return [Boolean] true if the +:execute_sql+ action is allowed (privileged SQL for host apps;
+    #   not used by built-in UI)
+    def can_execute_sql_operations?
       PgSqlTriggers::Permissions.can?(current_actor, :execute_sql, environment: current_environment)
     end
 
     # @return [Boolean] true if current actor can generate triggers
     def can_generate_triggers?
-      PgSqlTriggers::Permissions.can?(current_actor, :apply_trigger, environment: current_environment)
+      PgSqlTriggers::Permissions.can?(current_actor, :generate_trigger, environment: current_environment)
     end
 
     # @return [Boolean] true if current actor can apply triggers

data/app/controllers/pg_sql_triggers/audit_logs_controller.rb

@@ -4,35 +4,62 @@ module PgSqlTriggers
   class AuditLogsController < ApplicationController
     before_action :check_viewer_permission
 
+    TEXT_SEARCH_SQL = [
+      "trigger_name ILIKE :t",
+      "operation ILIKE :t",
+      "COALESCE(reason, '') ILIKE :t",
+      "COALESCE(error_message, '') ILIKE :t"
+    ].join(" OR ").freeze
+
+    CSV_HEADERS = [
+      "ID", "Trigger Name", "Operation", "Status", "Environment",
+      "Actor Type", "Actor ID", "Reason", "Error Message",
+      "Created At"
+    ].freeze
+
     # GET /audit_logs
     # Display audit log entries with filtering and sorting
     def index
-      @audit_logs = PgSqlTriggers::AuditLog.all
-
-      # Filter by trigger name
-      @audit_logs = @audit_logs.for_trigger(params[:trigger_name]) if params[:trigger_name].present?
+      scope = apply_filters(PgSqlTriggers::AuditLog.all)
+      @audit_logs = scope.order(created_at: sort_direction)
 
-      # Filter by operation
-      @audit_logs = @audit_logs.for_operation(params[:operation]) if params[:operation].present?
+      paginate_audit_logs
+      load_filter_options
 
-      # Filter by status
-      if params[:status].present? && %w[success failure].include?(params[:status])
-        @audit_logs = @audit_logs.where(status: params[:status])
+      respond_to do |format|
+        format.html
+        format.csv { send_csv_response(scope) }
       end
+    end
 
-      # Filter by environment
-      @audit_logs = @audit_logs.for_environment(params[:environment]) if params[:environment].present?
+    private
 
-      # Filter by actor (search in JSONB field)
-      @audit_logs = @audit_logs.where("actor->>'id' = ?", params[:actor_id]) if params[:actor_id].present?
+    def apply_filters(scope)
+      scope = scope.for_trigger(params[:trigger_name]) if params[:trigger_name].present?
+      scope = scope.for_operation(params[:operation]) if params[:operation].present?
+      scope = scope.where(status: params[:status]) if valid_status?(params[:status])
+      scope = scope.for_environment(params[:environment]) if params[:environment].present?
+      scope = scope.where("actor->>'id' = ?", params[:actor_id]) if params[:actor_id].present?
+      apply_text_search(scope)
+    end
 
-      # Sort by date (default: most recent first)
-      sort_direction = params[:sort] == "asc" ? :asc : :desc
-      @audit_logs = @audit_logs.order(created_at: sort_direction)
+    def apply_text_search(scope)
+      return scope if params[:q].blank?
 
-      # Pagination
-      @per_page = (params[:per_page] || 50).to_i
-      @per_page = [@per_page, 200].min # Cap at 200
+      term = "%#{ActiveRecord::Base.sanitize_sql_like(params[:q].to_s.strip)}%"
+      scope.where(TEXT_SEARCH_SQL, t: term)
+    end
+
+    def valid_status?(status)
+      status.present? && %w[success failure].include?(status)
+    end
+
+    def sort_direction
+      params[:sort] == "asc" ? :asc : :desc
+    end
+
+    def paginate_audit_logs
+      @per_page = [(params[:per_page] || 50).to_i, 200].min
       @page = (params[:page] || 1).to_i
       @total_count = @audit_logs.count
       @total_pages = @total_count.positive? ? (@total_count.to_f / @per_page).ceil : 1
@@ -40,63 +67,53 @@ module PgSqlTriggers
 
       offset = (@page - 1) * @per_page
       @audit_logs = @audit_logs.offset(offset).limit(@per_page)
+    end
 
-      # Get distinct values for filter dropdowns
+    def load_filter_options
       @available_trigger_names = PgSqlTriggers::AuditLog.distinct.pluck(:trigger_name).compact.sort
       @available_operations = PgSqlTriggers::AuditLog.distinct.pluck(:operation).compact.sort
       @available_environments = PgSqlTriggers::AuditLog.distinct.pluck(:environment).compact.sort
-
-      respond_to do |format|
-        format.html
-        format.csv do
-          send_data generate_csv, filename: "audit_logs_#{Time.current.strftime('%Y%m%d_%H%M%S')}.csv",
-                                  type: "text/csv", disposition: "attachment"
-        end
-      end
     end
 
-    private
+    def send_csv_response(scope)
+      send_data generate_csv(scope),
+                filename: "audit_logs_#{Time.current.strftime('%Y%m%d_%H%M%S')}.csv",
+                type: "text/csv",
+                disposition: "attachment"
+    end
 
-    def generate_csv
+    def generate_csv(scope)
       require "csv"
 
-      # Get all audit logs (no pagination for CSV)
-      audit_logs = PgSqlTriggers::AuditLog.all
-
-      # Apply filters
-      audit_logs = audit_logs.for_trigger(params[:trigger_name]) if params[:trigger_name].present?
-      audit_logs = audit_logs.for_operation(params[:operation]) if params[:operation].present?
-      if params[:status].present? && %w[success failure].include?(params[:status])
-        audit_logs = audit_logs.where(status: params[:status])
-      end
-      audit_logs = audit_logs.for_environment(params[:environment]) if params[:environment].present?
-      audit_logs = audit_logs.where("actor->>'id' = ?", params[:actor_id]) if params[:actor_id].present?
-
       CSV.generate(headers: true) do |csv|
-        csv << [
-          "ID", "Trigger Name", "Operation", "Status", "Environment",
-          "Actor Type", "Actor ID", "Reason", "Error Message",
-          "Created At"
-        ]
-
-        audit_logs.order(created_at: :desc).find_each do |log|
-          actor_type = log.actor.is_a?(Hash) ? log.actor["type"] || log.actor[:type] : nil
-          actor_id = log.actor.is_a?(Hash) ? log.actor["id"] || log.actor[:id] : nil
-
-          csv << [
-            log.id,
-            log.trigger_name || "",
-            log.operation,
-            log.status,
-            log.environment || "",
-            actor_type || "",
-            actor_id || "",
-            log.reason || "",
-            log.error_message || "",
-            log.created_at&.iso8601 || ""
-          ]
+        csv << CSV_HEADERS
+        scope.order(created_at: :desc).find_each do |log|
+          csv << csv_row_for(log)
         end
       end
     end
+
+    def csv_row_for(log)
+      actor_type, actor_id = extract_actor_fields(log.actor)
+
+      [
+        log.id,
+        log.trigger_name || "",
+        log.operation,
+        log.status,
+        log.environment || "",
+        actor_type || "",
+        actor_id || "",
+        log.reason || "",
+        log.error_message || "",
+        log.created_at&.iso8601 || ""
+      ]
+    end
+
+    def extract_actor_fields(actor)
+      return [nil, nil] unless actor.is_a?(Hash)
+
+      [actor["type"] || actor[:type], actor["id"] || actor[:id]]
+    end
   end
 end

data/app/controllers/pg_sql_triggers/dashboard_controller.rb

@@ -2,49 +2,126 @@
 
 module PgSqlTriggers
   class DashboardController < ApplicationController
+    helper DashboardHelper
+
     before_action :check_viewer_permission
 
+    DRIFT_STATE_PARAM_MAP = {
+      "in_sync" => PgSqlTriggers::DRIFT_STATE_IN_SYNC,
+      "drifted" => PgSqlTriggers::DRIFT_STATE_DRIFTED,
+      "disabled" => PgSqlTriggers::DRIFT_STATE_DISABLED,
+      "dropped" => PgSqlTriggers::DRIFT_STATE_DROPPED,
+      "unknown" => PgSqlTriggers::DRIFT_STATE_UNKNOWN,
+      "manual_override" => PgSqlTriggers::DRIFT_STATE_MANUAL_OVERRIDE
+    }.freeze
+
+    SOURCE_OPTIONS = %w[dsl generated manual_sql].freeze
+
     def index
-      # Sort by installed_at descending (most recent first), fallback to created_at
-      @triggers = PgSqlTriggers::TriggerRegistry.order(
+      load_filters
+      load_triggers
+      load_migration_status
+    end
+
+    private
+
+    def load_filters
+      @filter_table = params[:table].presence
+      @filter_state = params[:state].presence
+      @filter_source = params[:source].presence
+      @filter_query = params[:q].presence
+    end
+
+    def load_triggers
+      ordered = PgSqlTriggers::TriggerRegistry.order(
         Arel.sql("COALESCE(installed_at, created_at) DESC")
       )
+      drift_results = PgSqlTriggers::Drift::Detector.detect_all
+      @stats = build_stats(ordered, drift_results)
+
+      filtered = apply_trigger_filters(ordered, drift_results)
+      @trigger_list_total = filtered.count
+
+      paginate_triggers(filtered)
+      @filter_table_names = PgSqlTriggers::TriggerRegistry.distinct.order(:table_name).pluck(:table_name)
+    end
+
+    def paginate_triggers(filtered)
+      @trigger_per_page = [(params[:trigger_per_page] || 20).to_i, 100].min
+      @trigger_page = (params[:trigger_page] || 1).to_i
+      @trigger_total_pages = @trigger_list_total.positive? ? (@trigger_list_total.to_f / @trigger_per_page).ceil : 1
+      @trigger_page = @trigger_page.clamp(1, [@trigger_total_pages, 1].max)
+
+      offset = (@trigger_page - 1) * @trigger_per_page
+      @triggers = filtered.offset(offset).limit(@trigger_per_page)
+    end
+
+    def load_migration_status
+      all_migrations = PgSqlTriggers::Migrator.status
+      @pending_migrations = PgSqlTriggers::Migrator.pending_migrations
+      @current_migration_version = PgSqlTriggers::Migrator.current_version
+
+      paginate_migrations(all_migrations)
+    rescue StandardError => e
+      Rails.logger.error("Failed to fetch migration status: #{e.message}")
+      reset_migration_defaults
+    end
+
+    def paginate_migrations(all_migrations)
+      @per_page = [(params[:per_page] || 20).to_i, 100].min
+      @page = (params[:page] || 1).to_i
+      @total_migrations = all_migrations.count
+      @total_pages = @total_migrations.positive? ? (@total_migrations.to_f / @per_page).ceil : 1
+      @page = @page.clamp(1, @total_pages)
+
+      migration_offset = (@page - 1) * @per_page
+      @migration_status = all_migrations.slice(migration_offset, @per_page) || []
+    end
 
-      # Get drift summary
-      drift_summary = PgSqlTriggers::Drift::Reporter.summary
-      @stats = {
-        total: @triggers.count,
-        enabled: @triggers.enabled.count,
-        disabled: @triggers.disabled.count,
-        drifted: drift_summary[:drifted]
+    def reset_migration_defaults
+      @migration_status = []
+      @pending_migrations = []
+      @current_migration_version = 0
+      @total_migrations = 0
+      @total_pages = 1
+      @page = 1
+      @per_page = 20
+    end
+
+    def build_stats(ordered_scope, drift_results)
+      {
+        total: ordered_scope.count,
+        enabled: ordered_scope.enabled.count,
+        disabled: ordered_scope.disabled.count,
+        drifted: drift_results.count { |r| r[:state] == PgSqlTriggers::DRIFT_STATE_DRIFTED }
       }
+    end
+
+    def apply_trigger_filters(relation, drift_results)
+      scoped = relation
+      scoped = scoped.for_table(@filter_table) if @filter_table.present?
 
-      # Migration status with pagination
-      begin
-        all_migrations = PgSqlTriggers::Migrator.status
-        @pending_migrations = PgSqlTriggers::Migrator.pending_migrations
-        @current_migration_version = PgSqlTriggers::Migrator.current_version
-
-        # Pagination
-        @per_page = (params[:per_page] || 20).to_i
-        @per_page = [@per_page, 100].min # Cap at 100
-        @page = (params[:page] || 1).to_i
-        @total_migrations = all_migrations.count
-        @total_pages = @total_migrations.positive? ? (@total_migrations.to_f / @per_page).ceil : 1
-        @page = @page.clamp(1, @total_pages) # Ensure page is within valid range
-
-        offset = (@page - 1) * @per_page
-        @migration_status = all_migrations.slice(offset, @per_page) || []
-      rescue StandardError => e
-        Rails.logger.error("Failed to fetch migration status: #{e.message}")
-        @migration_status = []
-        @pending_migrations = []
-        @current_migration_version = 0
-        @total_migrations = 0
-        @total_pages = 1
-        @page = 1
-        @per_page = 20
+      scoped = scoped.by_source(@filter_source) if @filter_source.present? && SOURCE_OPTIONS.include?(@filter_source)
+
+      scoped = scoped.matching_search(@filter_query) if @filter_query.present?
+
+      if @filter_state.present? && DRIFT_STATE_PARAM_MAP.key?(@filter_state)
+        scoped = filter_by_drift_state(scoped, drift_results, DRIFT_STATE_PARAM_MAP[@filter_state])
+      end
+
+      scoped
+    end
+
+    def filter_by_drift_state(relation, drift_results, drift_constant)
+      names = drift_results.each_with_object([]) do |result, acc|
+        next unless result[:state] == drift_constant
+
+        entry = result[:registry_entry]
+        acc << entry.trigger_name if entry
       end
+      return relation.none if names.empty?
+
+      relation.where(trigger_name: names)
     end
   end
 end

data/app/controllers/pg_sql_triggers/migrations_controller.rb

@@ -82,13 +82,13 @@ module PgSqlTriggers
         return
       end
 
-      if target_version
-        redo_target_migration(target_version, current_version)
-      else
-        PgSqlTriggers::Migrator.run_down
-        PgSqlTriggers::Migrator.run_up
-        flash[:success] = "Last migration redone successfully."
-      end
+      flash[:success] = if target_version
+                          redo_target_migration(target_version, current_version)
+                        else
+                          PgSqlTriggers::Migrator.run_down
+                          PgSqlTriggers::Migrator.run_up
+                          "Last migration redone successfully."
+                        end
       redirect_to root_path
     rescue PgSqlTriggers::KillSwitchError => e
       flash[:error] = e.message
@@ -107,10 +107,11 @@ module PgSqlTriggers
       redirect_to root_path, alert: "Insufficient permissions. Operator role required."
     end
 
+    # Returns the flash message that should be set by the caller after a successful redo.
     def redo_target_migration(target_version, current_version)
-      # For redo, we need to rollback the specific migration and re-apply it
-      # If target_version is the current version, rollback the last migration
-      # Otherwise, rollback to one version before target, then run up to target
+      # For redo, we need to rollback the specific migration and re-apply it.
+      # If target_version is the current version, rollback the last migration.
+      # Otherwise, rollback to one version before target, then run up to target.
       if current_version == target_version
         # Rollback the last migration (which is the target)
         PgSqlTriggers::Migrator.run_down
@@ -119,14 +120,12 @@ module PgSqlTriggers
       else
         # Target version is not applied yet, just run it up
         PgSqlTriggers::Migrator.run_up(target_version)
-        flash[:success] = "Migration #{target_version} redone successfully."
-        redirect_to root_path
-        return
+        return "Migration #{target_version} redone successfully."
       end
 
       # Now run up to the target version
       PgSqlTriggers::Migrator.run_up(target_version)
-      flash.now[:success] = "Migration #{target_version} redone successfully."
+      "Migration #{target_version} redone successfully."
     end
 
     def rollback_to_before_target(target_version)

data/app/controllers/pg_sql_triggers/tables_controller.rb

@@ -23,6 +23,14 @@ module PgSqlTriggers
                           all_tables
                         end
 
+      @search_query = params[:q].to_s.strip
+      if @search_query.present?
+        needle = @search_query.downcase
+        filtered_tables = filtered_tables.select do |row|
+          row[:table_name].to_s.downcase.include?(needle)
+        end
+      end
+
       @total_tables = filtered_tables.count
 
       # Pagination

data/app/controllers/pg_sql_triggers/triggers_controller.rb

@@ -12,6 +12,7 @@ module PgSqlTriggers
     def show
       # Load trigger details and drift information
       @drift_info = calculate_drift_info
+      @dependency_related = PgSqlTriggers::Registry::Validator.related_triggers_for_show(@trigger)
     end
 
     def enable

data/app/helpers/pg_sql_triggers/dashboard_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  # URL helpers for dashboard list filters and dual pagination (triggers vs migrations).
+  module DashboardHelper
+    # Params to preserve when linking within the dashboard (filters + both paginations).
+    DASHBOARD_PARAM_KEYS = %i[
+      table state source q
+      trigger_page trigger_per_page
+      page per_page
+    ].freeze
+
+    def dashboard_list_params(extra = {})
+      keys = DashboardHelper::DASHBOARD_PARAM_KEYS
+      base = params.permit(*keys).to_h.symbolize_keys
+      base.merge(extra.symbolize_keys).compact_blank
+    end
+  end
+end

data/app/helpers/pg_sql_triggers/permissions_helper.rb

@@ -25,8 +25,9 @@ module PgSqlTriggers
       can?(:drop_trigger)
     end
 
-    # Check if the current actor can execute SQL capsules
-    def can_execute_sql?
+    # Check if the current actor has the +:execute_sql+ permission (admin-level SQL;
+    # host apps may use this in custom tooling — not used by built-in UI)
+    def can_execute_sql_operations?
       can?(:execute_sql)
     end