job-iteration 1.13.1 → 1.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8e5e3fa1240a67b88f2b83290f7b01fcadb28b4a7be257f646d199cff9c2e97
-  data.tar.gz: 6a2130de073c8c5eb29c13934f7e4bb73af31cf15fc33af74b5738b420a9b38b
+  metadata.gz: dbb861f47602c89b8163b0f36f662c8b1f10c34528c0d06b0ce74918973e89db
+  data.tar.gz: b00adea778b0a722dc727fdd4a9954c60442df995ee273ec82ff9d85b9fa222f
 SHA512:
-  metadata.gz: b6316aa38f0e6f7df7874a478253b6e285db61c6077089c43ef1edfce408ec1835cdd7d50d4ccf257e096677cc4fcdb23e67cc609efc48998ae91a0667a8974a
-  data.tar.gz: ac9fdbf6afeb440010323c70aa1fcdf60288460788893b0a0dbc536684caeca3291a0e90c80142439c7aac4efbf4853039b482ae37078d2b2c69ab2d565680be
+  metadata.gz: 1d085184d274fcc7315277c0e11e45093674e96a152d6bf49eff6644be23974df17f6d778e0abf0d1289ac2203af8ea59a9c7a7d9aeedd46de26b6ed16649d86
+  data.tar.gz: 50fea852189c3f13f4b0c84f465f532e4b27804d5d71238f044fa0f6beec67c8372c83561b0690e1605eb09c47a3f07cfad24a417a3dd612a4b57bfda840696d

data/CHANGELOG.md

@@ -16,6 +16,28 @@ nil
 
 nil
 
+## v1.15.0 (Jun 4, 2026)
+
+### Features
+
+- [715](https://github.com/Shopify/job-iteration/pull/715) - Add support for keyword arguments in `build_enumerator` and `each_iteration` while preserving positional params Hash compatibility for existing jobs. This compatibility path is transitional; migrate jobs away from positional params Hash signatures paired with `perform_later(keyword: value)`.
+
+## v1.14.0 (May 14, 2026)
+
+### Breaking Changes
+
+- [704](https://github.com/Shopify/job-iteration/pull/704) - Drop support for Rails 7.0. The minimum supported Rails version is now 7.1.
+
+### Features
+
+- [702](https://github.com/Shopify/job-iteration/pull/702) - Add support for parallel iteration with `enumerator_builder.parallel`. This enqueues multiple jobs, allowing you to split up the work across multiple instances.
+- [705](https://github.com/Shopify/job-iteration/pull/705) - Add support for parallel array iteration with `enumerator_builder.parallel_array`.
+- [706](https://github.com/Shopify/job-iteration/pull/706) - Add support for parallel Active Record relation iteration with `enumerator_builder.parallel_active_record_on_records` and `enumerator_builder.parallel_active_record_on_batches`.
+
+### Bug fixes
+
+- [709](https://github.com/Shopify/job-iteration/pull/709) - Fix an issue with parallel iteration when `instances` changed after child jobs were enqueued.
+
 ## v1.13.1 (Apr 28, 2026)
 
 ### Bug fixes

data/README.md

@@ -101,6 +101,21 @@ class BatchesAsRelationJob < ApplicationJob
 end
 ```
 
+```ruby
+class ParallelIterationJob < ApplicationJob
+  include JobIteration::Iteration
+  
+  def build_enumerator(cursor:)
+    enumerator_builder.parallel_active_record_on_records(User.all, instances: 5, cursor: cursor)
+  end
+
+  # Runs in 5 separate jobs, with each job processing a subset of the users
+  def each_iteration(user)
+    user.notify_about_something
+  end
+end
+```
+
 ```ruby
 class ArrayJob < ApplicationJob
   include JobIteration::Iteration
@@ -167,7 +182,7 @@ Job-iteration currently supports the following queue adapters (in order of imple
 It supports the following platforms:
 
 - Ruby 3.1 and later
-- Rails 7.0 and later
+- Rails 7.1 and later
 
 Support for older platforms that have reached end of life may occasionally be dropped if maintaining backwards compatibility is cumbersome.
 
@@ -178,20 +193,21 @@ Support for older platforms that have reached end of life may occasionally be dr
 * [Best practices](guides/best-practices.md)
 * [Writing custom enumerator](guides/custom-enumerator.md)
 * [Throttling](guides/throttling.md)
+* [Parallel iteration](guides/parallel-iteration.md)
 
 For more detailed documentation, see [rubydoc](https://www.rubydoc.info/gems/job-iteration).
 
 ## Requirements
 
-ActiveJob is the primary requirement for Iteration. While there's nothing that prevents it, Iteration is not yet compatible with [vanilla](https://github.com/mperham/sidekiq/wiki/Active-Job) Sidekiq API.
+Active Job is the primary requirement for Iteration. For iteration without Active Job in Sidekiq, see [Sidekiq Iteration](https://github.com/sidekiq/sidekiq/wiki/Iteration).
 
 ### API
 
-Iteration job must respond to `build_enumerator` and `each_iteration` methods. `build_enumerator` must return [Enumerator](http://ruby-doc.org/core-2.5.1/Enumerator.html) object that respects the `cursor` value.
+Iteration job must respond to `build_enumerator` and `each_iteration` methods. `build_enumerator` must return an [Enumerator](http://ruby-doc.org/core-2.5.1/Enumerator.html) object that respects the `cursor` value.
 
 ### Sidekiq adapter
 
-Unless you are running on Heroku, we recommend you to tune Sidekiq's [timeout](https://github.com/mperham/sidekiq/wiki/Deployment#overview) option from the default 8 seconds to 25-30 seconds, to allow the last `each_iteration` to complete and gracefully shutdown.
+Running iterating jobs on Sidekiq should work with the default configuration. The most important setting is Sidekiq's [timeout](https://github.com/mperham/sidekiq/wiki/Deployment#overview) option, which defaults to 25 seconds. That allows the last `each_iteration` to complete and gracefully shutdown.
 
 ### Resque adapter
 
@@ -203,11 +219,11 @@ There a few configuration assumptions that are required for Iteration to work wi
 
 **What happens when my job is interrupted?** A checkpoint will be persisted to Redis after the current `each_iteration`, and the job will be re-enqueued. Once it's popped off the queue, the worker will work off from the next iteration.
 
-**What happens with retries?** An interruption of a job does not count as a retry. If an exception occurs, the job will retry or be discarded as normal using Active Job configuration for the job. If the job retries, it processes the iteration that originally failed and progress will continue from there on if successful.
+**What happens with retries?** An interruption of a job does not count as a retry. If an exception occurs, the job will retry or be discarded as normal using Active Job configuration for the job. If the job retries, it re-processes the iteration that originally failed and progress will continue from there on if successful.
 
 **What happens if my iteration takes a long time?** We recommend that a single `each_iteration` should take no longer than 30 seconds. In the future, this may raise an exception.
 
-**Why is it important that `each_iteration` takes less than 30 seconds?** When the job worker is scheduled for restart or shutdown, it gets a notice to finish remaining unit of work. To guarantee that no progress is lost we need to make sure that `each_iteration` completes within a reasonable amount of time.
+**Why is it important that `each_iteration` runs quickly?** When the job worker is scheduled for restart or shutdown, it gets a notice to finish remaining unit of work. To guarantee that no progress is lost we need to make sure that `each_iteration` completes within a reasonable amount of time. The exact timeout depends on your queue adapter configuration.
 
 **Why do I use have to use this ugly helper in `build_enumerator`? Why can't you automatically infer it?** This is how the first version of the API worked. We checked the type of object returned by `build_enumerable`, and whether it was ActiveRecord Relation or an Array, we used the matching adapter. This caused opaque type branching in Iteration internals and it didn’t allow developers to craft their own Enumerators and control the cursor value. We made a decision to _always_ return Enumerator instance from `build_enumerator`. Now we provide explicit helpers to convert ActiveRecord Relation or an Array to Enumerator, and for more complex iteration flows developers can build their own `Enumerator` objects.
 

data/job-iteration.gemspec

@@ -26,5 +26,5 @@ Gem::Specification.new do |spec|
   spec.metadata["changelog_uri"] = "https://github.com/Shopify/job-iteration/blob/main/CHANGELOG.md"
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
-  spec.add_dependency("activejob", ">= 7.0")
+  spec.add_dependency("activejob", ">= 7.1")
 end

data/lib/job-iteration/active_record_batch_enumerator.rb

@@ -66,10 +66,6 @@ module JobIteration
       pkey = @column_mgr.primary_key
       pkey_values = primary_key_values
 
-      # If the primary key is only composed of a single column, simplify the
-      # query. This keeps us compatible with Rails prior to 7.1 where composite
-      # primary keys were introduced along with the syntax that allows you to
-      # query for multi-column values.
       if pkey.size <= 1
         pkey = pkey.first
         pkey_values = pkey_values.map(&:first)

data/lib/job-iteration/active_record_cursor.rb

@@ -18,7 +18,7 @@ module JobIteration
       end
     end
 
-    def initialize(relation, columns = nil, position = nil)
+    def initialize(relation, columns, position, instance, instances)
       @columns = if columns
         Array(columns)
       else
@@ -35,6 +35,17 @@ module JobIteration
       end
 
       @base_relation = relation.reorder(@columns.join(","))
+
+      if instances.present?
+        pk = relation.primary_key
+        unless pk.is_a?(String) && relation.klass.column_for_attribute(pk).type == :integer
+          raise ArgumentError, "Parallel iteration requires a single integer primary key. " \
+            "For more complex cases, use the enumerator_builder.parallel primitive directly."
+        end
+
+        @base_relation = @base_relation.where("#{relation.table_name}.#{pk} % ? = ?", instances, instance)
+      end
+
       @reached_end = false
     end
 
@@ -56,7 +67,7 @@ module JobIteration
       self.position = @columns.map do |column|
         method = column.to_s.split(".").last
 
-        if ActiveRecord.version >= Gem::Version.new("7.1.0.alpha") && method == "id"
+        if method == "id"
           record.id_value
         else
           record.send(method.to_sym)

data/lib/job-iteration/active_record_enumerator.rb

@@ -7,7 +7,7 @@ module JobIteration
   class ActiveRecordEnumerator
     SQL_DATETIME_WITH_NSEC = "%Y-%m-%d %H:%M:%S.%N"
 
-    def initialize(relation, columns: nil, batch_size: 100, timezone: nil, cursor: nil)
+    def initialize(relation, columns: nil, batch_size: 100, timezone: nil, cursor: nil, instance: nil, instances: nil)
       @relation = relation
       @batch_size = batch_size
       @timezone = timezone
@@ -17,6 +17,8 @@ module JobIteration
         Array(relation.primary_key).map { |pk| "#{relation.table_name}.#{pk}" }
       end
       @cursor = cursor
+      @instance = instance
+      @instances = instances
     end
 
     def records
@@ -39,7 +41,8 @@ module JobIteration
     end
 
     def size
-      @relation.count(:all)
+      full_size = @relation.count(:all)
+      @instances.present? ? full_size / @instances : full_size
     end
 
     private
@@ -61,7 +64,7 @@ module JobIteration
     end
 
     def finder_cursor
-      JobIteration::ActiveRecordCursor.new(@relation, @columns, @cursor)
+      JobIteration::ActiveRecordCursor.new(@relation, @columns, @cursor, @instance, @instances)
     end
 
     def column_value(record, attribute)

data/lib/job-iteration/enumerator_builder.rb

@@ -5,6 +5,7 @@ require_relative "active_record_enumerator"
 require_relative "csv_enumerator"
 require_relative "throttle_enumerator"
 require_relative "nested_enumerator"
+require_relative "parallel_enumerator"
 require "forwardable"
 
 module JobIteration
@@ -65,6 +66,23 @@ module JobIteration
       wrap(self, enumerable.each_with_index.drop(drop).to_enum { enumerable.size - drop })
     end
 
+    # Builds an Enumerator that iterates over a given array, across +instances+ parallel jobs.
+    #
+    # Child job i iterates over the slice of the array starting at
+    # index (array.size / instances * i).floor and ending at index (array.size / instances * (i + 1)).floor - 1.
+    def build_parallel_array_enumerator(array, instances:, cursor:)
+      unless array.is_a?(Array)
+        raise ArgumentError, "array must be an Array"
+      end
+
+      build_parallel_enumerator(instances: instances, cursor: cursor) do |instance, instances, inner_cursor|
+        slice_start = (array.size.to_f / instances * instance).floor
+        next_slice_start = (array.size.to_f / instances * (instance + 1)).floor
+        slice = array[slice_start...next_slice_start]
+        build_array_enumerator(slice, cursor: inner_cursor)
+      end
+    end
+
     # Builds Enumerator from Active Record Relation. Each Enumerator tick moves the cursor one row forward.
     #
     # +columns:+ argument is used to build the actual query for iteration. +columns+: defaults to primary key:
@@ -103,6 +121,21 @@ module JobIteration
       wrap(self, enum)
     end
 
+    # Builds an Enumerator that iterates over a given Active Record Relation, across +instances+ parallel jobs.
+    #
+    # Child job i iterates over the records where the id is equal to (instance % instances).
+    def build_parallel_active_record_enumerator_on_records(scope, instances:, cursor:, **args)
+      build_parallel_enumerator(instances: instances, cursor: cursor) do |instance, instances, inner_cursor|
+        build_active_record_enumerator(
+          scope,
+          cursor: inner_cursor,
+          instances: instances,
+          instance: instance,
+          **args,
+        ).records
+      end
+    end
+
     # Builds Enumerator from Active Record Relation and enumerates on batches of records.
     # Each Enumerator tick moves the cursor +batch_size+ rows forward.
     #
@@ -118,6 +151,21 @@ module JobIteration
       wrap(self, enum)
     end
 
+    # Builds an Enumerator that iterates over a given Active Record Relation, across +instances+ parallel jobs, and enumerates on batches.
+    #
+    # Child job i iterates over the batches of records where the id is equal to (instance % instances).
+    def build_parallel_active_record_enumerator_on_batches(scope, instances:, cursor:, **args)
+      build_parallel_enumerator(instances: instances, cursor: cursor) do |instance, instances, inner_cursor|
+        build_active_record_enumerator(
+          scope,
+          cursor: inner_cursor,
+          instances: instances,
+          instance: instance,
+          **args,
+        ).batches
+      end
+    end
+
     # Builds Enumerator from Active Record Relation and enumerates on batches, yielding Active Record Relations.
     # See documentation for #build_active_record_enumerator_on_batches.
     def build_active_record_enumerator_on_batch_relations(scope, wrap: true, cursor:, **args)
@@ -185,27 +233,48 @@ module JobIteration
       wrap(self, enum)
     end
 
+    def build_parallel_enumerator(instances:, cursor:, &block)
+      unless instances.is_a?(Integer) && instances.positive?
+        raise ArgumentError, "instances must be a positive Integer"
+      end
+
+      return ParallelEnumerator::EnqueueJobs.new(instances) if cursor.nil?
+
+      enum = ParallelEnumerator.new(block, cursor: cursor).to_enum
+      wrap(self, enum)
+    end
+
     alias_method :once, :build_once_enumerator
     alias_method :times, :build_times_enumerator
     alias_method :array, :build_array_enumerator
+    alias_method :parallel_array, :build_parallel_array_enumerator
     alias_method :active_record_on_records, :build_active_record_enumerator_on_records
+    alias_method :parallel_active_record_on_records, :build_parallel_active_record_enumerator_on_records
     alias_method :active_record_on_batches, :build_active_record_enumerator_on_batches
+    alias_method :parallel_active_record_on_batches, :build_parallel_active_record_enumerator_on_batches
     alias_method :active_record_on_batch_relations, :build_active_record_enumerator_on_batch_relations
     alias_method :throttle, :build_throttle_enumerator
     alias_method :csv, :build_csv_enumerator
     alias_method :csv_on_batches, :build_csv_enumerator_on_batches
     alias_method :nested, :build_nested_enumerator
+    alias_method :parallel, :build_parallel_enumerator
 
     private
 
-    def build_active_record_enumerator(scope, cursor:, **args)
+    def build_active_record_enumerator(scope, cursor:, instance: nil, instances: nil, **args)
       unless scope.is_a?(ActiveRecord::Relation)
         raise ArgumentError, "scope must be an ActiveRecord::Relation"
       end
 
+      if (instance.nil? && instances.present?) || (instance.present? && instances.nil?)
+        raise ArgumentError, "instance and instances must both be provided or both be nil"
+      end
+
       JobIteration::ActiveRecordEnumerator.new(
         scope,
         cursor: cursor,
+        instance: instance,
+        instances: instances,
         **args,
       )
     end

data/lib/job-iteration/iteration.rb

@@ -107,8 +107,8 @@ module JobIteration
       self.total_time = Float(job_data["total_time"] || 0.0)
     end
 
-    def perform(*params) # @private
-      interruptible_perform(*params)
+    def perform(...) # @private
+      interruptible_perform(...)
 
       nil
     end
@@ -128,12 +128,12 @@ module JobIteration
       JobIteration.enumerator_builder.new(self)
     end
 
-    def interruptible_perform(*arguments)
+    def interruptible_perform(*args, **kwargs)
       self.start_time = Time.now.utc
 
       enumerator = nil
       ActiveSupport::Notifications.instrument("build_enumerator.iteration", instrumentation_tags) do
-        enumerator = build_enumerator(*arguments, cursor: cursor_position)
+        enumerator = call_job_iteration_build_enumerator(args, kwargs)
       end
 
       unless enumerator
@@ -141,6 +141,14 @@ module JobIteration
         return
       end
 
+      if enumerator.is_a?(ParallelEnumerator::EnqueueJobs)
+        tags = instrumentation_tags.merge(instances: enumerator.instances)
+        ActiveSupport::Notifications.instrument("enqueue_parallel_jobs.iteration", tags) do
+          enumerator.enqueue_jobs(self)
+        end
+        return
+      end
+
       assert_enumerator!(enumerator)
 
       if executions == 1 && times_interrupted == 0
@@ -153,7 +161,7 @@ module JobIteration
       end
 
       completed = catch(:abort) do
-        iterate_with_enumerator(enumerator, arguments)
+        iterate_with_enumerator(enumerator, args, kwargs)
       end
 
       run_callbacks(:shutdown)
@@ -170,8 +178,7 @@ module JobIteration
       end
     end
 
-    def iterate_with_enumerator(enumerator, arguments)
-      arguments = arguments.dup.freeze
+    def iterate_with_enumerator(enumerator, args, kwargs)
       found_record = false
       @needs_reenqueue = false
 
@@ -183,7 +190,7 @@ module JobIteration
         ActiveSupport::Notifications.instrument("each_iteration.iteration", tags) do
           found_record = true
           run_callbacks(:iterate) do
-            each_iteration(object_from_enumerator, *arguments)
+            call_job_iteration_each_iteration(object_from_enumerator, args, kwargs)
           end
           self.cursor_position = cursor_from_enumerator
         end
@@ -207,6 +214,64 @@ module JobIteration
       adjust_total_time
     end
 
+    def call_job_iteration_build_enumerator(args, kwargs)
+      positional_args, keyword_args = normalize_job_iteration_arguments(args, kwargs, :build_enumerator)
+
+      if keyword_args&.key?(:cursor)
+        raise ArgumentError, "The keyword argument `cursor` is reserved for the job iteration framework. " \
+          "Please remove `cursor` from the arguments passed to the job or rename it"
+      end
+
+      # `keyword_args || {}` because splatting `nil` raises on Ruby < 3.4; it only
+      # became a no-op in 3.4 (https://bugs.ruby-lang.org/issues/20064).
+      build_enumerator(*positional_args, **(keyword_args || {}), cursor: cursor_position)
+    end
+
+    def call_job_iteration_each_iteration(object_from_enumerator, args, kwargs)
+      positional_args, keyword_args = normalize_job_iteration_arguments(args, kwargs, :each_iteration)
+      # `keyword_args || {}` because splatting `nil` raises on Ruby < 3.4; it only
+      # became a no-op in 3.4 (https://bugs.ruby-lang.org/issues/20064).
+      each_iteration(object_from_enumerator, *positional_args, **(keyword_args || {}))
+    end
+
+    # Normalize Active Job kwargs for job-iteration dispatch. If the target method
+    # accepts job keyword parameters other than build_enumerator's reserved cursor:,
+    # keep kwargs separate so they can be splatted. Otherwise, append kwargs as a
+    # positional params Hash for transitional compatibility with existing jobs
+    # enqueued with keyword syntax.
+    #: (Array[top], Hash[Symbol, top], Symbol) -> [Array[top], Hash[Symbol, top]?]
+    def normalize_job_iteration_arguments(args, kwargs, method_name)
+      if kwargs.empty?
+        [args.dup.freeze, nil]
+      elsif job_has_keyword_parameters?(method_name)
+        [args.dup.freeze, kwargs.dup.freeze]
+      else
+        params_hash_args = args + [kwargs]
+        [params_hash_args.dup.freeze, nil]
+      end
+    end
+
+    #: (Symbol) -> bool
+    def job_has_keyword_parameters?(method_name)
+      @job_has_keyword_parameters ||= {}
+      return @job_has_keyword_parameters[method_name] if @job_has_keyword_parameters.key?(method_name)
+
+      @job_has_keyword_parameters[method_name] = method_parameters(method_name).any? do |type, name|
+        job_keyword_argument?(method_name, type, name)
+      end
+    end
+
+    def job_keyword_argument?(method_name, type, name)
+      # Match keyword parameters: double-splat (**kwargs), required (key:) or optional (key: default).
+      return false unless type == :keyrest || type == :keyreq || type == :key
+
+      # Ignore the `cursor:` argument, which is part of the `job-iteration`
+      # framework, and not a argument in the job's serialized argument list.
+      return false if method_name == :build_enumerator && name == :cursor
+
+      true
+    end
+
     def reenqueue_iteration_job
       ActiveSupport::Notifications.instrument(
         "interrupted.iteration",

data/lib/job-iteration/log_subscriber.rb

@@ -19,6 +19,12 @@ module JobIteration
       end
     end
 
+    def enqueue_parallel_jobs(event)
+      info do
+        "[JobIteration::Iteration] Enqueued #{event.payload[:instances]} parallel jobs."
+      end
+    end
+
     def interrupted(event)
       info do
         "[JobIteration::Iteration] Interrupting and re-enqueueing the job " \

data/lib/job-iteration/parallel_enumerator.rb

@@ -0,0 +1,52 @@
+# typed: true
+# frozen_string_literal: true
+
+module JobIteration
+  # ParallelEnumerator allows you to parallelize iterations.
+  class ParallelEnumerator
+    class EnqueueError < StandardError; end
+
+    class EnqueueJobs
+      def initialize(instances)
+        @instances = instances
+      end
+
+      attr_reader :instances
+
+      def enqueue_jobs(job)
+        child_jobs = instances.times.map do |index|
+          job.class.new(*job.arguments).tap do |child_job|
+            child_job.cursor_position = { "instance" => index, "instances" => instances, "inner_cursor" => nil }
+
+            # Carry forward potential overrides from the parent job
+            child_job.queue_name = job.queue_name
+            child_job.priority = job.priority if job.priority
+          end
+        end
+
+        ActiveJob.perform_all_later(child_jobs)
+
+        unless child_jobs.all?(&:successfully_enqueued?)
+          failed_count = instances - child_jobs.count(&:successfully_enqueued?)
+          raise EnqueueError, "Failed to enqueue #{failed_count} out of #{instances} child jobs"
+        end
+      end
+    end
+
+    def initialize(block, cursor:)
+      @instance = cursor["instance"]
+      @instances = cursor["instances"]
+      inner_cursor = cursor["inner_cursor"]
+      @inner_enum = block.call(@instance, @instances, inner_cursor)
+    end
+
+    def to_enum
+      Enumerator.new(-> { @inner_enum.size }) do |yielder|
+        @inner_enum.each do |object_from_enumerator, cursor_from_enumerator|
+          parallel_cursor = { "instance" => @instance, "instances" => @instances, "inner_cursor" => cursor_from_enumerator }
+          yielder.yield(object_from_enumerator, parallel_cursor)
+        end
+      end
+    end
+  end
+end

data/lib/job-iteration/railtie.rb

@@ -5,8 +5,7 @@ return unless defined?(Rails::Railtie)
 module JobIteration
   class Railtie < Rails::Railtie
     initializer "job_iteration.register_deprecator" do |app|
-      # app.deprecators was added in Rails 7.1
-      app.deprecators[:job_iteration] = JobIteration::Deprecation if app.respond_to?(:deprecators)
+      app.deprecators[:job_iteration] = JobIteration::Deprecation
     end
   end
 end

data/lib/job-iteration/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JobIteration
-  VERSION = "1.13.1"
+  VERSION = "1.15.0"
 end

data/lib/tapioca/dsl/compilers/job_iteration.rb

@@ -105,15 +105,11 @@ module Tapioca
           ).returns(T::Array[RBI::TypedParam])
         end
         def perform_later_parameters(parameters, returned_job_class)
-          if ::Gem::Requirement.new(">= 7.0").satisfied_by?(::ActiveJob.gem_version)
-            parameters.reject! { |typed_param| RBI::BlockParam === typed_param.param }
-            parameters + [create_block_param(
-              "block",
-              type: "T.nilable(T.proc.params(job: #{returned_job_class}).void)",
-            )]
-          else
-            parameters
-          end
+          parameters.reject! { |typed_param| RBI::BlockParam === typed_param.param }
+          parameters + [create_block_param(
+            "block",
+            type: "T.nilable(T.proc.params(job: #{returned_job_class}).void)",
+          )]
         end
 
         class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: job-iteration
 version: !ruby/object:Gem::Version
-  version: 1.13.1
+  version: 1.15.0
 platform: ruby
 authors:
 - Shopify
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
 description: Makes your background jobs interruptible and resumable.
 email:
 - ops-accounts+shipit@shopify.com
@@ -52,6 +52,7 @@ files:
 - lib/job-iteration/iteration.rb
 - lib/job-iteration/log_subscriber.rb
 - lib/job-iteration/nested_enumerator.rb
+- lib/job-iteration/parallel_enumerator.rb
 - lib/job-iteration/railtie.rb
 - lib/job-iteration/test_helper.rb
 - lib/job-iteration/throttle_enumerator.rb
@@ -77,7 +78,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.12
 specification_version: 4
 summary: Makes your background jobs interruptible and resumable.
 test_files: []