riverqueue 0.11.0 → 0.12.0

data/migration/sqlite/main/008_job_id_autoincrement.up.sql

@@ -0,0 +1,123 @@
+-- Rebuild river_job so automatically generated IDs are never reused after the
+-- job holding the largest ID is deleted. Unlike PostgreSQL sequences, SQLite's
+-- default ROWID allocator may otherwise reuse that deleted ID.
+
+-- Rebuilding river_job would discard schema installed by River Pro. Check
+-- schema objects instead of migration records to also catch manually applied
+-- Pro migrations and the legacy workflow migration line.
+CREATE TEMP TABLE river_job_pro_schema_guard (
+    id integer NOT NULL
+);
+
+CREATE TEMP TRIGGER river_job_pro_schema_guard_enforce
+    BEFORE INSERT ON river_job_pro_schema_guard
+    WHEN EXISTS (
+        SELECT 1
+        FROM /* TEMPLATE: schema */sqlite_master
+        WHERE name IN ('river_job_sequence', 'river_job_workflow_scheduling', 'river_workflow')
+    )
+BEGIN
+    SELECT RAISE(ABORT, 'River SQLite migration 008 cannot run while River Pro schema is installed');
+END;
+
+INSERT INTO river_job_pro_schema_guard (id) VALUES (1);
+
+DROP TRIGGER river_job_pro_schema_guard_enforce;
+DROP TABLE river_job_pro_schema_guard;
+
+DROP INDEX /* TEMPLATE: schema */river_job_kind;
+DROP INDEX /* TEMPLATE: schema */river_job_state_and_finalized_at_index;
+DROP INDEX /* TEMPLATE: schema */river_job_prioritized_fetching_index;
+DROP INDEX /* TEMPLATE: schema */river_job_unique_idx;
+
+ALTER TABLE /* TEMPLATE: schema */river_job RENAME TO river_job_old;
+
+CREATE TABLE /* TEMPLATE: schema */river_job (
+    id integer PRIMARY KEY AUTOINCREMENT,
+    args blob NOT NULL DEFAULT (jsonb('{}')),
+    attempt integer NOT NULL DEFAULT 0,
+    attempted_at timestamp,
+    attempted_by blob, -- json
+    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    errors blob, -- json
+    finalized_at timestamp,
+    kind text NOT NULL,
+    max_attempts integer NOT NULL DEFAULT 25,
+    metadata blob NOT NULL DEFAULT (jsonb('{}')),
+    priority integer NOT NULL DEFAULT 1,
+    queue text NOT NULL DEFAULT 'default',
+    state text NOT NULL DEFAULT 'available',
+    scheduled_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    tags blob NOT NULL DEFAULT (jsonb('[]')),
+    unique_key blob,
+    unique_states integer,
+    CONSTRAINT finalized_or_finalized_at_null CHECK (
+        (finalized_at IS NULL AND state NOT IN ('cancelled', 'completed', 'discarded')) OR
+        (finalized_at IS NOT NULL AND state IN ('cancelled', 'completed', 'discarded'))
+    ),
+    CONSTRAINT priority_in_range CHECK (priority >= 1 AND priority <= 4),
+    CONSTRAINT queue_length CHECK (length(queue) > 0 AND length(queue) < 128),
+    CONSTRAINT kind_length CHECK (length(kind) > 0 AND length(kind) < 128),
+    CONSTRAINT state_valid CHECK (state IN ('available', 'cancelled', 'completed', 'discarded', 'pending', 'retryable', 'running', 'scheduled'))
+);
+
+INSERT INTO /* TEMPLATE: schema */river_job (
+    id,
+    args,
+    attempt,
+    attempted_at,
+    attempted_by,
+    created_at,
+    errors,
+    finalized_at,
+    kind,
+    max_attempts,
+    metadata,
+    priority,
+    queue,
+    state,
+    scheduled_at,
+    tags,
+    unique_key,
+    unique_states
+)
+SELECT
+    id,
+    args,
+    attempt,
+    attempted_at,
+    attempted_by,
+    created_at,
+    errors,
+    finalized_at,
+    kind,
+    max_attempts,
+    metadata,
+    priority,
+    queue,
+    state,
+    scheduled_at,
+    tags,
+    unique_key,
+    unique_states
+FROM /* TEMPLATE: schema */river_job_old;
+
+DROP TABLE /* TEMPLATE: schema */river_job_old;
+
+CREATE INDEX /* TEMPLATE: schema */river_job_kind ON river_job (kind);
+CREATE INDEX /* TEMPLATE: schema */river_job_state_and_finalized_at_index ON river_job (state, finalized_at) WHERE finalized_at IS NOT NULL;
+CREATE INDEX /* TEMPLATE: schema */river_job_prioritized_fetching_index ON river_job (state, queue, priority, scheduled_at, id);
+CREATE UNIQUE INDEX /* TEMPLATE: schema */river_job_unique_idx ON river_job (unique_key)
+    WHERE unique_key IS NOT NULL
+        AND unique_states IS NOT NULL
+        AND CASE state
+            WHEN 'available' THEN unique_states & (1 << 0)
+            WHEN 'cancelled' THEN unique_states & (1 << 1)
+            WHEN 'completed' THEN unique_states & (1 << 2)
+            WHEN 'discarded' THEN unique_states & (1 << 3)
+            WHEN 'pending'   THEN unique_states & (1 << 4)
+            WHEN 'retryable' THEN unique_states & (1 << 5)
+            WHEN 'running'   THEN unique_states & (1 << 6)
+            WHEN 'scheduled' THEN unique_states & (1 << 7)
+            ELSE 0
+        END >= 1;

data/sig/client.rbs

@@ -0,0 +1,95 @@
+module River
+  MAX_ATTEMPTS_DEFAULT: Integer
+  PRIORITY_DEFAULT: Integer
+  QUEUE_DEFAULT: String
+
+  class Client
+    @config: Config
+    @driver: _Driver
+    @runtime: ClientRuntime
+    @time_now_utc: ^() -> Time
+
+    attr_reader config: Config
+    attr_reader driver: _Driver
+
+    def initialize: (_Driver driver, ?config: Config?) -> void
+    def __finish_claimed_job: (JobRow, ?Exception?) -> untyped
+    def __perform_job: (Integer, ?allow_scheduled: bool) -> untyped
+    def __interrupt_workers: () -> untyped
+    def __runtime_healthy?: () -> bool
+    def id: () -> String
+    def insert: (jobArgs, ?insert_opts: InsertOpts?, ?max_attempts: Integer?,
+      ?metadata: Hash[String | Symbol, untyped]?, ?priority: Integer?, ?queue: (String | Symbol)?,
+      ?scheduled_at: Time?, ?state: jobStateInput?, ?tags: Array[String]?, ?unique_opts: UniqueOpts?) -> JobInsertResult
+    def insert_many: (Array[jobArgs | InsertManyParams]) -> Array[JobInsertResult]
+    def job_cancel: (Integer) -> JobRow
+    def job_delete: (Integer) -> JobRow
+    def job_delete_many: (?JobListParams?, ?after: untyped, ?after_id: untyped,
+      ?ids: untyped, ?kinds: untyped, ?limit: untyped, ?metadata: untyped, ?priorities: untyped,
+      ?queues: untyped, ?sort_by: untyped, ?sort_order: untyped, ?states: untyped,
+      ?tags_all: untyped, ?tags_any: untyped) -> untyped
+    def job_get: (Integer) -> JobRow
+    def job_list: (?JobListParams?, ?after: untyped, ?after_id: untyped,
+      ?ids: untyped, ?kinds: untyped, ?limit: untyped, ?metadata: untyped, ?priorities: untyped,
+      ?queues: untyped, ?sort_by: untyped, ?sort_order: untyped, ?states: untyped,
+      ?tags_all: untyped, ?tags_any: untyped) -> untyped
+    def job_retry: (Integer) -> JobRow
+    def job_update: (Integer, ?JobUpdateParams?, ?attempt: untyped, ?attempted_at: untyped,
+      ?attempted_by: untyped, ?errors: untyped, ?finalized_at: untyped, ?max_attempts: untyped,
+      ?metadata: untyped, ?state: untyped) -> JobRow
+    def periodic_jobs: () -> PeriodicJobBundle
+    def queue_add: (String | Symbol, QueueConfig | Integer) -> self
+    def queue_get: (String | Symbol) -> Queue
+    def queue_list: (?max: Integer) -> untyped
+    def queue_pause: (String | Symbol) -> bool
+    def queue_remove: (String | Symbol) -> self
+    def queue_resume: (String | Symbol) -> bool
+    def queue_update: (String | Symbol, metadata: Hash[untyped, untyped]) -> Queue
+    def start: () -> self
+    def started?: () -> bool
+    def stop: (?wait: bool) -> self
+    def stop_and_cancel: () -> self
+    def stopped?: () -> bool
+    def subscribe: (*Symbol | String kinds, ?buffer_size: Integer) -> Subscription
+
+    DEFAULT_UNIQUE_STATES: Array[jobStateAll]
+    EMPTY_INSERT_OPTS: InsertOpts
+    REQUIRED_UNIQUE_STATES: Array[jobStateAll]
+    TAG_RE: Regexp
+
+    private def insert_and_check_unique_job: (Driver::JobInsertParams) -> JobInsertResult
+    private def make_insert_params: (jobArgs, InsertOpts) -> Driver::JobInsertParams
+    private def make_unique_key_and_bitmask: (Driver::JobInsertParams, UniqueOpts) -> [String, String]
+    private def run_insert_plugins: (Array[Driver::JobInsertParams]) { () -> Array[JobInsertResult] } -> Array[JobInsertResult]
+    private def truncate_time: (Time, Integer | Rational) -> Time
+    private def uint64_to_int64: (Integer) -> Integer
+    private def validate_tags: (Array[String]) -> Array[String]
+    private def validate_unique_states: (Array[jobStateInput]) -> Array[jobStateAll]
+  end
+
+  class InsertManyParams
+    @args: jobArgs
+    @insert_opts: InsertOpts?
+
+    attr_reader args: jobArgs
+    attr_reader insert_opts: InsertOpts?
+
+    def initialize: (jobArgs job, ?insert_opts: InsertOpts?, ?max_attempts: Integer?,
+      ?metadata: Hash[String | Symbol, untyped]?, ?priority: Integer?, ?queue: (String | Symbol)?,
+      ?scheduled_at: Time?, ?state: jobStateInput?, ?tags: Array[String]?, ?unique_opts: UniqueOpts?) -> void
+    def is_a?: (Class) -> bool
+  end
+
+  class JobInsertResult
+    @job: JobRow
+    @unique_skipped_as_duplicate: bool
+
+    attr_reader job: JobRow
+    def unique_skipped_as_duplicate?: () -> bool
+    alias unique_skipped_as_duplicated unique_skipped_as_duplicate?
+
+    def initialize: (JobRow job, unique_skipped_as_duplicated: bool) -> void
+  end
+
+  class InsertResult = JobInsertResult
+end

data/sig/driver.rbs

@@ -0,0 +1,170 @@
+module River
+  interface _Driver
+    def respond_to?: (Symbol, ?bool) -> bool
+    def init_driver: () -> void
+    def migration_backend: () -> Symbol
+    def migration_connection: [A] () { (untyped) -> A } -> A
+    def advisory_lock: (Integer) -> void
+    def job_cancel: (Integer, ?now: Time) -> JobRow?
+    def job_delete: (Integer) -> JobRow?
+    def job_delete_finalized: (**untyped) -> Integer
+    def job_delete_if_running: (Integer) -> bool
+    def job_delete_many: (JobListParams) -> Array[JobRow]
+    def job_get_available: (queue: String, max: Integer, attempted_by: String, ?kinds: Array[String]?, ?now: Time) -> Array[JobRow]
+    def job_claim: (id: Integer, attempted_by: String, ?allow_scheduled: bool, ?now: Time) -> JobRow?
+    def job_get_cancelled_ids: (Array[Integer]) -> Array[Integer]
+    def job_complete: (id: Integer, finalized_at: Time, ?metadata: Hash[untyped, untyped]?, ?now: Time) -> (JobRow | :cancelled)?
+    def job_get_by_kind_and_unique_properties: (Driver::JobGetByKindAndUniquePropertiesParam) -> JobRow?
+    def job_insert: (Driver::JobInsertParams) -> [JobRow, bool]
+    def job_insert_many: (Array[Driver::JobInsertParams]) -> Array[[JobRow, bool]]
+    def job_metadata_merge: (Integer, Hash[untyped, untyped]) -> JobRow?
+    def job_rescue_stuck: (**untyped) -> Integer
+    def job_retry: (Integer, ?now: Time) -> JobRow?
+    def job_schedule: (?now: Time, ?max: Integer) -> Integer
+    def job_set_state_if_running: (**untyped) -> JobRow?
+    def job_update: (Integer, JobUpdateParams) -> JobRow?
+    def leader_acquire: (String, ?ttl: Integer, ?now: Time) -> bool
+    def leader_release: (String) -> untyped
+    def leader_renew: (String, ?ttl: Integer, ?now: Time) -> bool
+    def notification_delete_before: (horizon: Time, ?max: Integer) -> Integer
+    def queue_get: (String) -> Queue?
+    def queue_list: (?max: Integer) -> Array[Queue]
+    def queue_pause: (String, ?now: Time) -> untyped
+    def queue_resume: (String, ?now: Time) -> untyped
+    def queue_update: (String, metadata: Hash[untyped, untyped], ?now: Time) -> Queue?
+    def queue_upsert: (String, ?metadata: Hash[untyped, untyped], ?now: Time) -> Queue?
+    def transaction: [T] () { () -> T } -> T
+
+    # this set of methods is used only in tests
+    def advisory_lock_try: (Integer) -> bool
+    def job_get_by_id: (Integer) -> JobRow?
+    def job_list: (?JobListParams | :all) -> Array[JobRow]
+    def rollback_exception: -> Exception
+  end
+
+  module Driver
+    class JobRowDecoder
+      ZERO_TIME: Time
+      @errors: Array[String]
+      def self.attempt_error: (untyped) -> AttemptError
+      def self.error_time: (untyped) -> Time
+      def self.error_integer: (untyped) -> Integer
+      def self.error_string: (untyped) -> String
+      def initialize: () -> void
+      def json: (Symbol, untyped, ?type: Class?, ?strings: bool, ?default: untyped) -> untyped
+      def decoded: (Symbol, untyped, ?type: Class?, ?strings: bool, ?default: untyped) -> untyped
+      def finish: (JobRow) -> JobRow
+    end
+
+    class PostgresCapabilities
+      attr_reader supports_listen_notify: bool
+      attr_reader unique_insert_mode: :metadata_nonce | :returning_old | :xmax
+      attr_reader unique_insert_sql: String
+      def initialize: (product: String, version_num: Integer, yb_listen_notify_enabled: bool) -> void
+
+      class Cache
+        @mutex: Mutex
+        @values: Hash[untyped, PostgresCapabilities]
+        def initialize: () -> void
+        def fetch: (untyped) { () -> PostgresCapabilities } -> PostgresCapabilities
+      end
+    end
+
+    class JobGetByKindAndUniquePropertiesParam
+      attr_accessor created_at: [Time, Time]?
+      attr_accessor encoded_args: String?
+      attr_accessor kind: String
+      attr_accessor queue: String?
+      attr_accessor state: Array[jobStateAll]?
+
+      def initialize: (kind: String, ?created_at: [Time, Time]?, ?encoded_args: String?, ?queue: String?, ?state: Array[jobStateAll]?) -> void
+    end
+
+    class JobInsertParams
+      attr_accessor args: untyped
+      attr_accessor encoded_args: String
+      attr_accessor kind: String
+      attr_accessor max_attempts: Integer
+      attr_accessor metadata: Hash[untyped, untyped]
+      attr_accessor priority: Integer
+      attr_accessor queue: String
+      attr_accessor scheduled_at: Time?
+      attr_accessor state: jobStateAll
+      attr_accessor tags: Array[String]?
+      attr_accessor unique_key: String?
+      attr_accessor unique_states: String?
+
+      def initialize: (?args: untyped, encoded_args: String, kind: String, max_attempts: Integer, ?metadata: Hash[untyped, untyped], priority: Integer, queue: String, scheduled_at: Time?, state: jobStateAll, tags: Array[String]?, ?unique_key: String?, ?unique_states: String?) -> void
+    end
+
+    module Runtime
+      def runtime_read_job: (untyped) -> untyped
+      def runtime_decode_sqlite_job: (untyped) -> JobRow
+      def runtime_decode_postgres_job: (untyped) -> JobRow
+      @postgres_capabilities_cache: PostgresCapabilities::Cache
+      def init_driver: () -> void
+      def postgres_capabilities: () -> PostgresCapabilities
+      def postgres_notify_insert: (Array[JobInsertParams]) -> void
+      def job_get_cancelled_ids: (Array[Integer]) -> Array[Integer]
+      def job_complete: (id: untyped, finalized_at: untyped, ?metadata: untyped, ?now: untyped) -> untyped
+      def job_cancel: (untyped, ?now: untyped) -> untyped
+      def job_delete: (untyped) -> untyped
+      def job_delete_finalized: (retention: untyped, ?now: untyped, ?max: untyped) -> untyped
+      def job_delete_if_running: (untyped) -> untyped
+      def job_delete_many: (untyped) -> untyped
+      def job_get_available: (queue: untyped, max: untyped, attempted_by: untyped, ?kinds: untyped, ?now: untyped) -> untyped
+      def job_claim: (id: untyped, attempted_by: untyped, ?allow_scheduled: untyped, ?now: untyped) -> untyped
+      private def runtime_claim_jobs: (untyped, untyped, untyped, untyped) -> untyped
+      def job_list: (?untyped) -> untyped
+      def job_metadata_merge: (untyped, untyped) -> untyped
+      def job_rescue_stuck: (horizon: untyped, retry_policy: untyped, ?now: untyped, ?max: untyped) -> untyped
+      def job_retry: (untyped, ?now: untyped) -> untyped
+      def job_schedule: (?now: untyped, ?max: untyped) -> untyped
+      def job_set_state_if_running: (id: untyped, state: untyped, ?now: untyped, ?attempt: untyped, ?error: untyped, ?finalized_at: untyped, ?metadata: untyped, ?scheduled_at: untyped) -> untyped
+      def job_update: (untyped, untyped) -> untyped
+      def leader_acquire: (untyped, ?ttl: untyped, ?now: untyped) -> untyped
+      def leader_release: (untyped) -> untyped
+      def leader_renew: (untyped, ?ttl: untyped, ?now: untyped) -> untyped
+      def notification_delete_before: (horizon: untyped, ?max: untyped) -> untyped
+      def queue_get: (untyped) -> untyped
+      def queue_list: (?max: untyped) -> untyped
+      def queue_pause: (untyped, ?now: untyped) -> untyped
+      def queue_resume: (untyped, ?now: untyped) -> untyped
+      def queue_update: (untyped, metadata: untyped, ?now: untyped) -> untyped
+      def queue_upsert: (untyped, ?metadata: untyped, ?now: untyped) -> untyped
+
+      private
+
+      def job_get_by_id: (untyped) -> untyped
+      def runtime_append_error: (untyped) -> untyped
+      def runtime_cancel_attempted: () -> untyped
+      def runtime_connection_pool: () -> untyped
+      def runtime_cursor_clause: (untyped) -> String
+      def runtime_execute: (String) -> untyped
+      def runtime_in_clause: (untyped, untyped) -> untyped
+      def runtime_job_list_without_params: () -> untyped
+      def runtime_job_rows: (String) -> untyped
+      def runtime_json: (untyped) -> untyped
+      def runtime_merge_metadata: (untyped) -> untyped
+      def runtime_metadata_equals: (untyped, untyped) -> untyped
+      def runtime_nullable_time: (untyped) -> untyped
+      def runtime_notify: (String, untyped) -> untyped
+      def sqlite_insert_nonces: (Array[JobInsertParams]) -> Array[String]
+      def runtime_parse_json: (untyped) -> untyped
+      def runtime_parse_time: (untyped) -> untyped
+      def runtime_postgres?: () -> bool
+      def runtime_query_rows: (String) -> untyped
+      def runtime_queue_columns: () -> untyped
+      def runtime_queue_from_row: (untyped) -> untyped
+      def runtime_quote: (untyped) -> String
+      def runtime_returning_ids: (untyped) -> untyped
+      def runtime_state: (untyped) -> untyped
+      def runtime_tag_contains: (untyped) -> untyped
+      def runtime_time: (untyped) -> untyped
+      def runtime_unique_violation_class: () -> singleton(Exception)
+      def runtime_update_value: (untyped, untyped) -> untyped
+      def runtime_value: (untyped, untyped) -> untyped
+      def transaction: () { () -> untyped } -> untyped
+    end
+  end
+end

data/sig/insert_opts.rbs

@@ -0,0 +1,25 @@
+module River
+  class InsertOpts
+    attr_accessor max_attempts: Integer?
+    attr_accessor metadata: Hash[String | Symbol, untyped]?
+    attr_accessor priority: Integer?
+    attr_accessor queue: (String | Symbol)?
+    attr_accessor scheduled_at: Time?
+    attr_accessor state: jobStateInput?
+    attr_accessor tags: Array[String]?
+    attr_accessor unique_opts: UniqueOpts?
+
+    def initialize: (?max_attempts: Integer?, ?metadata: Hash[String | Symbol, untyped]?, ?priority: Integer?, ?queue: (String | Symbol)?, ?scheduled_at: Time?, ?state: jobStateInput?, ?tags: Array[String]?, ?unique_opts: UniqueOpts?) -> void
+  end
+
+  class UniqueOpts
+    def empty?: () -> bool
+    attr_accessor by_args: bool? | Array[String | Symbol | Array[String | Symbol]]?
+    attr_accessor by_period: (Integer | Rational)?
+    attr_accessor by_queue: bool?
+    attr_accessor by_state: Array[jobStateInput]?
+    attr_accessor exclude_kind: bool?
+
+    def initialize: (?by_args: bool? | Array[String | Symbol | Array[String | Symbol]]?, ?by_period: (Integer | Rational)?, ?by_queue: bool?, ?by_state: Array[jobStateInput]?, ?exclude_kind: bool?) -> void
+  end
+end

data/sig/job.rbs

@@ -0,0 +1,72 @@
+module River
+  JOB_STATE_AVAILABLE: "available"
+  JOB_STATE_CANCELLED: "cancelled"
+  JOB_STATE_COMPLETED: "completed"
+  JOB_STATE_DISCARDED: "discarded"
+  JOB_STATE_PENDING: "pending"
+  JOB_STATE_RETRYABLE: "retryable"
+  JOB_STATE_RUNNING: "running"
+  JOB_STATE_SCHEDULED: "scheduled"
+
+  type jobStateAll = "available" | "cancelled" | "completed" | "discarded" | "pending" | "retryable" | "running" | "scheduled"
+  type jobStateInput = jobStateAll | :available | :cancelled | :completed | :discarded | :pending | :retryable | :running | :scheduled
+
+  interface _JobArgs
+    def is_a?: (Class) -> bool
+    def kind: () -> (String | Symbol)
+    def respond_to?: (Symbol) -> bool
+    def to_json: () -> String
+  end
+
+  interface _JobArgsWithInsertOpts
+    include _JobArgs
+
+    def insert_opts: () -> InsertOpts?
+  end
+
+  type jobArgs = _JobArgs  | _JobArgsWithInsertOpts
+
+  class JobArgsHash
+    @hash: Hash[String | Symbol, untyped]
+    @kind: String
+
+    attr_reader kind: String
+
+    def initialize: (String | Symbol kind, Hash[String | Symbol, untyped] hash) -> void
+    def to_json: () -> String
+  end
+
+  class JobRow
+    attr_accessor __decode_error: JobRowDecodeError?
+    attr_accessor args: Hash[String, untyped]
+    attr_accessor attempt: Integer
+    attr_accessor attempted_at: Time?
+    attr_accessor attempted_by: Array[String]?
+    attr_accessor created_at: Time
+    attr_accessor errors: Array[AttemptError]?
+    attr_accessor finalized_at: Time?
+    attr_accessor id: Integer
+    attr_accessor kind: String
+    attr_accessor max_attempts: Integer
+    attr_accessor metadata: Hash[String, untyped]
+    attr_accessor priority: Integer
+    attr_accessor queue: String
+    attr_accessor scheduled_at: Time
+    attr_accessor state: jobStateAll
+    attr_accessor tags: Array[String]?
+    attr_accessor unique_key: String?
+    attr_accessor unique_states: Array[jobStateAll]?
+
+    def initialize: (id: Integer, args: Hash[String, untyped], attempt: Integer, ?attempted_at: Time?, ?attempted_by: Array[String]?, created_at: Time, ?errors: Array[AttemptError]?, ?finalized_at: Time?, kind: String, max_attempts: Integer, metadata: Hash[String, untyped], priority: Integer, queue: String, scheduled_at: Time, state: jobStateAll, ?tags: Array[String]?, ?unique_key: String?, ?unique_states: Array[jobStateAll]?) -> void
+  end
+
+  class AttemptError
+    attr_accessor at: Time
+    attr_accessor attempt: Integer
+    attr_accessor error: String
+    attr_accessor trace: String
+
+    def initialize: (at: Time, attempt: Integer, error: String, trace: String) -> void
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/job_persisted_logging/plugin.rbs

@@ -0,0 +1,29 @@
+module River
+  module JobPersistedLogging
+    class Plugin
+      @logger_factory: (^(Buffer) -> untyped)?
+      @max_size_bytes: Integer
+      @max_total_bytes: Integer
+
+      def initialize: (?max_size_bytes: Integer, ?max_total_bytes: Integer) ?{ (Buffer) -> untyped } -> void
+      def work: [T] (Job, ^() -> T) -> T
+
+      private
+
+      def persist_log: (Job, Buffer) -> void
+
+      class Buffer
+        @closed: bool
+        @data: String
+        @limit: Integer
+        @mutex: Mutex
+        @truncated: bool
+
+        def initialize: (Integer) -> void
+        def close: () -> nil
+        def finish: () -> [String, bool]
+        def write: (_ToS) -> Integer
+      end
+    end
+  end
+end

data/sig/migrator.rbs

@@ -0,0 +1,44 @@
+class Gem::Specification
+  def self.find_all_by_name: (String, *untyped) -> Array[Gem::Specification]
+end
+
+module River
+  module MigrationCLI
+    def self.detect_driver: () -> String
+    def self.run: (Array[String], ?err: untyped, ?out: untyped) -> Integer
+  end
+  class Migrator
+    class Migration < Data
+      attr_reader version: Integer
+      attr_reader name: String
+      attr_reader sql_up: String
+      attr_reader sql_down: String
+      def self.new: (Integer, untyped, String, String) -> instance
+    end
+    class Status < Data
+      attr_reader version: Integer
+      attr_reader name: String
+      attr_reader applied: bool
+      def self.new: (Integer, String, bool) -> instance
+    end
+    @backend: Symbol
+    @connection: untyped
+    @driver: untyped
+    @line: String
+    @migrations: Array[Migration]
+    @mutex: Mutex
+    @requested_schema: untyped
+    @schema: untyped
+    attr_reader migrations: Array[Migration]
+    def initialize: (untyped, ?line: String, ?migrations_path: String, ?schema: untyped) -> void
+    def migrate: (?direction: Symbol, ?dry_run: bool, ?steps: untyped, ?target: untyped) -> Array[Migration]
+    def status: () -> Array[Status]
+    private
+    def execute: (String) -> untyped
+    def existing_versions: () -> Array[Integer]
+    def line_column?: () -> bool
+    def query: (String) -> untyped
+    def session: [A] (?lock: bool) { () -> A } -> A
+    def table: () -> String
+  end
+end

data/sig/riverqueue.rbs

@@ -0,0 +1,2 @@
+module River
+end