zizq 0.5.0 → 0.6.0

data/lib/zizq/resources/job.rb

@@ -12,14 +12,15 @@ module Zizq
     # retention, unique_key, unique_while) from JobTemplate and adds
     # lifecycle fields and action methods.
     class Job < JobTemplate
-      def id          = @data["id"]          #: () -> String
-      def status      = @data["status"]      #: () -> String
-      def ready_at    = ms_to_seconds(@data["ready_at"])    #: () -> Float?
-      def attempts    = @data["attempts"]    #: () -> Integer
+      def id = @data["id"] #: () -> String
+      def status = @data["status"] #: () -> String
+      def ready_at = ms_to_seconds(@data["ready_at"]) #: () -> Float?
+      def attempts = @data["attempts"] #: () -> Integer
       def dequeued_at = ms_to_seconds(@data["dequeued_at"]) #: () -> Float?
-      def failed_at     = ms_to_seconds(@data["failed_at"])     #: () -> Float?
-      def completed_at  = ms_to_seconds(@data["completed_at"])  #: () -> Float?
-      def duplicate?    = @data["duplicate"] == true #: () -> bool
+      def failed_at = ms_to_seconds(@data["failed_at"]) #: () -> Float?
+      def completed_at = ms_to_seconds(@data["completed_at"]) #: () -> Float?
+      def duplicate? = @data["duplicate"] == true #: () -> bool
+      def folded? = @data["folded"] == true #: () -> bool
 
       # Fetch the error history for this job.
       #
@@ -44,8 +45,21 @@ module Zizq
       # @rbs retry_at: Float?
       # @rbs kill: bool
       # @rbs return: Job
-      def fail!(message:, error_type: nil, backtrace: nil, retry_at: nil, kill: false)
-        @client.report_failure(id, message:, error_type:, backtrace:, retry_at:, kill:)
+      def fail!(
+        message:,
+        error_type: nil,
+        backtrace: nil,
+        retry_at: nil,
+        kill: false
+      )
+        @client.report_failure(
+          id,
+          message:,
+          error_type:,
+          backtrace:,
+          retry_at:,
+          kill:
+        )
       end
 
       # Delete this job.
@@ -66,21 +80,24 @@ module Zizq
       # @rbs backoff: (Zizq::backoff | singleton(Zizq::RESET) | singleton(Zizq::UNCHANGED))?
       # @rbs retention: (Zizq::retention | singleton(Zizq::RESET) | singleton(Zizq::UNCHANGED))?
       # @rbs return: Job
-      def update(queue: Zizq::UNCHANGED,
-                 priority: Zizq::UNCHANGED,
-                 ready_at: Zizq::UNCHANGED,
-                 retry_limit: Zizq::UNCHANGED,
-                 backoff: Zizq::UNCHANGED,
-                 retention: Zizq::UNCHANGED)
-        job = @client.update_job(
-          id,
-          queue:,
-          priority:,
-          ready_at:,
-          retry_limit:,
-          backoff:,
-          retention:
-        )
+      def update(
+        queue: Zizq::UNCHANGED,
+        priority: Zizq::UNCHANGED,
+        ready_at: Zizq::UNCHANGED,
+        retry_limit: Zizq::UNCHANGED,
+        backoff: Zizq::UNCHANGED,
+        retention: Zizq::UNCHANGED
+      )
+        job =
+          @client.update_job(
+            id,
+            queue:,
+            priority:,
+            ready_at:,
+            retry_limit:,
+            backoff:,
+            retention:
+          )
 
         # Make sure this job's fields are updated.
         @data.merge!(job.to_h)

data/lib/zizq/resources/job_page.rb

@@ -38,18 +38,29 @@ module Zizq
       # @rbs backoff: (Zizq::backoff | singleton(Zizq::RESET) | singleton(Zizq::UNCHANGED))?
       # @rbs retention: (Zizq::retention | singleton(Zizq::RESET) | singleton(Zizq::UNCHANGED))?
       # @rbs return: Integer
-      def update_all(queue: Zizq::UNCHANGED,
-                     priority: Zizq::UNCHANGED,
-                     ready_at: Zizq::UNCHANGED,
-                     retry_limit: Zizq::UNCHANGED,
-                     backoff: Zizq::UNCHANGED,
-                     retention: Zizq::UNCHANGED)
+      def update_all(
+        queue: Zizq::UNCHANGED,
+        priority: Zizq::UNCHANGED,
+        ready_at: Zizq::UNCHANGED,
+        retry_limit: Zizq::UNCHANGED,
+        backoff: Zizq::UNCHANGED,
+        retention: Zizq::UNCHANGED
+      )
         ids = jobs.map(&:id)
         return 0 if ids.empty?
 
         client.update_all_jobs(
-          where: { id: ids },
-          apply: { queue:, priority:, ready_at:, retry_limit:, backoff:, retention: },
+          where: {
+            id: ids
+          },
+          apply: {
+            queue:,
+            priority:,
+            ready_at:,
+            retry_limit:,
+            backoff:,
+            retention:
+          }
         )
       end
     end

data/lib/zizq/resources/job_template.rb

@@ -9,15 +9,23 @@ module Zizq
     # Typed wrapper around a job template — the fields shared between
     # live jobs and cron entry job definitions.
     class JobTemplate < Resource
-      def type         = @data["type"]         #: () -> String
-      def queue        = @data["queue"]        #: () -> String
-      def priority     = @data["priority"]     #: () -> Integer?
-      def payload      = @data["payload"]      #: () -> Hash[String, untyped]?
-      def retry_limit  = @data["retry_limit"]  #: () -> Integer?
-      def unique_key   = @data["unique_key"]   #: () -> String?
+      def type = @data["type"] #: () -> String
+      def queue = @data["queue"] #: () -> String
+      def priority = @data["priority"] #: () -> Integer?
+      def payload = @data["payload"] #: () -> Hash[String, untyped]?
+      def retry_limit = @data["retry_limit"] #: () -> Integer?
+      def unique_key = @data["unique_key"] #: () -> String?
       def unique_while = @data["unique_while"]&.to_sym #: () -> Zizq::unique_scope?
 
-      # Backoff configuration converted from the wire format (ms) to the
+      # Batching configuration for this job. Retutns `nil` for non-batched jobs.
+      def batch #: () -> Zizq::batch?
+        raw = @data["batch"]
+        return nil unless raw
+
+        { key: raw["key"], when: raw["when"], fold: raw["fold"] }
+      end
+
+      # Backoff configuration converted from the API format (ms) to the
       # Ruby-idiomatic format (seconds), matching the Zizq::backoff type.
       def backoff #: () -> Zizq::backoff?
         raw = @data["backoff"]
@@ -30,7 +38,7 @@ module Zizq
         }
       end
 
-      # Retention configuration converted from the wire format (ms) to the
+      # Retention configuration converted from the API format (ms) to the
       # Ruby-idiomatic format (seconds), matching the Zizq::retention type.
       def retention #: () -> Zizq::retention?
         raw = @data["retention"]

data/lib/zizq/resources/page.rb

@@ -21,7 +21,8 @@ module Zizq
 
       # Wrapped resource objects for this page.
       def items #: () -> Array[T]
-        raise NotImplementedError, "#{self.class.name}#items must be implemented"
+        raise NotImplementedError,
+              "#{self.class.name}#items must be implemented"
       end
 
       # Returns the underlying raw response hash.

data/lib/zizq/resources/resource.rb

@@ -27,10 +27,11 @@ module Zizq
 
       # Omit the client from inspect output to reduce noise.
       def inspect #: () -> String
-        ivars = instance_variables
-          .reject { |v| v == :@client }
-          .map { |v| " #{v}=#{instance_variable_get(v).inspect}" }
-          .join
+        ivars =
+          instance_variables
+            .reject { |v| v == :@client }
+            .map { |v| " #{v}=#{instance_variable_get(v).inspect}" }
+            .join
         "#<#{self.class}#{ivars}>"
       end
 

data/lib/zizq/resources.rb

@@ -5,15 +5,15 @@
 
 module Zizq
   module Resources
-    autoload :Resource,        "zizq/resources/resource"
-    autoload :JobTemplate,     "zizq/resources/job_template"
-    autoload :Job,             "zizq/resources/job"
-    autoload :ErrorRecord,     "zizq/resources/error_record"
-    autoload :Page,            "zizq/resources/page"
-    autoload :JobPage,         "zizq/resources/job_page"
-    autoload :ErrorPage,       "zizq/resources/error_page"
+    autoload :Resource, "zizq/resources/resource"
+    autoload :JobTemplate, "zizq/resources/job_template"
+    autoload :Job, "zizq/resources/job"
+    autoload :ErrorRecord, "zizq/resources/error_record"
+    autoload :Page, "zizq/resources/page"
+    autoload :JobPage, "zizq/resources/job_page"
+    autoload :ErrorPage, "zizq/resources/error_page"
     autoload :ErrorEnumerator, "zizq/resources/error_enumerator"
-    autoload :CronGroup,       "zizq/resources/cron_group"
-    autoload :CronEntry,       "zizq/resources/cron_entry"
+    autoload :CronGroup, "zizq/resources/cron_group"
+    autoload :CronEntry, "zizq/resources/cron_entry"
   end
 end

data/lib/zizq/router.rb

@@ -55,7 +55,8 @@ module Zizq
     # route and no fallback. Caught by Zizq's normal worker error
     # path, which nacks the job for retry (or dead-letters it once
     # the retry limit is hit).
-    class UnknownJobType < Zizq::Error; end
+    class UnknownJobType < Zizq::Error
+    end
 
     # @rbs &block: ?(self) [self: Router] -> void
     def initialize(&block)
@@ -94,7 +95,7 @@ module Zizq
       return @fallback.call(job) if @fallback
 
       raise UnknownJobType,
-        "no handler registered for job type #{job.type.inspect}"
+            "no handler registered for job type #{job.type.inspect}"
     end
   end
 end

data/lib/zizq/test/client.rb

@@ -26,7 +26,8 @@ module Zizq
     class Client < Zizq::Client
       # Raised when test-mode code reaches an operation that isn't
       # supported (queries, queue listing, worker streams, etc.).
-      class NotSupported < Zizq::Error; end
+      class NotSupported < Zizq::Error
+      end
 
       # Length of a real scru128 id in its base-32 representation.
       # Synthetic test ids are sized to match (`test` prefix + zero
@@ -39,10 +40,10 @@ module Zizq
       # report. Test mode never retries — `in_flight` only ever
       # transitions to `completed` or `dead`.
       STATUS_SCHEDULED = "scheduled"
-      STATUS_READY     = "ready"
+      STATUS_READY = "ready"
       STATUS_IN_FLIGHT = "in_flight"
       STATUS_COMPLETED = "completed"
-      STATUS_DEAD      = "dead"
+      STATUS_DEAD = "dead"
 
       # Default `filter:` lambda — passes every job. Named so the
       # filter pipeline is always callable without nil-checking.
@@ -132,28 +133,33 @@ module Zizq
       end
 
       # @rbs override
-      def enqueue(queue:,
-                  type:,
-                  payload:,
-                  priority: nil,
-                  ready_at: nil,
-                  retry_limit: nil,
-                  backoff: nil,
-                  retention: nil,
-                  unique_key: nil,
-                  unique_while: nil)
-        req = EnqueueRequest.new(
-          queue:,
-          type:,
-          payload: self.class.normalize_payload(payload),
-          priority:,
-          ready_at:,
-          retry_limit:,
-          backoff:,
-          retention:,
-          unique_key:,
-          unique_while:,
-        )
+      def enqueue(
+        queue:,
+        type:,
+        payload:,
+        priority: nil,
+        ready_at: nil,
+        retry_limit: nil,
+        backoff: nil,
+        retention: nil,
+        unique_key: nil,
+        unique_while: nil,
+        batch: nil
+      )
+        req =
+          EnqueueRequest.new(
+            queue:,
+            type:,
+            payload: self.class.normalize_payload(payload),
+            priority:,
+            ready_at:,
+            retry_limit:,
+            backoff:,
+            retention:,
+            unique_key:,
+            unique_while:,
+            batch:
+          )
         @mutex.synchronize { record_unsynchronized(req) }.job
       end
 
@@ -161,18 +167,20 @@ module Zizq
       def enqueue_bulk(jobs:)
         @mutex.synchronize do
           jobs.map do |params|
-            req = EnqueueRequest.new(
-              queue:        params[:queue],
-              type:         params[:type],
-              payload:      self.class.normalize_payload(params[:payload]),
-              priority:     params[:priority],
-              ready_at:     params[:ready_at],
-              retry_limit:  params[:retry_limit],
-              backoff:      params[:backoff],
-              retention:    params[:retention],
-              unique_key:   params[:unique_key],
-              unique_while: params[:unique_while],
-            )
+            req =
+              EnqueueRequest.new(
+                queue: params[:queue],
+                type: params[:type],
+                payload: self.class.normalize_payload(params[:payload]),
+                priority: params[:priority],
+                ready_at: params[:ready_at],
+                retry_limit: params[:retry_limit],
+                backoff: params[:backoff],
+                retention: params[:retention],
+                unique_key: params[:unique_key],
+                unique_while: params[:unique_while],
+                batch: params[:batch]
+              )
             record_unsynchronized(req).job
           end
         end
@@ -202,7 +210,7 @@ module Zizq
           Kernel.raise(
             NotSupported,
             "Zizq::Test::Client##{method_name} is not supported in test mode. " \
-            "Test mode buffers enqueues only — point at a real server, or stub the call."
+              "Test mode buffers enqueues only — point at a real server, or stub the call."
           )
         end
       end
@@ -227,15 +235,20 @@ module Zizq
           "priority" => req.priority,
           "ready_at" => ready_at_ms,
           "retry_limit" => req.retry_limit,
-          "status" => ready_at_ms > now_ms ? STATUS_SCHEDULED : STATUS_READY,
+          "status" => ready_at_ms > now_ms ? STATUS_SCHEDULED : STATUS_READY
         }
-        entry = Entry.new(request: req, job: Resources::Job.new(self, data), data: data)
+        entry =
+          Entry.new(
+            request: req,
+            job: Resources::Job.new(self, data),
+            data: data
+          )
         @entries << entry
         entry
       end
 
       def synthetic_id(counter) #: (Integer) -> String
-        "#{ID_PREFIX}#{counter.to_s.rjust(ID_LENGTH - ID_PREFIX.length, '0')}"
+        "#{ID_PREFIX}#{counter.to_s.rjust(ID_LENGTH - ID_PREFIX.length, "0")}"
       end
 
       public
@@ -267,20 +280,22 @@ module Zizq
       #   truthy to keep. Defaults to `PASS_ALL_FILTER`.
       #
       # `only_*` and `except_*` AND together with the predicate.
-      def apply_filters(entries,
-                        only_queues: nil,
-                        except_queues: nil,
-                        only_types: nil,
-                        except_types: nil,
-                        filter: PASS_ALL_FILTER) #: (Array[Entry], **untyped) -> Array[Entry]
-        only_queues   = normalize_filter(only_queues)
+      def apply_filters(
+        entries,
+        only_queues: nil,
+        except_queues: nil,
+        only_types: nil,
+        except_types: nil,
+        filter: PASS_ALL_FILTER
+      ) #: (Array[Entry], **untyped) -> Array[Entry]
+        only_queues = normalize_filter(only_queues)
         except_queues = normalize_filter(except_queues)
-        only_types    = normalize_filter(only_types)
-        except_types  = normalize_filter(except_types)
+        only_types = normalize_filter(only_types)
+        except_types = normalize_filter(except_types)
 
         entries.select do |entry|
           queue = entry.data["queue"] #: String
-          type  = entry.data["type"]  #: String
+          type = entry.data["type"] #: String
 
           (only_queues.empty? || only_queues.include?(queue)) &&
             (except_queues.empty? || !except_queues.include?(queue)) &&
@@ -313,9 +328,12 @@ module Zizq
 
       def runnable?(entry, now_ms) #: (Entry, Integer) -> bool
         case entry.data["status"]
-        when STATUS_READY     then true
-        when STATUS_SCHEDULED then entry.data["ready_at"] <= now_ms
-        else false
+        when STATUS_READY
+          true
+        when STATUS_SCHEDULED
+          entry.data["ready_at"] <= now_ms
+        else
+          false
         end
       end
 
@@ -323,9 +341,12 @@ module Zizq
       # Strings. Class names match the API's `type` string.
       def normalize_filter(value) #: ((String | Class | Array[String | Class])?) -> Array[String]
         case value
-        when nil then []
-        when Array then value.map { |x| x.to_s }
-        else [value.to_s]
+        when nil
+          []
+        when Array
+          value.map { |x| x.to_s }
+        else
+          [value.to_s]
         end
       end
 
@@ -340,7 +361,7 @@ module Zizq
         begin
           Zizq.configuration.dequeue_middleware.call(entry.job)
           entry.data["status"] = STATUS_COMPLETED
-        rescue
+        rescue StandardError
           entry.data["status"] = STATUS_DEAD
           raise
         end

data/lib/zizq/test.rb

@@ -60,7 +60,7 @@ module Zizq
     def self.client #: () -> Client
       unless Zizq.configuration.test_mode
         raise Client::NotSupported,
-          "Zizq.configuration.test_mode is not enabled; Zizq::Test.client has nothing to manage."
+              "Zizq.configuration.test_mode is not enabled; Zizq::Test.client has nothing to manage."
       end
       Zizq.client #: Client
     end
@@ -141,15 +141,15 @@ module Zizq
 
       unless job_class.respond_to?(:zizq_serialize)
         raise ArgumentError,
-          "#{job_class} doesn't implement zizq_serialize — " \
-          "include Zizq::Job or extend Zizq::ActiveJobConfig, " \
-          "or use Zizq::Test.enqueued_raw? for raw enqueues."
+              "#{job_class} doesn't implement zizq_serialize — " \
+                "include Zizq::Job or extend Zizq::ActiveJobConfig, " \
+                "or use Zizq::Test.enqueued_raw? for raw enqueues."
       end
 
       expected = job_class.zizq_serialize(*args, **kwargs)
-      client.enqueued_jobs(only_types: type).count do |job|
-        payloads_equivalent?(expected, job.payload)
-      end
+      client
+        .enqueued_jobs(only_types: type)
+        .count { |job| payloads_equivalent?(expected, job.payload) }
     end
 
     # Was a raw job (queue + type + payload) enqueued? Each kwarg is
@@ -167,7 +167,7 @@ module Zizq
     def self.enqueued_raw_count(queue: nil, type: nil, payload: nil) #: (?queue: String?, ?type: String?, ?payload: untyped) -> Integer
       filters = {}
       filters[:only_queues] = queue if queue
-      filters[:only_types]  = type  if type
+      filters[:only_types] = type if type
       unless payload.nil?
         # Normalize the assertion-side payload the same way enqueue
         # normalizes the buffered one, so symbol-keyed test payloads

data/lib/zizq/tls_configuration.rb

@@ -18,10 +18,11 @@ module Zizq
   # All values may be PEM-encoded strings or file paths.
   #
   # Note: Mutual TLS support requires a Zizq Pro license on the server.
-  TlsConfiguration = Struct.new(
-    :ca,          #: String?
-    :client_cert, #: String?
-    :client_key,  #: String?
-    keyword_init: true
-  )
+  TlsConfiguration =
+    Struct.new(
+      :ca, #: String?
+      :client_cert, #: String?
+      :client_key, #: String?
+      keyword_init: true
+    )
 end

data/lib/zizq/version.rb

@@ -5,5 +5,5 @@
 # frozen_string_literal: true
 
 module Zizq
-  VERSION = "0.5.0" #: String
+  VERSION = "0.6.0" #: String
 end