tramway 4.0.2 → 4.1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1254075cd4e025f5a4f46d4951fc391bd8c90a4c1a486b3bbe471b0d79cfebb
-  data.tar.gz: d37cb6b0408b55f635f75b8cc8f0fb90d5d5efa454a1db5c4303fdf800e45726
+  metadata.gz: b7992bbaa872dc64b21203cb0350463136687e0bfe033a1b461c87bf15804f6b
+  data.tar.gz: 24024ccfa23c7e0718a8dcfd708ce4fcfe232e67c352e5fa28360b017f0b323e
 SHA512:
-  metadata.gz: 29d854a96abfcadda07911e326932a2347c509a0465dc5e6d4c19533dd7b5299f05aa011d3d928490dc6a17969143dc0490f81206618ecd13bd37040bc5306a3
-  data.tar.gz: d176134cef60ad20d9c2617067d0e4c498a966fef4119ef182dd2d13b32ae7919cce4ab2a3d18d076b0a20a7a6a08bda88b667190c072bfd41a2021ffa84c1af
+  metadata.gz: 5a8e09bf7ab1d4c09d881f87d99cd1ab5841e92b29a17e2bab144bc009e70263af0cf3ffc71930a027dd589beb13f50c933f4ffcc9fb292e3c36e75f2015b699
+  data.tar.gz: 0110e0d22d0f745d459021d97b929ed4915e08d292a706d7a06dd0c409cd2426c42f2fdb0e40af5ef243e1609b8c37c5ad20204c38b7d16db4f4d0f9d5599b89

data/README.md

@@ -1,6 +1,11 @@
 # Tramway
 Unite Ruby on Rails brilliance. Streamline development with Tramway.
 
+> **AI agents: read this first.** Before writing or changing any code in a Rails app that uses Tramway, install and
+> use the [`tramway-skill`](https://github.com/Purple-Magic/tramway-skill/) skill — it is mandatory for Tramway work
+> and is the authoritative, up-to-date playbook for Tramway's conventions (CRUD, Forms, Decorators, Navbar, Plugins,
+> and more). Do not generate Tramway-related code from memory alone.
+
 Tramway ships with full CRUD (index, show, create, update, destroy) out of the box. Its install generator also adds a
 Codex instruction that points agents to the Tramway skill for Tramway-native code generation.
 
@@ -1558,10 +1563,19 @@ Autocomplete select example:
 <% end %>
 ```
 
-`autocomplete: true` renders an autocomplete-enabled select. It cannot be used together with `multiselect: true` in the
-same select field.
+`autocomplete: true` renders an autocomplete-enabled select. It can be combined with `multiple: true` to get a
+searchable multi-select:
+
+```erb
+<%= tramway_form_for @user do |f| %>
+  <%= f.select :departments, [['Engineering', 'engineering'], ['Sales', 'sales']], autocomplete: true, multiple: true %>
+<% end %>
+```
+
+With both options set, the search input stays visible after each selection so you can keep filtering and picking
+more options; selected options still show as removable tags.
 
-When you use `multiselect: true`, make sure any preselected values still exist in the collection you render. Unknown
+When you use `multiple: true`, make sure any preselected values still exist in the collection you render. Unknown
 values are ignored by the widget so the select can still boot safely.
 
 **Examples**
@@ -1766,6 +1780,48 @@ Tramway.configure do |config|
 end
 ```
 
+## Plugins
+
+Plugins add optional, ready-made dashboards to your app, mounted and styled with Tramway. Enable one by name and,
+optionally, configure it:
+
+```ruby
+Tramway.configure do |config|
+  config.plugins = [:solid_queue]
+  config.plugins.solid_queue = {
+    path: '/jobs'
+  }
+end
+```
+
+Enabling a plugin also adds a navbar entry for it automatically (see [Tramway
+Navbar](#tramway-navbar)).
+
+### SolidQueue
+
+The `:solid_queue` plugin is a dashboard for inspecting and managing [SolidQueue](https://github.com/rails/solid_queue)
+jobs. It requires the `solid_queue` gem in your Gemfile — if it's missing, Tramway raises a clear error explaining
+how to fix it instead of failing deep inside a controller.
+
+It gives you:
+
+- A paginated, filterable jobs list (by status, queue, class name, or free-text search by class name/active job
+  ID/numeric ID), with per-status counts.
+- A job detail page, including failure details (exception class, message, backtrace) for failed jobs.
+- Retry, discard and destroy for a single job, or in bulk for a selection of jobs — or "Destroy all" to destroy
+  every job matching the currently active filters at once. Bulk actions and "Destroy all" run in the background
+  (you'll see a flash message confirming the action was queued, not completed instantly) on their own dedicated
+  worker queue, which `tramway:install` sets up for you.
+- A queues list with size/running/latency/throughput, and pause/resume/clear actions per queue. "Size" only counts
+  jobs waiting to run — "Running" shows jobs currently executing on that queue, so a queue processing one big job
+  (e.g. a large "Destroy all") doesn't look idle just because nothing is waiting behind it.
+- A recurring tasks list with the ability to enqueue a task immediately.
+- Jobs, queues, and recurring tasks lists (and the job detail page) refresh themselves in the background every few
+  seconds, so job status changes show up without reloading the page.
+
+See [docs/users/tramway_solid_queue_plugin.md](docs/users/tramway_solid_queue_plugin.md) for more on what "discard"
+does and other SolidQueue-specific behavior.
+
 ## Lantern Color Palette
 
   | Type | Color |

data/app/assets/javascripts/tramway/tramway.js

@@ -1,5 +1,5 @@
 import { Controller } from "@hotwired/stimulus"
-/* global console */
+/* global console, fetch, setInterval, clearInterval, DOMParser */
 
 class TramwaySelect extends Controller {
   static targets = ["dropdown", "showSelectedArea", "hiddenInput", "caretDown", "caretUp"]
@@ -26,7 +26,7 @@ class TramwaySelect extends Controller {
     this.items = JSON.parse(this.element.dataset.items).map((item, index) => {
       return {
         index,
-        text: item.text,
+        text: item.text == null ? '' : item.text.toString(),
         value: item.value.toString(),
         selected: false
       }
@@ -59,7 +59,7 @@ class TramwaySelect extends Controller {
 
     let content = allItems;
 
-    if (this.autocomplete() && this.selectedItems.length === 0) {
+    if (this.autocomplete() && (this.multiple() || this.selectedItems.length === 0)) {
       content += this.element.dataset.autocompleteInput;
     }
 
@@ -80,7 +80,14 @@ class TramwaySelect extends Controller {
     }
   }
 
-  toggleDropdown() {
+  toggleDropdown(event) {
+    // Clicking into the autocomplete search input bubbles up to this action. While the dropdown
+    // is already open, that click should keep it open (so the user can keep typing/selecting)
+    // rather than close it on every refocus.
+    if (this.dropdownState === 'open' && event && event.target.tagName === 'INPUT') {
+      return;
+    }
+
     if (this.dropdownState === 'closed') {
       this.openDropdown();
     } else {
@@ -103,6 +110,14 @@ class TramwaySelect extends Controller {
 
     this.caretDownTarget.classList.add('hidden');
     this.caretUpTarget.classList.remove('hidden');
+
+    if (this.autocomplete()) {
+      this.searchInput()?.focus();
+    }
+  }
+
+  searchInput() {
+    return this.showSelectedAreaTarget.querySelector('input');
   }
 
   dropdown() {
@@ -564,4 +579,60 @@ class Collapsible extends Controller {
   }
 }
 
-export { TramwaySelect, UiCheckbox, Tooltip, Navbar, Collapsible }
+// Periodically re-fetches the current page and swaps the innerHTML of each marked
+// "refreshable" target by id, so pages reflect background changes (e.g. job status moving
+// through SolidQueue) without a full reload. A target is skipped while it has a checked
+// checkbox or focus inside it, so an in-progress bulk selection or form entry isn't clobbered.
+class AutoRefresh extends Controller {
+  static targets = ["refreshable"]
+
+  static values = {
+    interval: { type: Number, default: 4000 }
+  }
+
+  connect() {
+    this.refreshing = false
+    this.timer = setInterval(() => this.refresh(), this.intervalValue)
+  }
+
+  disconnect() {
+    clearInterval(this.timer)
+  }
+
+  async refresh() {
+    if (this.refreshing || document.hidden) return
+
+    this.refreshing = true
+
+    try {
+      const response = await fetch(window.location.href, { headers: { 'X-Requested-With': 'XMLHttpRequest' } })
+
+      if (!response.ok) return
+
+      const next = new DOMParser().parseFromString(await response.text(), 'text/html')
+
+      this.refreshableTargets.forEach((target) => this.updateTarget(target, next))
+    } finally {
+      this.refreshing = false
+    }
+  }
+
+  updateTarget(target, next) {
+    if (!target.id || this.hasPendingInput(target)) return
+
+    const replacement = next.getElementById(target.id)
+
+    if (replacement) {
+      target.innerHTML = replacement.innerHTML
+    }
+  }
+
+  hasPendingInput(target) {
+    const focused = target.contains(document.activeElement) &&
+      document.activeElement.matches('input, textarea, select')
+
+    return target.querySelector('input:checked') !== null || focused
+  }
+}
+
+export { TramwaySelect, UiCheckbox, Tooltip, Navbar, Collapsible, AutoRefresh }

data/app/controllers/tramway/plugins/solid_queue/application_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'tramway/plugins'
+
+module Tramway
+  module Plugins
+    module SolidQueue
+      # Base controller for the solid_queue plugin dashboard
+      class ApplicationController < Tramway.config.application_controller.constantize
+        prepend_view_path "#{Gem::Specification.find_by_name('tramway').gem_dir}/app/views"
+
+        layout 'tramway/layouts/application'
+
+        helper Tramway::ApplicationHelper
+        helper Tramway::Plugins::SolidQueue::JobsHelper
+        include Rails.application.routes.url_helpers
+
+        before_action :ensure_solid_queue_available!
+
+        private
+
+        def ensure_solid_queue_available!
+          Tramway::Plugins.fetch(:solid_queue).ensure_available!
+        end
+      end
+    end
+  end
+end

data/app/controllers/tramway/plugins/solid_queue/jobs_controller.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Tramway
+  module Plugins
+    module SolidQueue
+      # Lists, filters and manages SolidQueue jobs for the plugin dashboard
+      class JobsController < ApplicationController
+        def index
+          @jobs = jobs_filter.jobs.order(id: :desc).page(params[:page])
+          @status_counts = jobs_filter.status_counts
+          @queue_names = ::SolidQueue::Job.distinct.order(:queue_name).pluck(:queue_name)
+          @class_names = ::SolidQueue::Job.distinct.order(:class_name).pluck(:class_name)
+        end
+
+        def show
+          @job = job
+        end
+
+        def destroy
+          job.destroy
+
+          redirect_to jobs_path, notice: t('tramway.plugins.solid_queue.notices.destroyed')
+        end
+
+        def retry
+          job.retry
+
+          redirect_to jobs_path, notice: t('tramway.plugins.solid_queue.notices.retried')
+        end
+
+        def discard
+          job.discard
+
+          redirect_to jobs_path, notice: t('tramway.plugins.solid_queue.notices.discarded')
+        end
+
+        def bulk_retry
+          Tramway::SolidQueue::BulkRetryJob.perform_later(selected_job_ids)
+
+          redirect_to jobs_path, notice: t('tramway.plugins.solid_queue.notices.bulk_retry_enqueued')
+        end
+
+        def bulk_discard
+          Tramway::SolidQueue::BulkDiscardJob.perform_later(selected_job_ids)
+
+          redirect_to jobs_path, notice: t('tramway.plugins.solid_queue.notices.bulk_discard_enqueued')
+        end
+
+        def bulk_destroy
+          Tramway::SolidQueue::BulkDestroyJob.perform_later(selected_job_ids)
+
+          redirect_to jobs_path, notice: t('tramway.plugins.solid_queue.notices.bulk_destroy_enqueued')
+        end
+
+        def destroy_all
+          Tramway::SolidQueue::DestroyAllJob.perform_later(filter_params)
+
+          redirect_to jobs_path(request.query_parameters.except('page')),
+                      notice: t('tramway.plugins.solid_queue.notices.destroy_all_enqueued')
+        end
+
+        private
+
+        def job
+          @job ||= ::SolidQueue::Job.find(params.expect(:id))
+        end
+
+        def jobs_filter
+          @jobs_filter ||= Tramway::SolidQueue::JobsFilter.new(filter_params)
+        end
+
+        def filter_params
+          params.permit(:status, :queue_name, :class_name, :query).to_h
+        end
+
+        def selected_job_ids
+          Array(params[:job_ids]).map(&:to_i)
+        end
+      end
+    end
+  end
+end

data/app/controllers/tramway/plugins/solid_queue/queues_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Tramway
+  module Plugins
+    module SolidQueue
+      # Lists SolidQueue queues and lets the user pause/resume/clear them
+      class QueuesController < ApplicationController
+        def index
+          @queues = ::SolidQueue::Queue.all.sort_by(&:name)
+        end
+
+        def pause
+          queue.pause
+
+          redirect_to queues_path, notice: t('tramway.plugins.solid_queue.notices.paused')
+        end
+
+        def resume
+          queue.resume
+
+          redirect_to queues_path, notice: t('tramway.plugins.solid_queue.notices.resumed')
+        end
+
+        def clear
+          queue.clear
+
+          redirect_to queues_path, notice: t('tramway.plugins.solid_queue.notices.cleared')
+        end
+
+        private
+
+        def queue
+          @queue ||= ::SolidQueue::Queue.find_by_name(params.expect(:name))
+        end
+      end
+    end
+  end
+end

data/app/controllers/tramway/plugins/solid_queue/recurring_tasks_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Tramway
+  module Plugins
+    module SolidQueue
+      # Lists SolidQueue recurring tasks and lets the user enqueue one immediately
+      class RecurringTasksController < ApplicationController
+        def index
+          @recurring_tasks = ::SolidQueue::RecurringTask.order(:key)
+        end
+
+        def enqueue
+          recurring_task.enqueue(at: Time.current)
+
+          redirect_to recurring_tasks_path, notice: t('tramway.plugins.solid_queue.notices.enqueued')
+        end
+
+        private
+
+        def recurring_task
+          @recurring_task ||= ::SolidQueue::RecurringTask.find_by!(key: params.expect(:key))
+        end
+      end
+    end
+  end
+end

data/app/helpers/tramway/plugins/solid_queue/jobs_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tramway
+  module Plugins
+    module SolidQueue
+      # View helpers for rendering SolidQueue job statuses in the plugin dashboard
+      module JobsHelper
+        STATUS_BADGE_TYPES = {
+          ready: :hope,
+          claimed: :love,
+          scheduled: :fear,
+          blocked: :warning,
+          failed: :rage,
+          finished: :will
+        }.freeze
+
+        def solid_queue_status_badge_type(status)
+          STATUS_BADGE_TYPES.fetch(status&.to_sym, :default)
+        end
+
+        def solid_queue_status_label(status)
+          t("tramway.plugins.solid_queue.statuses.#{status}", default: status.to_s.humanize)
+        end
+      end
+    end
+  end
+end

data/app/helpers/tramway/plugins/solid_queue/queues_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tramway
+  module Plugins
+    module SolidQueue
+      # View helpers for rendering SolidQueue queue throughput and running-job counts in the plugin dashboard
+      module QueuesHelper
+        THROUGHPUT_WINDOW = 5.minutes
+
+        def solid_queue_throughput_label(queue)
+          t('tramway.plugins.solid_queue.queues.throughput_value', default: '%<rate>s/min',
+                                                                   rate: solid_queue_throughput(queue))
+        end
+
+        def solid_queue_throughput(queue)
+          finished_count = ::SolidQueue::Job.where(queue_name: queue.name, finished_at: THROUGHPUT_WINDOW.ago..).count
+
+          (finished_count / THROUGHPUT_WINDOW.in_minutes).round(1)
+        end
+
+        def solid_queue_running_count(queue)
+          ::SolidQueue::Job.where(queue_name: queue.name).joins(:claimed_execution).count
+        end
+      end
+    end
+  end
+end

data/app/jobs/tramway/solid_queue/application_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Tramway
+  module SolidQueue
+    # Base job for the plugin's bulk jobs actions (retry/discard/destroy), routed to their
+    # own dedicated worker queue so a large bulk action can't starve other application jobs.
+    # The `tramway:install` generator configures this queue with 20 worker threads.
+    class ApplicationJob < ActiveJob::Base
+      BATCH_SIZE = 1000
+
+      queue_as :tramway_solid_queue_bulk_actions
+    end
+  end
+end

data/app/jobs/tramway/solid_queue/bulk_destroy_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Tramway
+  module SolidQueue
+    # Destroys the given jobs, in batches so a large selection doesn't load/destroy
+    # everything in a single pass.
+    class BulkDestroyJob < ApplicationJob
+      def perform(job_ids)
+        ::SolidQueue::Job.where(id: job_ids).in_batches(of: BATCH_SIZE, &:destroy_all)
+      end
+    end
+  end
+end

data/app/jobs/tramway/solid_queue/bulk_discard_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Tramway
+  module SolidQueue
+    # Discards the given jobs, in batches so a large selection doesn't load everything
+    # in a single pass. `discard` is a per-record SolidQueue operation, not a bulk SQL one.
+    class BulkDiscardJob < ApplicationJob
+      def perform(job_ids)
+        ::SolidQueue::Job.where(id: job_ids).find_each(batch_size: BATCH_SIZE, &:discard)
+      end
+    end
+  end
+end

data/app/jobs/tramway/solid_queue/bulk_retry_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Tramway
+  module SolidQueue
+    # Retries the given jobs, in batches so a large selection doesn't load everything
+    # in a single pass. `retry` is a per-record SolidQueue operation, not a bulk SQL one.
+    class BulkRetryJob < ApplicationJob
+      def perform(job_ids)
+        ::SolidQueue::Job.where(id: job_ids).find_each(batch_size: BATCH_SIZE, &:retry)
+      end
+    end
+  end
+end

data/app/jobs/tramway/solid_queue/destroy_all_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Tramway
+  module SolidQueue
+    # Destroys every job matching the given filters, in batches so a large match set
+    # doesn't load/destroy everything in a single pass.
+    class DestroyAllJob < ApplicationJob
+      def perform(filters = {})
+        Tramway::SolidQueue::JobsFilter.new(filters).jobs.in_batches(of: BATCH_SIZE, &:destroy_all)
+      end
+    end
+  end
+end

data/app/models/tramway/solid_queue/jobs_filter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Tramway
+  module SolidQueue
+    # Shared status/queue/class/search filtering for SolidQueue jobs, used by both the
+    # jobs controller (for the index page) and the background jobs that process a
+    # filtered set of jobs (e.g. "Destroy all"), since a job's `perform` only receives
+    # plain serializable arguments, not a live `ActionController::Parameters`.
+    class JobsFilter
+      STATUS_FILTERS = {
+        'ready' => ->(relation) { relation.joins(:ready_execution) },
+        'claimed' => ->(relation) { relation.joins(:claimed_execution) },
+        'scheduled' => ->(relation) { relation.joins(:scheduled_execution) },
+        'blocked' => ->(relation) { relation.joins(:blocked_execution) },
+        'failed' => ->(relation) { relation.joins(:failed_execution) },
+        'finished' => ->(relation) { relation.finished }
+      }.freeze
+
+      def initialize(filters = {})
+        @filters = filters.to_h.stringify_keys
+      end
+
+      def jobs
+        relation = apply_status_filter(::SolidQueue::Job.all)
+        relation = relation.where(queue_name: filters['queue_name']) if filters['queue_name'].present?
+        relation = relation.where(class_name: filters['class_name']) if filters['class_name'].present?
+
+        apply_search(relation).distinct
+      end
+
+      def status_counts
+        STATUS_FILTERS.transform_values { |scope| scope.call(::SolidQueue::Job.all).count }
+      end
+
+      private
+
+      attr_reader :filters
+
+      def apply_status_filter(relation)
+        STATUS_FILTERS.fetch(filters['status']) { ->(rel) { rel } }.call(relation)
+      end
+
+      def apply_search(relation)
+        query = filters['query'].to_s.strip
+
+        return relation if query.blank?
+        return relation.where(id: query) if query.match?(/\A\d+\z/)
+
+        relation.where('class_name LIKE :query OR active_job_id LIKE :query', query: "%#{query}%")
+      end
+    end
+  end
+end

data/app/views/tramway/plugins/solid_queue/_subnav.html.haml

@@ -0,0 +1,7 @@
+.flex.gap-2.mt-2
+  = tramway_button tag: :a, text: t('tramway.plugins.solid_queue.jobs.title'), path: jobs_path,
+    type: (current_page?(jobs_path) ? :primary : :inverse), size: :small
+  = tramway_button tag: :a, text: t('tramway.plugins.solid_queue.queues.title'), path: queues_path,
+    type: (current_page?(queues_path) ? :primary : :inverse), size: :small
+  = tramway_button tag: :a, text: t('tramway.plugins.solid_queue.recurring_tasks.title'), path: recurring_tasks_path,
+    type: (current_page?(recurring_tasks_path) ? :primary : :inverse), size: :small

data/app/views/tramway/plugins/solid_queue/jobs/index.html.haml

@@ -0,0 +1,89 @@
+- content_for :title, t('tramway.plugins.solid_queue.jobs.title', default: 'Background Jobs')
+
+= tramway_container do
+  .flex.justify-between.items-center
+    = tramway_title do
+      = content_for :title
+
+  = render 'tramway/plugins/solid_queue/subnav'
+
+  %div{ data: { controller: 'tramway--auto-refresh' } }
+    #tramway-solid-queue-jobs-status-filters.flex.flex-wrap.gap-2.mt-2{ data: { 'tramway--auto-refresh-target': 'refreshable' } }
+      - @status_counts.each do |status, count|
+        - status_params = request.query_parameters.except('page').merge(status:)
+        - button_type = status == params[:status] ? :primary : :inverse
+        = tramway_button text: "#{solid_queue_status_label(status)} · #{count}",
+          path: jobs_path(status_params), type: button_type, size: :small
+
+      - if params[:status].present?
+        - clear_params = request.query_parameters.except('page', 'status')
+        = tramway_button tag: :a, path: jobs_path(clear_params), type: :inverse,
+          size: :small, tooltip: { text: t('tramway.actions.clear_filter'), event: :hover } do
+          %i.fa.fa-times{ 'aria-hidden' => 'true' }
+
+    - all_queues_option = [t('tramway.plugins.solid_queue.jobs.all_queues', default: 'All queues'), '']
+    - queue_name_options = [all_queues_option] + @queue_names.map { |name| [name, name] }
+    - all_classes_option = [t('tramway.plugins.solid_queue.jobs.all_classes', default: 'All classes'), '']
+    - class_name_options = [all_classes_option] + @class_names.map { |name| [name, name] }
+
+    = form_with url: jobs_path, method: :get, local: true, builder: Tramway::Form::Builder, horizontal: true do |f|
+      .flex.flex-wrap.items-center.gap-4.mt-2
+        = f.select :queue_name, queue_name_options, label: false, selected: params[:queue_name].to_s
+        = f.select :class_name, class_name_options, label: false, selected: params[:class_name].to_s
+        = f.text_field :query, label: false, value: params[:query], placeholder: t('tramway.actions.search')
+        = f.submit nil, 'aria-label' => t('tramway.actions.search') do
+          %i.fa.fa-search{ 'aria-hidden' => 'true' }
+
+    .flex.justify-between.gap-2.mt-4
+      = tramway_button text: t('tramway.actions.destroy_all'), path: destroy_all_jobs_path(request.query_parameters.except('page')),
+        method: :post, type: :rage, size: :small
+
+      = form_with url: bulk_destroy_jobs_path, method: :post, id: 'tramway-solid-queue-bulk-jobs-form', local: true do
+        .flex.gap-2
+          = tramway_button text: t('tramway.actions.retry'), tag: :button, type: :will, size: :small,
+            formaction: bulk_retry_jobs_path
+          = tramway_button text: t('tramway.actions.discard'), tag: :button, type: :warning, size: :small,
+            formaction: bulk_discard_jobs_path
+          = tramway_button text: t('tramway.actions.destroy'), tag: :button, type: :rage, size: :small,
+            formaction: bulk_destroy_jobs_path
+
+    #tramway-solid-queue-jobs-table{ data: { 'tramway--auto-refresh-target': 'refreshable' } }
+      = tramway_table class: 'mt-4' do
+        = tramway_header headers: ['', 'ID', t('tramway.plugins.solid_queue.jobs.class_name', default: 'Class'),
+          t('tramway.plugins.solid_queue.jobs.queue_name', default: 'Queue'),
+          t('tramway.plugins.solid_queue.jobs.status', default: 'Status'),
+          t('tramway.plugins.solid_queue.jobs.scheduled_at', default: 'Scheduled at'),
+          t('tramway.table.actions_header')]
+        - @jobs.each do |job|
+          = tramway_row do
+            = tramway_cell do
+              = check_box_tag 'job_ids[]', job.id, false, id: "tramway-solid-queue-job-#{job.id}",
+                form: 'tramway-solid-queue-bulk-jobs-form'
+            = tramway_cell do
+              = job.id
+            = tramway_cell do
+              = job.class_name
+            = tramway_cell do
+              = job.queue_name
+            = tramway_cell do
+              = tramway_badge text: solid_queue_status_label(job.status),
+                type: solid_queue_status_badge_type(job.status)
+            = tramway_cell do
+              = job.scheduled_at
+            = tramway_cell do
+              .flex.gap-2
+                = tramway_button tag: :a, path: job_path(job.id), type: :inverse, size: :small do
+                  %i.fa.fa-eye{ 'aria-hidden' => 'true' }
+                - if job.status == :failed
+                  = tramway_button path: retry_job_path(job.id), method: :post, type: :will, size: :small do
+                    %i.fa.fa-redo{ 'aria-hidden' => 'true' }
+                - if job.status != :finished
+                  = tramway_button path: discard_job_path(job.id), method: :post, type: :warning, size: :small do
+                    %i.fa.fa-ban{ 'aria-hidden' => 'true' }
+                = tramway_button path: job_path(job.id), method: :delete, type: :rage, size: :small do
+                  %i.fa.fa-trash{ 'aria-hidden' => 'true' }
+
+      .flex.flex-col.items-center.mt-4.gap-2
+        = paginate @jobs
+        %p.sm:hidden.text-xs.text-zinc-500
+          = page_entries_info @jobs