feat: add sortable column headers to all job list tables (#24)

Add clickable column headers for sorting across all job tables:
- Ready Jobs: class_name, queue_name, priority, created_at
- Scheduled Jobs: class_name, queue_name, scheduled_at
- Failed Jobs: class_name, queue_name, created_at
- In Progress Jobs: class_name, queue_name, created_at
- Recurring Jobs: key, class_name, queue_name, priority
- Jobs: class_name, queue_name, status, created_at
- Queues: queue_name, job_count
- Workers: hostname, last_heartbeat_at

Features:
- Click to sort ascending, click again for descending
- Visual indicators: ↑ (asc), ↓ (desc), ⇅ (default/sortable)
- Sort state preserved across pagination and filtering
- Special handling for execution tables with JOIN queries
- Special handling for GROUP BY queries on queues page

Includes comprehensive test coverage with 27 new specs.

Author: vishaltps

.rubocop.yml

@@ -27,7 +27,7 @@ Metrics/ClassLength:
     - 'app/presenters/solid_queue_monitor/job_details_presenter.rb'
 
 Metrics/ParameterLists:
-  Max: 7
+  Max: 8
 
 Metrics/ModuleLength:
   Max: 200

app/controllers/solid_queue_monitor/base_controller.rb

@@ -202,5 +202,36 @@ def filter_params
         status: params[:status]
       }
     end
+
+    def sort_params
+      {
+        sort_by: params[:sort_by],
+        sort_direction: params[:sort_direction]
+      }
+    end
+
+    def apply_sorting(relation, allowed_columns, default_column, default_direction = :desc)
+      column = sort_params[:sort_by]
+      direction = sort_params[:sort_direction]
+      column = default_column unless allowed_columns.include?(column)
+      direction = %w[asc desc].include?(direction) ? direction.to_sym : default_direction
+      relation.order(column => direction)
+    end
+
+    def apply_execution_sorting(relation, allowed_columns, default_column, default_direction = :desc)
+      column = sort_params[:sort_by]
+      direction = sort_params[:sort_direction]
+      column = default_column unless allowed_columns.include?(column)
+      direction = %w[asc desc].include?(direction) ? direction.to_sym : default_direction
+
+      # Columns that exist on the jobs table, not on execution tables
+      job_table_columns = %w[class_name queue_name]
+
+      if job_table_columns.include?(column)
+        relation.joins(:job).order("solid_queue_jobs.#{column}" => direction)
+      else
+        relation.order(column => direction)
+      end
+    end
   end
 end

app/controllers/solid_queue_monitor/failed_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class FailedJobsController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name created_at].freeze
+
     def index
-      base_query = SolidQueue::FailedExecution.includes(:job).order(created_at: :desc)
-      @failed_jobs = paginate(filter_failed_jobs(base_query))
+      base_query = SolidQueue::FailedExecution.includes(:job)
+      sorted_query = apply_execution_sorting(filter_failed_jobs(base_query), SORTABLE_COLUMNS, 'created_at', :desc)
+      @failed_jobs = paginate(sorted_query)
 
       render_page('Failed Jobs', SolidQueueMonitor::FailedJobsPresenter.new(@failed_jobs[:records],
                                                                             current_page: @failed_jobs[:current_page],
                                                                             total_pages: @failed_jobs[:total_pages],
-                                                                            filters: filter_params).render)
+                                                                            filters: filter_params,
+                                                                            sort: sort_params).render)
     end
 
     def retry

app/controllers/solid_queue_monitor/in_progress_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class InProgressJobsController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name created_at].freeze
+
     def index
-      base_query = SolidQueue::ClaimedExecution.includes(:job).order(created_at: :desc)
-      @in_progress_jobs = paginate(filter_in_progress_jobs(base_query))
+      base_query = SolidQueue::ClaimedExecution.includes(:job)
+      sorted_query = apply_execution_sorting(filter_in_progress_jobs(base_query), SORTABLE_COLUMNS, 'created_at', :desc)
+      @in_progress_jobs = paginate(sorted_query)
 
       render_page('In Progress Jobs', SolidQueueMonitor::InProgressJobsPresenter.new(@in_progress_jobs[:records],
                                                                                      current_page: @in_progress_jobs[:current_page],
                                                                                      total_pages: @in_progress_jobs[:total_pages],
-                                                                                     filters: filter_params).render)
+                                                                                     filters: filter_params,
+                                                                                     sort: sort_params).render)
     end
 
     private

app/controllers/solid_queue_monitor/overview_controller.rb

@@ -2,12 +2,15 @@
 
 module SolidQueueMonitor
   class OverviewController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name created_at].freeze
+
     def index
       @stats = SolidQueueMonitor::StatsCalculator.calculate
       @chart_data = SolidQueueMonitor::ChartDataService.new(time_range: time_range_param).calculate
 
-      recent_jobs_query = SolidQueue::Job.order(created_at: :desc).limit(100)
-      @recent_jobs = paginate(filter_jobs(recent_jobs_query))
+      recent_jobs_query = SolidQueue::Job.limit(100)
+      sorted_query = apply_sorting(filter_jobs(recent_jobs_query), SORTABLE_COLUMNS, 'created_at', :desc)
+      @recent_jobs = paginate(sorted_query)
 
       preload_job_statuses(@recent_jobs[:records])
 
@@ -31,7 +34,8 @@ def generate_overview_content
         SolidQueueMonitor::JobsPresenter.new(@recent_jobs[:records],
                                              current_page: @recent_jobs[:current_page],
                                              total_pages: @recent_jobs[:total_pages],
-                                             filters: filter_params).render
+                                             filters: filter_params,
+                                             sort: sort_params).render
     end
   end
 end

app/controllers/solid_queue_monitor/queues_controller.rb

@@ -2,23 +2,26 @@
 
 module SolidQueueMonitor
   class QueuesController < BaseController
+    SORTABLE_COLUMNS = %w[queue_name job_count].freeze
+    QUEUE_DETAILS_SORTABLE_COLUMNS = %w[class_name created_at].freeze
+
     def index
-      @queues = SolidQueue::Job.group(:queue_name)
-                               .select('queue_name, COUNT(*) as job_count')
-                               .order('job_count DESC')
+      base_query = SolidQueue::Job.group(:queue_name)
+                                  .select('queue_name, COUNT(*) as job_count')
+      @queues = apply_queue_sorting(base_query)
       @paused_queues = QueuePauseService.paused_queues
 
-      render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(@queues, @paused_queues).render)
+      render_page('Queues', SolidQueueMonitor::QueuesPresenter.new(@queues, @paused_queues, sort: sort_params).render)
     end
 
     def show
       @queue_name = params[:queue_name]
       @paused = QueuePauseService.paused_queues.include?(@queue_name)
 
       # Get all jobs for this queue with filtering and pagination
-      base_query = SolidQueue::Job.where(queue_name: @queue_name).order(created_at: :desc)
-      filtered_query = filter_queue_jobs(base_query)
-      @jobs = paginate(filtered_query)
+      base_query = SolidQueue::Job.where(queue_name: @queue_name)
+      sorted_query = apply_sorting(filter_queue_jobs(base_query), QUEUE_DETAILS_SORTABLE_COLUMNS, 'created_at', :desc)
+      @jobs = paginate(sorted_query)
       preload_job_statuses(@jobs[:records])
 
       @counts = calculate_queue_counts(@queue_name)
@@ -31,7 +34,8 @@ def show
                     counts: @counts,
                     current_page: @jobs[:current_page],
                     total_pages: @jobs[:total_pages],
-                    filters: queue_filter_params
+                    filters: queue_filter_params,
+                    sort: sort_params
                   ).render)
     end
 
@@ -97,5 +101,14 @@ def queue_filter_params
         status: params[:status]
       }
     end
+
+    def apply_queue_sorting(relation)
+      column = sort_params[:sort_by]
+      direction = sort_params[:sort_direction]
+      column = 'job_count' unless SORTABLE_COLUMNS.include?(column)
+      direction = 'desc' unless %w[asc desc].include?(direction)
+
+      relation.order("#{column} #{direction}")
+    end
   end
 end

app/controllers/solid_queue_monitor/ready_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class ReadyJobsController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name priority created_at].freeze
+
     def index
-      base_query = SolidQueue::ReadyExecution.includes(:job).order(created_at: :desc)
-      @ready_jobs = paginate(filter_ready_jobs(base_query))
+      base_query = SolidQueue::ReadyExecution.includes(:job)
+      sorted_query = apply_execution_sorting(filter_ready_jobs(base_query), SORTABLE_COLUMNS, 'created_at', :desc)
+      @ready_jobs = paginate(sorted_query)
 
       render_page('Ready Jobs', SolidQueueMonitor::ReadyJobsPresenter.new(@ready_jobs[:records],
                                                                           current_page: @ready_jobs[:current_page],
                                                                           total_pages: @ready_jobs[:total_pages],
-                                                                          filters: filter_params).render)
+                                                                          filters: filter_params,
+                                                                          sort: sort_params).render)
     end
   end
 end

app/controllers/solid_queue_monitor/recurring_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class RecurringJobsController < BaseController
+    SORTABLE_COLUMNS = %w[key class_name queue_name priority].freeze
+
     def index
-      base_query = filter_recurring_jobs(SolidQueue::RecurringTask.order(:key))
-      @recurring_jobs = paginate(base_query)
+      base_query = filter_recurring_jobs(SolidQueue::RecurringTask.all)
+      sorted_query = apply_sorting(base_query, SORTABLE_COLUMNS, 'key', :asc)
+      @recurring_jobs = paginate(sorted_query)
 
       render_page('Recurring Jobs', SolidQueueMonitor::RecurringJobsPresenter.new(@recurring_jobs[:records],
                                                                                   current_page: @recurring_jobs[:current_page],
                                                                                   total_pages: @recurring_jobs[:total_pages],
-                                                                                  filters: filter_params).render)
+                                                                                  filters: filter_params,
+                                                                                  sort: sort_params).render)
     end
   end
 end

app/controllers/solid_queue_monitor/scheduled_jobs_controller.rb

@@ -2,14 +2,18 @@
 
 module SolidQueueMonitor
   class ScheduledJobsController < BaseController
+    SORTABLE_COLUMNS = %w[class_name queue_name scheduled_at].freeze
+
     def index
-      base_query = SolidQueue::ScheduledExecution.includes(:job).order(scheduled_at: :asc)
-      @scheduled_jobs = paginate(filter_scheduled_jobs(base_query))
+      base_query = SolidQueue::ScheduledExecution.includes(:job)
+      sorted_query = apply_execution_sorting(filter_scheduled_jobs(base_query), SORTABLE_COLUMNS, 'scheduled_at', :asc)
+      @scheduled_jobs = paginate(sorted_query)
 
       render_page('Scheduled Jobs', SolidQueueMonitor::ScheduledJobsPresenter.new(@scheduled_jobs[:records],
                                                                                   current_page: @scheduled_jobs[:current_page],
                                                                                   total_pages: @scheduled_jobs[:total_pages],
-                                                                                  filters: filter_params).render)
+                                                                                  filters: filter_params,
+                                                                                  sort: sort_params).render)
     end
 
     def create

app/controllers/solid_queue_monitor/workers_controller.rb

@@ -2,16 +2,19 @@
 
 module SolidQueueMonitor
   class WorkersController < BaseController
+    SORTABLE_COLUMNS = %w[hostname last_heartbeat_at].freeze
+
     def index
-      base_query = SolidQueue::Process.order(created_at: :desc)
-      filtered_query = filter_workers(base_query)
-      @processes = paginate(filtered_query)
+      base_query = SolidQueue::Process.all
+      sorted_query = apply_sorting(filter_workers(base_query), SORTABLE_COLUMNS, 'last_heartbeat_at', :desc)
+      @processes = paginate(sorted_query)
 
       render_page('Workers', SolidQueueMonitor::WorkersPresenter.new(
         @processes[:records],
         current_page: @processes[:current_page],
         total_pages: @processes[:total_pages],
-        filters: worker_filter_params
+        filters: worker_filter_params,
+        sort: sort_params
       ).render)
     end