pgbus 0.18.2 → 0.19.1

data/lib/pgbus/web/data_source/deploy_task_list.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Web
+    class DataSource
+      # The Deploy tasks page (issue #536): declared tasks with their last
+      # rollover and manual runs, one task's run history, the rollover the
+      # scheduler acts on, and the two actions (Run now, Enable/Disable).
+      module DeployTaskList
+        RUN_HISTORY = 25
+
+        # page/per_page nil returns every task (the MCP tool's default). An
+        # install without the tables (pgbus:add_deploy_tasks not run) gets the
+        # empty state, whose hint names the generator, not an error per refresh.
+        def deploy_tasks(page: nil, per_page: nil)
+          return [] unless DeployTask.table_exists?
+
+          scope = DeployTask.order(:key)
+          scope = scope.limit(per_page).offset(((page || 1) - 1) * per_page) if per_page
+          records = scope.to_a
+          runs = DeployTaskRun.latest_for(records.map(&:key)).group_by(&:task_key)
+          records.map { |record| deploy_task_row(record, runs.fetch(record.key, [])) }
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error fetching deploy tasks: #{e.class}: #{e.message}" }
+          []
+        end
+
+        def deploy_task(id)
+          return nil unless DeployTask.table_exists?
+
+          record = DeployTask.find_by(id: id)
+          return nil unless record
+
+          # The state reads the same unbounded latest-per-trigger runs as the
+          # list, so a run older than the 25 shown still counts.
+          runs = DeployTaskRun.for_task(record.key).recent(RUN_HISTORY).to_a
+          deploy_task_row(record, DeployTaskRun.latest_for([record.key]).to_a).merge(
+            arguments: record.parsed_arguments,
+            runs: runs.map { |run| deploy_run_hash(run).merge(queue_name: run.queue_name, msg_id: run.msg_id) }
+          )
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error fetching deploy task #{id}: #{e.class}: #{e.message}" }
+          nil
+        end
+
+        def toggle_deploy_task(id)
+          record = DeployTask.find_by(id: id)
+          return nil unless record
+
+          record.update!(enabled: !record.enabled)
+          record.enabled ? :enabled : :disabled
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error toggling deploy task #{id}: #{e.message}" }
+          nil
+        end
+
+        # Run now: the scheduler's enqueue path with no gate and no claim. It
+        # leaves a pending rollover arm alone and records a manual run.
+        # :enqueued or :failed, the real outcome.
+        def enqueue_deploy_task_now(id)
+          record = DeployTask.find_by(id: id)
+          return :failed unless record
+          # The hidden button is not the boundary: a disabled task is not run.
+          return disabled_enqueue(record) unless record.enabled
+
+          Deploy::Runner.new(config: Pgbus.configuration).enqueue(record.to_task, triggered_by: Deploy::Runner::MANUAL)
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error enqueuing deploy task #{id}: #{e.class}: #{e.message}" }
+          :failed
+        end
+
+        # The rollover judged against the newest live scheduler's revision,
+        # not this web process's; that one only when no scheduler is live
+        # (scheduler: false says so). nil when it cannot be read.
+        def deploy_rollover(now: Time.current)
+          scheduler, revision = Deploy::Rollover.scheduler_revision(now: now)
+          revision = Deploy::Revision.current unless scheduler
+          status = Deploy::Rollover.check(revision: revision, now: now)
+          { revision: revision, reason: status.reason, lagging: status.lagging, workers_live: status.workers_live,
+            live_by_revision: status.live_by_revision, scheduler: scheduler }
+        rescue StandardError => e
+          Pgbus.logger.error { "[Pgbus::Web] Error reading the deploy rollover: #{e.class}: #{e.message}" }
+          nil
+        end
+
+        private
+
+        def disabled_enqueue(record)
+          Pgbus.logger.warn { "[Pgbus::Web] Deploy task #{record.key} is disabled; Run now refused" }
+          :failed
+        end
+
+        def deploy_task_row(record, latest_runs)
+          by_trigger = latest_runs.index_by(&:triggered_by)
+          {
+            id: record.id, key: record.key, class_name: record.class_name, command: record.command,
+            version: record.version, every_deploy: record.every_deploy, queue_name: record.queue_name,
+            priority: record.priority, description: record.description, enabled: record.enabled,
+            static: record.static, armed_at: record.armed_at, armed_for: record.armed_for,
+            last_rollover_run: deploy_run_hash(by_trigger[Deploy::Runner::ROLLOVER]),
+            last_manual_run: deploy_run_hash(by_trigger[Deploy::Runner::MANUAL]),
+            created_at: record.created_at, updated_at: record.updated_at
+          }
+        end
+
+        def deploy_run_hash(run)
+          return nil unless run
+
+          { run_at: run.run_at, revision: run.revision, version: run.version, triggered_by: run.triggered_by }
+        end
+      end
+    end
+  end
+end

data/lib/pgbus/web/data_source/list_counts.rb

@@ -30,15 +30,18 @@ module Pgbus
           ) b ON s.key = b.concurrency_key
         SQL
 
+        # Model names, resolved when counted (the models autoload lazily):
+        # names rather than lambdas, so the constant is plain frozen data.
         LIST_MODELS = {
-          batches: -> { BatchEntry },
-          job_locks: -> { UniquenessKey },
-          outbox: -> { OutboxEntry },
-          processed_events: -> { ProcessedEvent },
-          recurring_tasks: -> { RecurringTask }
+          batches: :BatchEntry,
+          deploy_tasks: :DeployTask,
+          job_locks: :UniquenessKey,
+          outbox: :OutboxEntry,
+          processed_events: :ProcessedEvent,
+          recurring_tasks: :RecurringTask
         }.freeze
 
-        # list – :batches, :job_locks, :concurrency_keys, :outbox, :processed_events or :recurring_tasks.
+        # list – :batches, :deploy_tasks, :job_locks, :concurrency_keys, :outbox, :processed_events or :recurring_tasks.
         def list_count(list)
           raise ArgumentError, "unknown list: #{list.inspect}" unless list == :concurrency_keys || LIST_MODELS.key?(list)
 
@@ -62,7 +65,7 @@ module Pgbus
         private
 
         def bounded_count(list)
-          rows = list == :concurrency_keys ? concurrency_keys_probe : LIST_MODELS.fetch(list).call.limit(COUNT_CAP + 1).count
+          rows = list == :concurrency_keys ? concurrency_keys_probe : Pgbus.const_get(LIST_MODELS.fetch(list)).limit(COUNT_CAP + 1).count
           Count.new(total: [rows.to_i, COUNT_CAP].min, capped: rows.to_i > COUNT_CAP)
         rescue StandardError => e
           Pgbus.logger.debug { "[Pgbus::Web] Error counting #{list}: #{e.message}" }

data/lib/pgbus/web/data_source.rb

@@ -12,6 +12,7 @@ module Pgbus
       include EventList
       include ProcessList
       include DashboardSignals
+      include DeployTaskList
 
       # pgbus_failed_events rows outside the EventBus handler queues; binds
       # handler_queue_names_literal as $1.

data/lib/pgbus/web/deploy_task_state.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pgbus
+  module Web
+    # The Deploy tasks page's words for one task (issue #536), derived from
+    # its row and the rollover the scheduler acts on (DataSource#deploy_rollover),
+    # so the page prints the reason the scheduler waits for. Pure.
+    #
+    # States: disabled, waiting (armed, gate closed, with the gate's reason),
+    # due (armed, gate open), ran (not armed, has a rollover run), never. A
+    # manual run is appended to any state through manual_args.
+    module DeployTaskState
+      BADGE_TONES = { "disabled" => :gray, "waiting" => :yellow, "due" => :indigo, "ran" => :green,
+                      "never" => :gray }.freeze
+
+      Result = Data.define(:state, :reason_key, :reason_args, :badge_tone, :manual_args)
+
+      module_function
+
+      # row – a DataSource#deploy_tasks row. rollover – DataSource#deploy_rollover, or nil when unreadable.
+      def present(row, rollover)
+        state, key, args = derive(row, rollover)
+        manual = row[:last_manual_run]
+        Result.new(state: state, reason_key: key, reason_args: args, badge_tone: BADGE_TONES.fetch(state),
+                   manual_args: manual ? { ago: manual[:run_at] } : nil)
+      end
+
+      def derive(row, rollover)
+        return ["disabled", row[:armed_at] ? "disabled_armed" : "disabled", {}] unless row[:enabled]
+        return armed(rollover) if row[:armed_at]
+
+        run = row[:last_rollover_run]
+        return ["never", "never", {}] unless run
+
+        ["ran", "ran", { ago: run[:run_at], revision: run[:revision] }]
+      end
+
+      def armed(rollover)
+        return ["waiting", "waiting_unknown", {}] unless rollover
+        return ["waiting", "waiting_no_scheduler", {}] unless rollover[:scheduler]
+
+        case rollover[:reason]
+        when :ready then ["due", "due", {}]
+        when :lagging then ["waiting", "waiting_lagging", { count: rollover[:lagging].size, revision: rollover[:revision] }]
+        when :no_workers then ["waiting", "waiting_no_workers", { revision: rollover[:revision] }]
+        else ["waiting", "waiting_no_revision", {}]
+        end
+      end
+    end
+  end
+end

data/lib/pgbus/web/health_server.rb

@@ -65,7 +65,10 @@ module Pgbus
 
         @server = TCPServer.new(@bind, @configured_port)
         @port = @server.addr[1]
-        @thread = Thread.new { accept_loop }
+        # The accept loop, owned by this server: started once (the @server
+        # check above) by the supervisor, joined (then killed if it hangs) by
+        # #stop.
+        @thread = Thread.new { accept_loop } # rubocop:disable ThreadSafety/NewThread
         logger.info { "[Pgbus::Web::HealthServer] listening on #{@bind}:#{@port} (/livez, /readyz)" }
       end
 

data/lib/pgbus/web/process_activity.rb

@@ -11,7 +11,7 @@ module Pgbus
     # :uptime and :limit (lifetime), Strings for queue and topic lists.
     module ProcessActivity
       KIND_ORDER = %w[worker consumer dispatcher scheduler outbox_poller].freeze
-      RECYCLE_LIMITS = [%w[jobs max_jobs jobs_processed done], %w[memory max_memory_mb memory_mb used]].freeze
+      RECYCLE_LIMITS = [%w[jobs max_jobs jobs_processed done].freeze, %w[memory max_memory_mb memory_mb used].freeze].freeze
 
       module_function
 

data/lib/pgbus/web/streamer/heartbeat.rb

@@ -48,7 +48,10 @@ module Pgbus
           return if @running
 
           @running = true
-          @thread = Thread.new { run_loop }
+          # The heartbeat's one thread, owned by this object: Instance#start
+          # starts it once (under Streamer's @current_mutex); #stop signals
+          # and joins it.
+          @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus/web/streamer/hub_client.rb

@@ -43,7 +43,10 @@ module Pgbus
 
         def connect
           @sock = UNIXSocket.new(@socket_path)
-          @reader = Thread.new { reader_loop }
+          # The client's reader thread, owned by this object: #connect starts
+          # it once per socket; it ends when the socket closes, and #stop
+          # closes the socket and joins it.
+          @reader = Thread.new { reader_loop } # rubocop:disable ThreadSafety/NewThread
           self
         rescue SystemCallError, IOError, ArgumentError, ThreadError => e
           # ArgumentError: a socket path over the platform sun_path limit;

data/lib/pgbus/web/streamer/listener.rb

@@ -35,8 +35,14 @@ module Pgbus
       # For a queue named `pgbus_stream_chat` the trigger table is
       # `q_pgbus_stream_chat`, so the channel is `pgmq.q_pgbus_stream_chat.INSERT`.
       class Listener
+        # Kept Ractor-shareable (issue #527): the hand-off to the dispatcher
+        # is the seam a Ractor dispatcher would pass by reference. The Strings
+        # are frozen in place: they are the sender's own (the NOTIFY's, or the
+        # hub frame's).
         WakeMessage = Data.define(:queue_name, :payload) do
           def initialize(queue_name:, payload: nil)
+            queue_name.freeze
+            payload&.freeze
             super
           end
         end
@@ -101,7 +107,10 @@ module Pgbus
           return if @running
 
           @running = true
-          @thread = Thread.new { run_loop }
+          # The LISTEN thread, owned by this object: Instance#start starts it
+          # once (under Streamer's @current_mutex); #stop clears @running and
+          # joins it.
+          @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus/web/streamer/master_hub.rb

@@ -124,9 +124,12 @@ module Pgbus
             File.umask(old_umask)
           end
           File.chmod(0o600, @socket_path)
-          @accept_thread = Thread.new { accept_loop }
-          @fanout_thread = Thread.new { fanout_loop }
-          @status_thread = Thread.new { status_loop }
+          # The hub's three loops, owned by this hub: #start runs once at hub
+          # start in the Puma master, under @lifecycle_mutex; #stop signals
+          # each loop and joins all three.
+          @accept_thread = Thread.new { accept_loop } # rubocop:disable ThreadSafety/NewThread
+          @fanout_thread = Thread.new { fanout_loop } # rubocop:disable ThreadSafety/NewThread
+          @status_thread = Thread.new { status_loop } # rubocop:disable ThreadSafety/NewThread
           self
         rescue StandardError
           @table_mutex.synchronize { @running = false }
@@ -201,8 +204,11 @@ module Pgbus
             @workers[@next_id] = entry
             @next_id
           end
-          entry[:writer] = Thread.new { writer_loop(id, entry) }
-          entry[:reader] = Thread.new { reader_loop(id, entry) }
+          # One writer and one reader per connected Puma worker, owned by its
+          # @workers entry: both end when cleanup_worker closes the entry's
+          # socket (a worker hangs up, or #stop cleans up every worker).
+          entry[:writer] = Thread.new { writer_loop(id, entry) } # rubocop:disable ThreadSafety/NewThread
+          entry[:reader] = Thread.new { reader_loop(id, entry) } # rubocop:disable ThreadSafety/NewThread
           id
         end
 

data/lib/pgbus/web/streamer/master_hub_boot.rb

@@ -50,7 +50,9 @@ module Pgbus
         def start
           ENV["PGBUS_STREAMS_HUB_SOCKET"] = @socket_path
           @state_mutex.synchronize { @running = true }
-          @thread = Thread.new { wait_and_start }
+          # The boot thread, owned by this object: the Puma plugin starts it
+          # once in the master; #stop clears @running and joins it.
+          @thread = Thread.new { wait_and_start } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus/web/streamer/outbound_pump.rb

@@ -62,7 +62,10 @@ module Pgbus
 
           @started = true
           @partitions.each do |partition|
-            @threads << Thread.new { run_worker(partition) }
+            # One writer per partition, owned by this pump: Instance#start
+            # starts them once (the @started check above); #stop signals each
+            # partition and joins every thread.
+            @threads << Thread.new { run_worker(partition) } # rubocop:disable ThreadSafety/NewThread
           end
           self
         end

data/lib/pgbus/web/streamer/peer_close_watcher.rb

@@ -57,7 +57,10 @@ module Pgbus
 
           @wake_reader, @wake_writer = IO.pipe if @wake_reader.closed?
           @running = true
-          @thread = Thread.new { run_loop }
+          # The watcher's one thread, owned by this object: Instance#start
+          # starts it once (under Streamer's @current_mutex); #stop wakes it
+          # through the pipe and joins it.
+          @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus/web/streamer/stream_event_dispatcher.rb

@@ -62,8 +62,17 @@ module Pgbus
         #                    nil means the default (turbo-stream); a typed
         #                    name (e.g. "presence", "reactive") lets clients
         #                    route without sniffing the HTML (issue #170).
+        #
+        # Kept Ractor-shareable, like WakeMessage (issue #527): its Strings are
+        # frozen in place (the dispatcher's own, from JSON.parse or the read),
+        # and `exclude` is normalized to the String it is compared as.
         StreamEnvelope = Data.define(:msg_id, :enqueued_at, :payload, :source, :visible_to, :exclude, :event) do
           def initialize(msg_id:, enqueued_at:, payload:, source:, visible_to: nil, exclude: nil, event: nil)
+            enqueued_at&.freeze
+            payload&.freeze
+            source&.freeze
+            event&.freeze
+            exclude = exclude&.to_s&.freeze
             super
           end
         end
@@ -147,7 +156,10 @@ module Pgbus
           return if @running
 
           @running = true
-          @thread = Thread.new { run_loop }
+          # The dispatcher's one thread, owned by this object: Instance#start
+          # starts it once (under Streamer's @current_mutex); #stop sends the
+          # sentinel and joins it.
+          @thread = Thread.new { run_loop } # rubocop:disable ThreadSafety/NewThread
           self
         end
 

data/lib/pgbus.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
 require "zeitwerk"
 
 module Pgbus
@@ -83,17 +84,37 @@ module Pgbus
   end
 
   class << self
+    # The gem's Zeitwerk loader, the app/models loader used outside Rails, and
+    # the configuration: built once when this file loads (see the bottom of
+    # the module body) and replaced only by reset!/teardown under @state_lock.
+    # Readers need no lock: a reference is published whole.
+    attr_reader :loader, :models_loader, :configuration
+
     # Process-global flag set by Worker#graceful_shutdown so the adapter
     # can report stopping? to ActiveJob::Continuation (Rails 8.1+).
-    attr_writer :stopping
-
     def stopping
-      @stopping || false
+      @state_lock.synchronize { @stopping }
+    end
+
+    def stopping=(value)
+      @state_lock.synchronize { @stopping = value ? true : false }
     end
 
-    def loader
-      @loader ||= begin
-        loader = Zeitwerk::Loader.for_gem
+    private
+
+    # True while a Rails app boots (its initializers and after_initialize
+    # blocks run): the engine finalizes at the end of that.
+    def rails_booting?
+      return false unless defined?(::Rails::Application) && ::Rails.respond_to?(:application)
+
+      app = ::Rails.application
+      !app.nil? && !app.initialized?
+    end
+
+    # Zeitwerk::Loader.for_gem works out the gem root from its caller, so this
+    # must stay in lib/pgbus.rb.
+    def build_loader
+      Zeitwerk::Loader.for_gem.tap do |loader|
         loader.inflector.inflect(
           "pgbus" => "Pgbus",
           "cli" => "CLI",
@@ -127,35 +148,32 @@ module Pgbus
         # root and tries to autoload Puma::Plugin, which collides with the real
         # Puma::Plugin class defined by the puma gem itself.
         loader.ignore("#{__dir__}/puma")
-        loader
       end
     end
 
     # Separate loader for app/models used only in non-Rails contexts (specs,
     # standalone scripts). When the Engine boots, Rails' autoloader takes over
     # app/models and this loader is torn down to avoid conflicts.
-    def models_loader
+    def build_models_loader
       models_dir = File.expand_path("../app/models", __dir__)
       return nil unless File.directory?(models_dir)
 
-      @models_loader ||= begin
-        loader = Zeitwerk::Loader.new
+      Zeitwerk::Loader.new.tap do |loader|
         loader.tag = "pgbus-models"
         loader.push_dir(models_dir)
         loader.setup
-        loader
       end
     end
 
-    def teardown_models_loader!
-      return unless @models_loader
-
-      @models_loader.unregister
-      @models_loader = nil
-    end
+    public
 
-    def configuration
-      @configuration ||= Configuration.new
+    def teardown_models_loader!
+      loader = @state_lock.synchronize do
+        current = @models_loader
+        @models_loader = nil
+        current
+      end
+      loader&.unregister
     end
 
     # True when the current process is running a rake task (db:*, assets:*, …
@@ -188,11 +206,32 @@ module Pgbus
       # until a worker path consumes it. Checking the flag after the yield
       # lets a block opt out for itself via `c.eager_validation = false`.
       configuration.validate! if configuration.eager_validation
+      # Without Rails this is the end of boot, so it finalizes; so does any
+      # configure once a Rails app has booted. While a Rails app boots, the
+      # engine's after_initialize finalizes instead, after every initializer
+      # and after_initialize block has had its say.
+      configuration.finalize! if configuration.finalized? || !rails_booting?
       configuration
     end
 
+    # The end of boot: validates the configuration (unless eager_validation
+    # is off) and freezes its plain-data settings into Ractor-shareable values
+    # (Configuration#finalize!). Callables and the logger stay as they are, on
+    # the main Ractor. Runs on its own: from the engine's after_initialize in a
+    # Rails app, at the end of each Pgbus.configure without Rails, and in
+    # `pgbus start` after its flags. Call it yourself only when you configure
+    # pgbus through setters alone, without Rails.
+    def finalize!
+      configuration.validate! if configuration.eager_validation
+      configuration.finalize!
+    end
+
+    # Built on first use, under @state_lock: two threads making the first
+    # call at once must not each build a Client (the loser's pool would be
+    # orphaned, its connections never closed). Not built at boot: a Client
+    # resolves connection options, which a rake db: task must not need.
     def client
-      @client ||= Client.new(configuration)
+      @state_lock.synchronize { @client ||= Client.new(configuration) }
     end
 
     # Entry point for the streams subsystem — `Pgbus.stream(name).broadcast(html)`
@@ -218,8 +257,7 @@ module Pgbus
       name = Streams::Stream.name_from(streamables)
       resolved = durable.nil? ? configuration.stream_durable?(name) : durable
       cache_key = "#{name}:#{resolved ? "d" : "e"}"
-      @stream_cache ||= Concurrent::Map.new
-      @stream_cache.compute_if_absent(cache_key) { Streams::Stream.new(streamables, durable: resolved) }
+      stream_cache.compute_if_absent(cache_key) { Streams::Stream.new(streamables, durable: resolved) }
     end
 
     # Compose a short, pgbus-safe stream identifier from any mix of
@@ -278,11 +316,14 @@ module Pgbus
       EventBus::Publisher.publish_later(routing_key, payload, delay: delay, headers: headers)
     end
 
+    # A fresh configuration (never nil, so readers need no lock) and no client.
     def reset!
-      @client&.close
-      @client = nil
-      @configuration = nil
-      @stream_cache = nil
+      @state_lock.synchronize do
+        @client&.close
+        @client = nil
+        @configuration = Configuration.new
+        @stream_cache = Concurrent::Map.new
+      end
     end
 
     # Discard the inherited PGMQ client after fork.
@@ -290,9 +331,13 @@ module Pgbus
     # state post-fork and attempting to acquire it can deadlock.
     # The next call to Pgbus.client will lazily create a fresh one.
     # Cached streams hold the client they were built with, so they go too.
+    # (@state_lock itself is safe to take in the child: Ruby abandons a Mutex
+    # whose owning thread did not survive the fork.)
     def reset_client!
-      @client = nil
-      @stream_cache = nil
+      @state_lock.synchronize do
+        @client = nil
+        @stream_cache = Concurrent::Map.new
+      end
     end
 
     def logger
@@ -302,13 +347,30 @@ module Pgbus
     def logger=(value)
       configuration.logger = value
     end
+
+    private
+
+    # Process-local, like the client it holds; replaced (never mutated in
+    # place) by reset!/reset_client!.
+    attr_reader :stream_cache
   end
 
-  loader.setup
+  # Module state, built here at load rather than by `||=` on first use, so no
+  # two threads can each build their own (issue #527). @state_lock guards every
+  # later write: the client memo, reset!/reset_client!, the stopping flag.
+  @state_lock = Mutex.new
+  @stopping = false
+  @client = nil
+  @stream_cache = Concurrent::Map.new
+  @loader = build_loader
+  @loader.setup
+
+  # After loader.setup: Configuration is Zeitwerk-managed.
+  @configuration = Configuration.new
 
   # In non-Rails contexts, set up model autoloading via a separate loader.
   # This is torn down by the Engine initializer when Rails boots.
-  models_loader unless defined?(Rails::Engine)
+  @models_loader = defined?(Rails::Engine) ? nil : build_models_loader
 end
 
 require "active_job/queue_adapters/pgbus_adapter" if defined?(ActiveJob)

data/sig/pgbus/active_job/adapter.rbs

@@ -0,0 +1,57 @@
+module Pgbus
+  module ActiveJob
+    # What the queue adapter delegates to.
+    class Adapter
+      def enqueue: (untyped active_job) -> untyped
+      def enqueue_at: (untyped active_job, Numeric timestamp) -> untyped
+      def enqueue_all: (Array[untyped] active_jobs) -> Integer
+    end
+  end
+
+  # The job-class options, included on ActiveJob::Base by the engine.
+  module Concurrency
+    module ClassMethods
+      def limits_concurrency: (to: Integer, ?key: untyped, ?duration: Numeric, ?on_conflict: :block | :discard | :raise) -> untyped
+      def pgbus_concurrency: () -> Hash[Symbol, untyped]?
+    end
+  end
+
+  module Uniqueness
+    module ClassMethods
+      # Any other keyword raises ArgumentError (lock_ttl: with a pointer to 1.0's removal).
+      def ensures_uniqueness: (?strategy: :until_executed | :while_executing, ?key: untyped,
+                               ?on_conflict: :reject | :discard | :log) -> untyped
+      def pgbus_uniqueness: () -> Hash[Symbol, untyped]?
+    end
+  end
+
+  module RetryBackoff
+    module JobMixin
+      module ClassMethods
+        def pgbus_retry_backoff: (?base: Numeric?, ?max: Numeric?, ?jitter: Numeric?) -> untyped
+        def pgbus_retry_backoff_config: () -> Hash[Symbol, Numeric]?
+      end
+    end
+  end
+
+  module VisibilityHeartbeat
+    module JobMixin
+      module ClassMethods
+        def pgbus_visibility_heartbeat: (?boolish enabled) -> bool
+      end
+    end
+  end
+end
+
+module ActiveJob
+  module QueueAdapters
+    # `config.active_job.queue_adapter = :pgbus`
+    class PgbusAdapter
+      def enqueue: (untyped active_job) -> untyped
+      def enqueue_at: (untyped active_job, Numeric timestamp) -> untyped
+      def enqueue_all: (Array[untyped] active_jobs) -> Integer
+      def enqueue_after_transaction_commit?: () -> bool
+      def stopping?: () -> bool
+    end
+  end
+end