async-background 1.0.1 → 1.1.0

data/lib/async/background/web/event_hub.rb

@@ -20,14 +20,13 @@ module Async
         end
 
         def current_version
-          @mutex.synchronize { raise ClosedError, 'event hub is closed' if @closed }
+          with_open {}
           @snapshot.data_version
         end
 
         def frame_for(version)
-          @mutex.synchronize do
-            raise ClosedError, 'event hub is closed' if @closed
-            return @cached_frame if @cached_version == version && @cached_frame
+          with_open do
+            next @cached_frame if @cached_version == version && @cached_frame
 
             refresh_frame_locked!
             @cached_frame
@@ -35,9 +34,7 @@ module Async
         end
 
         def initial_frame
-          @mutex.synchronize do
-            raise ClosedError, 'event hub is closed' if @closed
-
+          with_open do
             refresh_frame_locked!
             [@cached_version, @cached_frame]
           end
@@ -58,6 +55,14 @@ module Async
 
         private
 
+        def with_open
+          @mutex.synchronize do
+            raise ClosedError, 'event hub is closed' if @closed
+
+            yield
+          end
+        end
+
         def refresh_frame_locked!
           overview = @snapshot.overview(force: true)
           metrics = @metrics_reader&.aggregated

data/lib/async/background/web/metrics_reader.rb

@@ -11,16 +11,24 @@ module Async
 
         DEFAULT_TTL = 1.0
         EMPTY_WORKERS = [].freeze
-        EMPTY_TOTALS = {
-          total_runs: 0,
-          total_successes: 0,
-          total_failures: 0,
-          total_timeouts: 0,
-          total_skips: 0,
-          active_jobs: 0,
-          last_run_at: 0,
-          last_duration_ms: nil
-        }.freeze
+        SUMMED_FIELDS = %i[
+          total_runs
+          total_successes
+          total_failures
+          total_timeouts
+          total_skips
+          active_jobs
+        ].freeze
+
+        LATEST_FIELD = :last_run_at
+        LATEST_COMPANION = :last_duration_ms
+
+        EMPTY_TOTALS = (
+          SUMMED_FIELDS.to_h { |field| [field, 0] }
+            .merge(LATEST_FIELD => 0, LATEST_COMPANION => nil)
+        ).freeze
+
+        UNAVAILABLE = {available: false, workers: EMPTY_WORKERS, totals: EMPTY_TOTALS}.freeze
 
         def initialize(path:, total_workers:, ttl: DEFAULT_TTL)
           @path = path
@@ -57,37 +65,23 @@ module Async
           unavailable
         end
 
-        def unavailable
-          {available: false, workers: EMPTY_WORKERS, totals: EMPTY_TOTALS}
-        end
+        def unavailable = UNAVAILABLE
 
         def aggregate(workers)
-          totals = {
-            total_runs: 0,
-            total_successes: 0,
-            total_failures: 0,
-            total_timeouts: 0,
-            total_skips: 0,
-            active_jobs: 0,
-            last_run_at: 0,
-            last_duration_ms: nil
-          }
+          totals = EMPTY_TOTALS.dup
+          most_recent = nil
 
           workers.each do |worker|
-            totals[:total_runs] += worker[:total_runs].to_i
-            totals[:total_successes] += worker[:total_successes].to_i
-            totals[:total_failures] += worker[:total_failures].to_i
-            totals[:total_timeouts] += worker[:total_timeouts].to_i
-            totals[:total_skips] += worker[:total_skips].to_i
-            totals[:active_jobs] += worker[:active_jobs].to_i
-
-            last_run_at = worker[:last_run_at].to_i
-            next unless last_run_at > totals[:last_run_at]
-
-            totals[:last_run_at] = last_run_at
-            totals[:last_duration_ms] = worker[:last_duration_ms]
+            SUMMED_FIELDS.each { |field| totals[field] += worker[field].to_i }
+
+            last_run_at = worker[LATEST_FIELD].to_i
+            next unless last_run_at > totals[LATEST_FIELD]
+
+            totals[LATEST_FIELD] = last_run_at
+            most_recent = worker
           end
 
+          totals[LATEST_COMPANION] = most_recent[LATEST_COMPANION] if most_recent
           totals.freeze
         end
       end

data/lib/async/background/web/response.rb

@@ -13,8 +13,12 @@ module Async
         TEXT_TYPE = 'text/plain; charset=utf-8'
         JAVASCRIPT_TYPE = 'application/javascript; charset=utf-8'
         CSS_TYPE = 'text/css; charset=utf-8'
+        EVENT_STREAM_TYPE = 'text/event-stream; charset=utf-8'
+
         NO_STORE = 'no-store'
         ASSET_CACHE = 'public, max-age=31536000, immutable'
+        SSE_CACHE = 'no-cache, no-transform'
+
         BASE_SECURITY_HEADERS = {
           'x-content-type-options' => 'nosniff',
           'referrer-policy' => 'no-referrer',
@@ -34,73 +38,57 @@ module Async
             "form-action 'none'"
         ).freeze
 
-        UNAUTHORIZED_BODY = JSON.generate(error: 'unauthorized').freeze
-        NOT_FOUND_BODY = JSON.generate(error: 'not_found').freeze
-        BAD_REQUEST_BODY = JSON.generate(error: 'invalid_request').freeze
-        UNAVAILABLE_BODY = JSON.generate(error: 'service_unavailable').freeze
-        INTERNAL_ERROR_BODY = JSON.generate(error: 'internal_error').freeze
-        EVENT_STREAM_TYPE = 'text/event-stream; charset=utf-8'
+        ERRORS = {
+          unauthorized: [401, 'unauthorized'],
+          not_found: [404, 'not_found'],
+          bad_request: [400, 'invalid_request'],
+          unavailable: [503, 'service_unavailable'],
+          internal_error: [500, 'internal_error']
+        }.freeze
 
-        def sse(body)
-          [200, sse_headers, body]
-        end
+        ERROR_BODY = ERRORS.to_h { |name, (_, code)| [name, JSON.generate(error: code).freeze] }.freeze
 
-        def json(payload, status: 200)
-          [status, no_store_headers(JSON_TYPE), [JSON.generate(payload)]]
+        def headers(content_type, cache_control, security = BASE_SECURITY_HEADERS)
+          {'content-type' => content_type, 'cache-control' => cache_control}.merge(security)
         end
 
-        def html(body)
-          [200, html_headers, [body]]
-        end
+        def no_store_headers(content_type) = headers(content_type, NO_STORE)
+        def html_headers = headers(HTML_TYPE, NO_STORE, HTML_SECURITY_HEADERS)
+        def asset_headers(content_type) = headers(content_type, ASSET_CACHE)
 
-        def javascript(body)
-          [200, asset_headers(JAVASCRIPT_TYPE), [body]]
+        def sse_headers
+          {
+            'content-type' => EVENT_STREAM_TYPE,
+            'cache-control' => SSE_CACHE,
+            'x-accel-buffering' => 'no'
+          }.merge(BASE_SECURITY_HEADERS)
         end
 
-        def stylesheet(body)
-          [200, asset_headers(CSS_TYPE), [body]]
-        end
+        def sse(body) = [200, sse_headers, body]
+        def html(body) = [200, html_headers, [body]]
+        def javascript(body) = [200, asset_headers(JAVASCRIPT_TYPE), [body]]
+        def stylesheet(body) = [200, asset_headers(CSS_TYPE), [body]]
 
-        def unauthorized
-          [401, no_store_headers(JSON_TYPE), [UNAUTHORIZED_BODY]]
+        def json(payload, status: 200)
+          [status, no_store_headers(JSON_TYPE), [JSON.generate(payload)]]
         end
 
-        def not_found
-          [404, no_store_headers(JSON_TYPE), [NOT_FOUND_BODY]]
-        end
+        def unauthorized = error_response(:unauthorized)
+        def not_found = error_response(:not_found)
+        def unavailable = error_response(:unavailable)
+        def internal_error = error_response(:internal_error)
 
         def bad_request(message = nil)
-          body = message.nil? ? BAD_REQUEST_BODY : JSON.generate(error: 'invalid_request', message: message)
-          [400, no_store_headers(JSON_TYPE), [body]]
-        end
-
-        def unavailable
-          [503, no_store_headers(JSON_TYPE), [UNAVAILABLE_BODY]]
-        end
-
-        def internal_error
-          [500, no_store_headers(JSON_TYPE), [INTERNAL_ERROR_BODY]]
-        end
-
-        def no_store_headers(content_type)
-          {'content-type' => content_type, 'cache-control' => NO_STORE}.merge(BASE_SECURITY_HEADERS)
-        end
-
-        def html_headers
-          {'content-type' => HTML_TYPE, 'cache-control' => NO_STORE}.merge(HTML_SECURITY_HEADERS)
-        end
+          return error_response(:bad_request) if message.nil?
 
-        def asset_headers(content_type)
-          {'content-type' => content_type, 'cache-control' => ASSET_CACHE}.merge(BASE_SECURITY_HEADERS)
+          error_response(:bad_request, JSON.generate(error: 'invalid_request', message: message))
         end
 
-        def sse_headers
-          {
-            'content-type' => EVENT_STREAM_TYPE,
-            'cache-control' => 'no-cache, no-transform',
-            'x-accel-buffering' => 'no'
-          }.merge(BASE_SECURITY_HEADERS)
+        def error_response(name, body = ERROR_BODY.fetch(name))
+          status = ERRORS.fetch(name).first
+          [status, no_store_headers(JSON_TYPE), [body]]
         end
+        private_class_method :error_response
       end
     end
   end

data/lib/async/background/web/serializer.rb

@@ -26,97 +26,57 @@ module Async
         end
 
         def executing(rows)
-          rows.map { |row| executing_item(row) }
+          rows.map { |row| item(:executing, row) }
         end
 
         def claimed(rows)
-          rows.map { |row| claimed_item(row) }
+          rows.map { |row| item(:claimed, row) }
         end
 
         def done(rows)
-          page(rows.map { |row| done_item(row) }) { |item| Cursor.encode_finished(item[:finished_at], item[:id]) }
+          page(:done, rows)
         end
 
         def failed(rows)
-          page(rows.map { |row| failed_item(row) }) { |item| Cursor.encode_finished(item[:finished_at], item[:id]) }
+          page(:failed, rows)
         end
 
         def pending(rows)
-          page(rows.map { |row| pending_item(row) }) { |item| Cursor.encode_pending(item[:run_at], item[:id]) }
+          page(:pending, rows)
         end
 
         private
 
-        def page(items)
-          {items: items, next_cursor: items.empty? ? nil : yield(items.last)}
-        end
+        EXTRA_FIELDS = {
+          executing: %i[started_at locked_by locked_at].freeze,
+          claimed: %i[locked_at locked_by].freeze,
+          done: %i[finished_at duration_ms].freeze,
+          failed: %i[finished_at duration_ms last_error_class last_error_message].freeze,
+          pending: %i[created_at run_at].freeze
+        }.freeze
 
-        def executing_item(row)
-          args, args_count = args_for(row[:args_raw])
-          {
-            id: row[:id],
-            class_name: row[:class_name],
-            args: args,
-            args_count: args_count,
-            options: parse_options(row[:options_raw]),
-            started_at: row[:started_at],
-            locked_by: row[:locked_by],
-            locked_at: row[:locked_at]
-          }
-        end
+        CURSOR_KEY = {done: :finished_at, failed: :finished_at, pending: :run_at}.freeze
 
-        def claimed_item(row)
+        def item(kind, row)
           args, args_count = args_for(row[:args_raw])
-          {
-            id: row[:id],
-            class_name: row[:class_name],
-            args: args,
-            args_count: args_count,
-            options: parse_options(row[:options_raw]),
-            locked_at: row[:locked_at],
-            locked_by: row[:locked_by]
-          }
-        end
 
-        def done_item(row)
-          args, args_count = args_for(row[:args_raw])
-          {
+          fields = {
             id: row[:id],
             class_name: row[:class_name],
             args: args,
             args_count: args_count,
-            options: parse_options(row[:options_raw]),
-            finished_at: row[:finished_at],
-            duration_ms: row[:duration_ms]
+            options: parse_options(row[:options_raw])
           }
+          EXTRA_FIELDS.fetch(kind).each { |name| fields[name] = row[name] }
+          fields
         end
 
-        def failed_item(row)
-          args, args_count = args_for(row[:args_raw])
-          {
-            id: row[:id],
-            class_name: row[:class_name],
-            args: args,
-            args_count: args_count,
-            options: parse_options(row[:options_raw]),
-            finished_at: row[:finished_at],
-            duration_ms: row[:duration_ms],
-            last_error_class: row[:last_error_class],
-            last_error_message: row[:last_error_message]
-          }
-        end
+        def page(kind, rows)
+          items = rows.map { |row| item(kind, row) }
+          last = items.last
+          cursor = last && Cursor.encode(last[CURSOR_KEY.fetch(kind)], last[:id])
 
-        def pending_item(row)
-          args, args_count = args_for(row[:args_raw])
-          {
-            id: row[:id],
-            class_name: row[:class_name],
-            args: args,
-            args_count: args_count,
-            options: parse_options(row[:options_raw]),
-            created_at: row[:created_at],
-            run_at: row[:run_at]
-          }
+          {items: items, next_cursor: cursor}
         end
 
         def args_for(raw)

data/lib/async/background/web/snapshot.rb

@@ -13,6 +13,20 @@ module Async
         include Clock
 
         CacheEntry = Data.define(:value, :created_at)
+        RAW_COLUMNS = {'args' => :args_raw, 'options' => :options_raw}.freeze
+
+        ROW_KEYS = SQL::EXTRA_COLUMNS.to_h do |status, extra|
+          columns = SQL::BASE_COLUMNS + extra
+          [status, columns.map { |column| RAW_COLUMNS.fetch(column, column.to_sym) }.freeze]
+        end.freeze
+
+        PAGING = {
+          executing: [SQL::EXECUTING, nil, nil].freeze,
+          claimed: [SQL::CLAIMED, nil, nil].freeze,
+          done: [SQL::DONE, SQL::DONE_AFTER, %i[finished_at id].freeze].freeze,
+          failed: [SQL::FAILED, SQL::FAILED_AFTER, %i[finished_at id].freeze].freeze,
+          pending: [SQL::PENDING, SQL::PENDING_AFTER, %i[run_at id].freeze].freeze
+        }.freeze
 
         def initialize(path:, counts_cache_ttl:)
           @path = path
@@ -65,26 +79,23 @@ module Async
         end
 
         def executing(limit:)
-          read_rows(SQL::EXECUTING, [limit]).map { |row| executing_row(row) }
+          list(:executing, limit: limit)
         end
 
         def claimed(limit:)
-          read_rows(SQL::CLAIMED, [limit]).map { |row| claimed_row(row) }
+          list(:claimed, limit: limit)
         end
 
         def recent_done(limit:, cursor: nil)
-          sql, binds = terminal_query(SQL::DONE, SQL::DONE_AFTER, limit, cursor)
-          read_rows(sql, binds).map { |row| done_row(row) }
+          list(:done, limit: limit, cursor: cursor)
         end
 
         def recent_failed(limit:, cursor: nil)
-          sql, binds = terminal_query(SQL::FAILED, SQL::FAILED_AFTER, limit, cursor)
-          read_rows(sql, binds).map { |row| failed_row(row) }
+          list(:failed, limit: limit, cursor: cursor)
         end
 
         def pending(limit:, cursor: nil)
-          sql, binds = pending_query(limit, cursor)
-          read_rows(sql, binds).map { |row| pending_row(row) }
+          list(:pending, limit: limit, cursor: cursor)
         end
 
         private
@@ -103,7 +114,7 @@ module Async
         end
 
         def database_uri
-          path = URI::DEFAULT_PARSER.escape(File.expand_path(@path)).gsub('?', '%3F')
+          path = URI::RFC2396_PARSER.escape(File.expand_path(@path)).gsub('?', '%3F')
           "file:#{path}?mode=ro"
         end
 
@@ -153,10 +164,10 @@ module Async
           {
             counts: {
               executing: db.get_first_value(SQL::OVERVIEW_EXECUTING).to_i,
-              claimed:   db.get_first_value(SQL::OVERVIEW_CLAIMED).to_i,
-              pending:   db.get_first_value(SQL::OVERVIEW_PENDING).to_i,
-              done:      db.get_first_value(SQL::OVERVIEW_DONE).to_i,
-              failed:    db.get_first_value(SQL::OVERVIEW_FAILED).to_i
+              claimed: db.get_first_value(SQL::OVERVIEW_CLAIMED).to_i,
+              pending: db.get_first_value(SQL::OVERVIEW_PENDING).to_i,
+              done: db.get_first_value(SQL::OVERVIEW_DONE).to_i,
+              failed: db.get_first_value(SQL::OVERVIEW_FAILED).to_i
             }.freeze,
             next_pending_run_at: db.get_first_value(SQL::OVERVIEW_NEXT_PENDING),
             data_version: db.get_first_value(Queue::SQL::DATA_VERSION).to_i,
@@ -164,74 +175,17 @@ module Async
           }
         end
 
-        def terminal_query(first_page_sql, next_page_sql, limit, cursor)
-          return [first_page_sql, [limit]] unless cursor
-
-          [next_page_sql, [cursor.fetch(:finished_at), cursor.fetch(:id), limit]]
-        end
-
-        def pending_query(limit, cursor)
-          return [SQL::PENDING, [limit]] unless cursor
-
-          [SQL::PENDING_AFTER, [cursor.fetch(:run_at), cursor.fetch(:id), limit]]
+        def list(status, limit:, cursor: nil)
+          sql, binds = page_query(status, limit, cursor)
+          keys = ROW_KEYS.fetch(status)
+          read_rows(sql, binds).map { |row| keys.zip(row).to_h }
         end
 
-        def executing_row(row)
-          {
-            id: row[0],
-            class_name: row[1],
-            args_raw: row[2],
-            options_raw: row[3],
-            started_at: row[4],
-            locked_by: row[5],
-            locked_at: row[6]
-          }
-        end
+        def page_query(status, limit, cursor)
+          first_sql, seek_sql, cursor_keys = PAGING.fetch(status)
+          return [first_sql, [limit]] unless cursor
 
-        def claimed_row(row)
-          {
-            id: row[0],
-            class_name: row[1],
-            args_raw: row[2],
-            options_raw: row[3],
-            locked_at: row[4],
-            locked_by: row[5]
-          }
-        end
-
-        def done_row(row)
-          {
-            id: row[0],
-            class_name: row[1],
-            args_raw: row[2],
-            options_raw: row[3],
-            finished_at: row[4],
-            duration_ms: row[5]
-          }
-        end
-
-        def failed_row(row)
-          {
-            id: row[0],
-            class_name: row[1],
-            args_raw: row[2],
-            options_raw: row[3],
-            finished_at: row[4],
-            duration_ms: row[5],
-            last_error_class: row[6],
-            last_error_message: row[7]
-          }
-        end
-
-        def pending_row(row)
-          {
-            id: row[0],
-            class_name: row[1],
-            args_raw: row[2],
-            options_raw: row[3],
-            created_at: row[4],
-            run_at: row[5]
-          }
+          [seek_sql, cursor_keys.map { |key| cursor.fetch(key) } << limit]
         end
 
         def require_sqlite3

data/lib/async/background/web/sql.rb

@@ -9,79 +9,73 @@ module Async
         ROLLBACK = 'ROLLBACK'.freeze
         QUERY_ONLY = 'PRAGMA query_only = ON'.freeze
         BUSY_TIMEOUT = 'PRAGMA busy_timeout = 2000'.freeze
+        BASE_COLUMNS = %w[id class_name args options].freeze
 
-        OVERVIEW_EXECUTING = "SELECT COUNT(*) FROM jobs WHERE status = 'running' AND started_at IS NOT NULL".freeze
-        OVERVIEW_CLAIMED   = "SELECT COUNT(*) FROM jobs WHERE status = 'running' AND started_at IS NULL".freeze
-        OVERVIEW_PENDING   = "SELECT COUNT(*) FROM jobs WHERE status = 'pending'".freeze
-        OVERVIEW_DONE      = "SELECT COUNT(*) FROM jobs WHERE status = 'done'".freeze
-        OVERVIEW_FAILED    = "SELECT COUNT(*) FROM jobs WHERE status = 'failed'".freeze
-        OVERVIEW_NEXT_PENDING = "SELECT MIN(run_at) FROM jobs WHERE status = 'pending'".freeze
+        STATUS_PREDICATE = {
+          executing: "status = 'running' AND started_at IS NOT NULL",
+          claimed: "status = 'running' AND started_at IS NULL",
+          pending: "status = 'pending'",
+          done: "status = 'done'",
+          failed: "status = 'failed'"
+        }.freeze
 
-        EXECUTING = <<~SQL.freeze
-          SELECT id, class_name, args, options, started_at, locked_by, locked_at
-          FROM jobs
-          WHERE status = 'running' AND started_at IS NOT NULL
-          ORDER BY started_at, id
-          LIMIT ?
-        SQL
+        EXTRA_COLUMNS = {
+          executing: %w[started_at locked_by locked_at],
+          claimed: %w[locked_at locked_by],
+          pending: %w[created_at run_at],
+          done: %w[finished_at duration_ms],
+          failed: %w[finished_at duration_ms last_error_class last_error_message]
+        }.freeze
 
-        CLAIMED = <<~SQL.freeze
-          SELECT id, class_name, args, options, locked_at, locked_by
-          FROM jobs
-          WHERE status = 'running' AND started_at IS NULL
-          ORDER BY locked_at, id
-          LIMIT ?
-        SQL
+        KEYSET = {
+          executing: ['started_at', :asc],
+          claimed: ['locked_at', :asc],
+          pending: ['run_at', :asc],
+          done: ['finished_at', :desc],
+          failed: ['finished_at', :desc]
+        }.freeze
 
-        DONE = <<~SQL.freeze
-          SELECT id, class_name, args, options, finished_at, duration_ms
-          FROM jobs
-          WHERE status = 'done'
-          ORDER BY finished_at DESC, id DESC
-          LIMIT ?
-        SQL
+        ORDER_SQL = {asc: 'ORDER BY %<column>s, id', desc: 'ORDER BY %<column>s DESC, id DESC'}.freeze
+        SEEK_SQL = {asc: '(%<column>s, id) > (?, ?)', desc: '(%<column>s, id) < (?, ?)'}.freeze
 
-        DONE_AFTER = <<~SQL.freeze
-          SELECT id, class_name, args, options, finished_at, duration_ms
-          FROM jobs
-          WHERE status = 'done' AND (finished_at, id) < (?, ?)
-          ORDER BY finished_at DESC, id DESC
-          LIMIT ?
-        SQL
+        def self.columns_for(status)
+          (BASE_COLUMNS + EXTRA_COLUMNS.fetch(status)).join(', ')
+        end
 
-        FAILED = <<~SQL.freeze
-          SELECT id, class_name, args, options, finished_at, duration_ms,
-                 last_error_class, last_error_message
-          FROM jobs
-          WHERE status = 'failed'
-          ORDER BY finished_at DESC, id DESC
-          LIMIT ?
-        SQL
+        def self.count_query(status)
+          "SELECT COUNT(*) FROM jobs WHERE #{STATUS_PREDICATE.fetch(status)}".freeze
+        end
 
-        FAILED_AFTER = <<~SQL.freeze
-          SELECT id, class_name, args, options, finished_at, duration_ms,
-                 last_error_class, last_error_message
-          FROM jobs
-          WHERE status = 'failed' AND (finished_at, id) < (?, ?)
-          ORDER BY finished_at DESC, id DESC
-          LIMIT ?
-        SQL
+        def self.list_query(status, seek: false)
+          column, direction = KEYSET.fetch(status)
+          predicate = STATUS_PREDICATE.fetch(status)
+          predicate += " AND #{format(SEEK_SQL.fetch(direction), column: column)}" if seek
 
-        PENDING = <<~SQL.freeze
-          SELECT id, class_name, args, options, created_at, run_at
-          FROM jobs
-          WHERE status = 'pending'
-          ORDER BY run_at, id
-          LIMIT ?
-        SQL
+          <<~SQL.freeze
+            SELECT #{columns_for(status)}
+            FROM jobs
+            WHERE #{predicate}
+            #{format(ORDER_SQL.fetch(direction), column: column)}
+            LIMIT ?
+          SQL
+        end
 
-        PENDING_AFTER = <<~SQL.freeze
-          SELECT id, class_name, args, options, created_at, run_at
-          FROM jobs
-          WHERE status = 'pending' AND (run_at, id) > (?, ?)
-          ORDER BY run_at, id
-          LIMIT ?
-        SQL
+        OVERVIEW_EXECUTING = count_query(:executing)
+        OVERVIEW_CLAIMED = count_query(:claimed)
+        OVERVIEW_PENDING = count_query(:pending)
+        OVERVIEW_DONE = count_query(:done)
+        OVERVIEW_FAILED = count_query(:failed)
+        OVERVIEW_NEXT_PENDING = "SELECT MIN(run_at) FROM jobs WHERE #{STATUS_PREDICATE.fetch(:pending)}".freeze
+
+        EXECUTING = list_query(:executing)
+        CLAIMED = list_query(:claimed)
+        DONE = list_query(:done)
+        FAILED = list_query(:failed)
+        PENDING = list_query(:pending)
+
+        DONE_AFTER = list_query(:done, seek: true)
+        FAILED_AFTER = list_query(:failed, seek: true)
+        PENDING_AFTER = list_query(:pending, seek: true)
       end
     end
   end