chewy 8.0.1 → 8.3.0

data/lib/chewy/index/import/progressbar.rb

@@ -0,0 +1,79 @@
+module Chewy
+  class Index
+    module Import
+      # Thin wrapper around `ruby-progressbar` for import feedback.
+      #
+      # Unlike the original PR #787 implementation, this wrapper is only
+      # touched from the parent process: serial imports increment it directly,
+      # and parallel imports increment it via `Parallel`'s `finish:` callback
+      # (which runs in the parent under an internal mutex). The workers stay
+      # process-based, so there is no GVL contention as in PR #787 / #800.
+      #
+      # `Progressbar.build` returns a NULL object when the feature is disabled,
+      # so call sites do not need feature guards.
+      class Progressbar
+        NULL = Object.new
+        class << NULL
+          def increment(_); end
+          def total=(_); end
+          def finish; end
+        end
+
+        BOUNDED_FORMAT = '%t |%B| %p%% %c/%C %e'.freeze
+        UNBOUNDED_FORMAT = '%t %c (%a)'.freeze
+        TITLE = 'Importing'.freeze
+
+        # @param enabled [Boolean, :unbounded] feature flag. `:unbounded` shows
+        #   a spinner with no total (skip `import_count`).
+        # @param total [Integer, nil] expected total; ignored when `:unbounded`.
+        # @return [Progressbar, NULL]
+        def self.build(enabled, total)
+          return NULL unless enabled
+
+          unless '::ProgressBar'.safe_constantize
+            raise 'The `ruby-progressbar` gem is required for import progress, ' \
+                  "please add `gem 'ruby-progressbar'` to your Gemfile"
+          end
+
+          return new if enabled == :unbounded
+
+          new(normalize_total(total))
+        end
+
+        # Some ActiveRecord scopes (e.g., `.group(...)`) make `.count` return a
+        # Hash rather than an Integer. Coerce so we still get a usable total.
+        def self.normalize_total(total)
+          case total
+          when Hash then total.values.sum
+          when Integer then total
+          end
+        end
+
+        attr_reader :bar
+
+        def initialize(total = nil)
+          format = total ? BOUNDED_FORMAT : UNBOUNDED_FORMAT
+          @bar = ::ProgressBar.create(title: TITLE, total: total, format: format)
+        end
+
+        # Clamps to total when bounded — action_objects may include :delete
+        # entries (parent-child re-indexing, delete_if scope) that aren't
+        # counted by `adapter.import_count`, which would otherwise raise
+        # ProgressBar::InvalidProgressError.
+        def increment(by)
+          target = bar.progress + by
+          target = [bar.total, target].min if bar.total
+          bar.progress = target
+        end
+
+        def total=(value)
+          bar.total = value
+        end
+
+        def finish
+          bar.finish unless bar.finished?
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/import/routine.rb

@@ -31,7 +31,7 @@ module Chewy
 
         DEFAULT_OPTIONS = {
           refresh: true,
-          update_fields: [],
+          update_fields: nil,
           update_failover: true,
           batch_size: Chewy::Index::Adapter::Base::BATCH_SIZE
         }.freeze
@@ -56,6 +56,7 @@ module Chewy
               {}
             end
           end
+          @context = @options[:context] || {}
           @errors = []
           @stats = {}
           @leftovers = []
@@ -78,7 +79,7 @@ module Chewy
         # @param delete [Array<Object>] any acceptable objects for deleting
         # @return [true, false] the result of the request, true if no errors
         def process(index: [], delete: [])
-          bulk_builder = BulkBuilder.new(@index, to_index: index, delete: delete, fields: @options[:update_fields])
+          bulk_builder = BulkBuilder.new(@index, to_index: index, delete: delete, fields: @options[:update_fields], context: @context)
           bulk_body = bulk_builder.bulk_body
 
           if @options[:journal]

data/lib/chewy/index/import.rb

@@ -2,6 +2,7 @@ require 'chewy/index/import/journal_builder'
 require 'chewy/index/import/bulk_builder'
 require 'chewy/index/import/bulk_request'
 require 'chewy/index/import/routine'
+require 'chewy/index/import/progressbar'
 
 module Chewy
   class Index
@@ -11,20 +12,22 @@ module Chewy
       IMPORT_WORKER = lambda do |index, options, total, ids, iteration|
         ::Process.setproctitle("chewy [#{index}]: import data (#{iteration + 1}/#{total})")
         routine = Routine.new(index, **options)
+        processed = 0
         index.adapter.import(*ids, routine.options) do |action_objects|
           routine.process(**action_objects)
+          processed += action_objects.sum { |_, v| v.size }
         end
-        {errors: routine.errors, import: routine.stats, leftovers: routine.leftovers}
+        {errors: routine.errors, import: routine.stats, leftovers: routine.leftovers, processed: processed}
       end
 
       LEFTOVERS_WORKER = lambda do |index, options, total, body, iteration|
         ::Process.setproctitle("chewy [#{index}]: import leftovers (#{iteration + 1}/#{total})")
         routine = Routine.new(index, **options)
         routine.perform_bulk(body)
-        routine.errors
+        {errors: routine.errors}
       end
 
-      module ClassMethods
+      module ClassMethods # rubocop:disable Metrics/ModuleLength
         # @!method import(*collection, **options)
         # Basically, one of the main methods for an index. Performs any objects import
         # to the index. Does all the objects handling routines.
@@ -68,9 +71,15 @@ module Chewy
         # @option options [Integer] batch_size passed to the adapter import method, used to split imported objects in chunks, 1000 by default
         # @option options [Boolean] direct_import skips object reloading in ORM adapter, `false` by default
         # @option options [true, false] journal enables imported objects journaling, false by default
-        # @option options [Array<Symbol, String>] update_fields list of fields for the partial import, empty by default
+        # @option options [Array<Symbol, String>] update_fields list of fields for partial import. `nil` (default) triggers full document reindex;
+        #   an empty array (`[]`) is an explicit no-op (no fields updated).
         # @option options [true, false] update_failover enables full objects reimport in cases of partial update errors, `true` by default
         # @option options [true, Integer, Hash] parallel enables parallel import processing with the Parallel gem, accepts the number of workers or any Parallel gem acceptable options
+        # @option options [true, false, :unbounded] progressbar shows an import progressbar
+        #   on stderr. `true` precomputes the total via `adapter.import_count` (one extra
+        #   count query); `:unbounded` shows a spinner without computing the total. Default
+        #   `false`. Safe in parallel mode: the bar is incremented in the parent process via
+        #   `Parallel`'s `finish:` callback, workers stay process-based.
         # @return [true, false] false in case of errors
         def import(*args)
           intercept_import_using_strategy(*args).blank?
@@ -115,13 +124,26 @@ module Chewy
         # @param crutches [Object] optional crutches object; if omitted - a crutch for the single passed object is created as a fallback
         # @param fields [Array<Symbol>] and array of fields to restrict the generated document
         # @return [Hash] a JSON-ready hash
-        def compose(object, crutches = nil, fields: [])
-          crutches ||= Chewy::Index::Crutch::Crutches.new self, [object]
+        def compose(object, crutches = nil, fields: [], context: {})
+          crutches ||= Chewy::Index::Crutch::Crutches.new self, [object], context
 
-          if witchcraft? && root.children.present?
-            cauldron(fields: fields).brew(object, crutches)
+          # Hot path: the default-fields compiled method has already
+          # been built, so skip the per-call availability check and
+          # dispatch directly. Bulk reindexing hits this branch for
+          # every object after the first.
+          return __chewy_compose__(object, crutches, context) if fields.empty? && @compiled_default_ready
+
+          if compiled_compose_available?(fields)
+            if fields.empty?
+              @compiled_default_ready = true
+              __chewy_compose__(object, crutches, context)
+            else
+              compiled_compose(object, crutches, context, fields)
+            end
+          elsif witchcraft? && root.children.present?
+            cauldron(fields: fields).brew(object, crutches, context)
           else
-            root.compose(object, crutches, fields: fields)
+            root.compose(object, crutches, fields: fields, context: context)
           end
         end
 
@@ -175,46 +197,91 @@ module Chewy
         end
 
         def import_linear(objects, routine)
+          bar = build_progressbar(routine, objects)
           ActiveSupport::Notifications.instrument 'import_objects.chewy', index: self do |payload|
             adapter.import(*objects, routine.options) do |action_objects|
               routine.process(**action_objects)
+              bar.increment(action_objects.sum { |_, v| v.size })
             end
             routine.perform_bulk(routine.leftovers)
             payload[:import] = routine.stats
             payload[:errors] = payload_errors(routine.errors) if routine.errors.present?
             payload[:errors]
           end
+        ensure
+          bar&.finish
         end
 
         def import_parallel(objects, routine)
           raise "The `parallel` gem is required for parallel import, please add `gem 'parallel'` to your Gemfile" unless '::Parallel'.safe_constantize
 
+          bar = build_progressbar(routine, objects)
           ActiveSupport::Notifications.instrument 'import_objects.chewy', index: self do |payload|
             batches = adapter.import_references(*objects, routine.options.slice(:batch_size)).to_a
 
             ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
             results = ::Parallel.map_with_index(
               batches,
-              routine.parallel_options,
+              parallel_options_with_progress(routine.parallel_options, bar),
               &IMPORT_WORKER.curry[self, routine.options, batches.size]
             )
             ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
             errors, import, leftovers = process_parallel_import_results(results)
-
-            if leftovers.present?
-              batches = leftovers.each_slice(routine.options[:batch_size])
-              results = ::Parallel.map_with_index(
-                batches,
-                routine.parallel_options,
-                &LEFTOVERS_WORKER.curry[self, routine.options, batches.size]
-              )
-              errors.concat(results.flatten(1))
-            end
+            errors.concat(process_parallel_leftovers(leftovers, routine)) if leftovers.present?
 
             payload[:import] = import
             payload[:errors] = payload_errors(errors) if errors.present?
             payload[:errors]
           end
+        ensure
+          bar&.finish
+        end
+
+        def process_parallel_leftovers(leftovers, routine)
+          batches = leftovers.each_slice(routine.options[:batch_size]).to_a
+          results = ::Parallel.map_with_index(
+            batches,
+            routine.parallel_options,
+            &LEFTOVERS_WORKER.curry[self, routine.options, batches.size]
+          )
+          results.flat_map { |r| r[:errors] }
+        end
+
+        # Builds Parallel options with a `finish:` callback that increments the
+        # progressbar after each worker batch returns. The callback runs in the
+        # parent (main) thread under Parallel's internal mutex (parallel-1.x),
+        # so workers stay process-based and there is no worker-side
+        # synchronization — the regression that triggered the PR #800 revert.
+        #
+        # If the caller already supplied a `finish:` callback in
+        # `parallel_options`, both run; user callback first, then the bar.
+        def parallel_options_with_progress(parallel_options, bar)
+          user_finish = parallel_options[:finish]
+          progress = lambda do |item, i, result|
+            user_finish&.call(item, i, result)
+            bar.increment(result[:processed]) if result.is_a?(Hash) && result[:processed]
+          end
+          parallel_options.merge(finish: progress)
+        end
+
+        def build_progressbar(routine, objects)
+          enabled = routine.options[:progressbar]
+          total = enabled == true ? safe_import_count(objects) : nil
+          Progressbar.build(enabled, total)
+        end
+
+        # Returns nil when the adapter cannot or should not be counted:
+        # missing `import_count` on a custom adapter, a grouped scope that
+        # raises, or any unexpected count failure. A nil total makes
+        # `Progressbar.new` render a spinner instead of a bounded bar —
+        # avoids aborting the import just because the progressbar can't
+        # size itself.
+        def safe_import_count(objects)
+          return nil unless adapter.respond_to?(:import_count)
+
+          adapter.import_count(*objects)
+        rescue StandardError
+          nil
         end
 
         def process_parallel_import_results(results)

data/lib/chewy/index/mapping.rb

@@ -122,6 +122,7 @@ module Chewy
         #   end
         #
         def field(*args, **options, &block)
+          invalidate_compiled_compose! if respond_to?(:invalidate_compiled_compose!)
           if args.size > 1
             args.map { |name| field(name, **options) }
           else

data/lib/chewy/index/witchcraft.rb

@@ -1,15 +1,3 @@
-begin
-  require 'method_source'
-  begin
-    require 'prism'
-  rescue LoadError
-    require 'parser/current'
-  end
-  require 'unparser'
-rescue LoadError
-  nil
-end
-
 module Chewy
   class Index
     module Witchcraft
@@ -19,8 +7,30 @@ module Chewy
         class_attribute :_witchcraft, instance_reader: false, instance_writer: false
       end
 
+      def self.load_dependencies!
+        return if @dependencies_loaded
+
+        require 'method_source'
+        begin
+          require 'prism'
+        rescue LoadError
+          require 'parser/current'
+        end
+        require 'unparser'
+        @dependencies_loaded = true
+      rescue LoadError
+        nil
+      end
+
       module ClassMethods
         def witchcraft!
+          warn(
+            '[DEPRECATION] Chewy::Index.witchcraft! is deprecated and will be removed in a future release. ' \
+            'The compiled compose path is now the default and delivers equivalent performance without ' \
+            "method_source/parser/unparser dependencies. Remove the `witchcraft!` call from #{name || self}.",
+            uplevel: 1
+          )
+          Witchcraft.load_dependencies!
           self._witchcraft = true
           check_requirements!
         end
@@ -59,15 +69,15 @@ module Chewy
           @fields = fields
         end
 
-        def brew(object, crutches = nil)
-          alicorn.call(locals, object, crutches).as_json
+        def brew(object, crutches = nil, context = {})
+          alicorn.call(locals, object, crutches, context).as_json
         end
 
       private
 
         def alicorn
           @alicorn ||= singleton_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            -> (locals, object0, crutches) do
+            -> (locals, object0, crutches, context) do
               #{composed_values(@index.root, 0)}
             end
           RUBY
@@ -171,8 +181,8 @@ module Chewy
           end
         end
 
-        def source_for(proc, nesting)
-          lambdas = exctract_lambdas(ast_from_proc(proc))
+        def source_for(proc, nesting) # rubocop:disable Metrics/AbcSize
+          lambdas = extract_lambdas(ast_from_proc(proc))
 
           raise "No lambdas found, try to reformat your code:\n`#{proc.source}`" unless lambdas
 
@@ -189,6 +199,7 @@ module Chewy
               source = replace_lvar(source, proc_params[n], :"object#{n}") if proc_params[n]
             end
             source = replace_lvar(source, proc_params[nesting + 1], :crutches) if proc_params[nesting + 1]
+            source = replace_lvar(source, proc_params[nesting + 2], :context) if proc_params[nesting + 2]
 
             binding_variable_list(source).each do |variable|
               locals.push(proc.binding.eval(variable.to_s))
@@ -207,13 +218,13 @@ module Chewy
           end
         end
 
-        def exctract_lambdas(node)
+        def extract_lambdas(node)
           return unless node.is_a?(Parser::AST::Node)
 
           if node.type == :block && node.children[0].type == :send && node.children[0].to_a == [nil, :lambda]
             [node.children[2]]
           else
-            node.children.map { |child| exctract_lambdas(child) }.flatten.compact
+            node.children.map { |child| extract_lambdas(child) }.flatten.compact
           end
         end
 

data/lib/chewy/index/wrapper.rb

@@ -39,7 +39,7 @@ module Chewy
         end
       end
 
-      %w[_id _type _index].each do |name|
+      %w[_id _index].each do |name|
         define_method name do
           _data[name]
         end

data/lib/chewy/index.rb

@@ -11,6 +11,7 @@ require 'chewy/index/settings'
 require 'chewy/index/specification'
 require 'chewy/index/syncer'
 require 'chewy/index/witchcraft'
+require 'chewy/index/compiled'
 require 'chewy/index/wrapper'
 
 module Chewy
@@ -32,6 +33,7 @@ module Chewy
     include Observe
     include Crutch
     include Witchcraft
+    include Compiled
     include Wrapper
 
     singleton_class.delegate :client, to: 'Chewy'

data/lib/chewy/minitest/helpers.rb

@@ -96,7 +96,6 @@ module Chewy
             'hits' => hits.each_with_index.map do |hit, i|
               {
                 '_index' => index.index_name,
-                '_type' => '_doc',
                 '_id' => hit[:id] || (i + 1).to_s,
                 '_score' => 3.14,
                 '_source' => hit

data/lib/chewy/multi_search.rb

@@ -11,7 +11,7 @@ module Chewy
     # Instantiate a new MultiSearch instance.
     #
     # @param queries [Array<Chewy::Search::Request>]
-    # @option [Elasticsearch::Transport::Client] :client (Chewy.client)
+    # @option [Elasticsearch::Client] :client (Chewy.client)
     #   The Elasticsearch client that should be used for issuing requests.
     def initialize(queries, client: Chewy.client)
       @client = client

data/lib/chewy/rake_helper.rb

@@ -21,6 +21,8 @@ module Chewy
 
     DELETE_BY_QUERY_OPTIONS = %w[WAIT_FOR_COMPLETION REQUESTS_PER_SECOND SCROLL_SIZE].freeze
     FALSE_VALUES = %w[0 f false off].freeze
+    TRUE_VALUES = %w[1 t true on yes].freeze
+    UNBOUNDED_VALUES = %w[unbounded].freeze
 
     class << self
       # Performs zero-downtime reindexing of all documents for the specified indexes
@@ -105,7 +107,7 @@ module Chewy
           indexes_from(only: only, except: except).each_with_object([]) do |index, updated_indexes|
             if index.exists?
               output.puts "Updating #{index}"
-              index.import(parallel: parallel)
+              index.import(parallel: parallel, progressbar: progressbar_option)
               updated_indexes.push(index)
             else
               output.puts "Skipping #{index}, it does not exists (use rake chewy:reset[#{index.derivable_name}] to create and update it)"
@@ -336,7 +338,22 @@ module Chewy
 
       def reset_one(index, output, parallel: false)
         output.puts "Resetting #{index}"
-        index.reset!((Time.now.to_f * 1000).round, parallel: parallel, apply_journal: journal_exists?)
+        index.reset!((Time.now.to_f * 1000).round, parallel: parallel, apply_journal: journal_exists?, progressbar: progressbar_option)
+      end
+
+      def progressbar_option
+        value = ENV.fetch('PROGRESS', nil)
+        return false if value.nil? || value.empty?
+
+        case value.downcase
+        when *FALSE_VALUES then false
+        when *UNBOUNDED_VALUES then :unbounded
+        when *TRUE_VALUES then true
+        else
+          warn "PROGRESS=#{value.inspect} not recognized; treating as enabled. " \
+               "Use #{TRUE_VALUES.join('/')}, #{UNBOUNDED_VALUES.join('/')}, or #{FALSE_VALUES.join('/')}."
+          true
+        end
       end
 
       def warn_missing_index(output)

data/lib/chewy/rspec/helpers.rb

@@ -39,7 +39,6 @@ module Chewy
             'hits' => hits.each_with_index.map do |hit, i|
               {
                 '_index' => index.index_name,
-                '_type' => '_doc',
                 '_id' => (i + 1).to_s,
                 '_score' => 3.14,
                 '_source' => hit

data/lib/chewy/search/parameters/runtime_mappings.rb

@@ -0,0 +1,14 @@
+module Chewy
+  module Search
+    class Parameters
+      # Just a standard hash storage. Nothing to see here.
+      #
+      # @see Chewy::Search::Parameters::HashStorage
+      # @see Chewy::Search::Request#runtime_mappings
+      # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-search-request.html
+      class RuntimeMappings < Storage
+        include HashStorage
+      end
+    end
+  end
+end

data/lib/chewy/search/request.rb

@@ -18,14 +18,14 @@ module Chewy
       include Scoping
       include Scrolling
       UNDEFINED = Class.new.freeze
-      EVERFIELDS = %w[_index _type _id _parent _routing].freeze
+      EVERFIELDS = %w[_index _id _routing].freeze
       DELEGATED_METHODS = %i[
         query filter post_filter knn order reorder docvalue_fields
         track_scores track_total_hits request_cache explain version profile
         search_type preference limit offset terminate_after
         timeout min_score source stored_fields search_after
         load script_fields suggest aggs aggregations collapse none
-        indices_boost rescore highlight total total_count
+        indices_boost rescore highlight runtime_mappings total total_count
         total_entries indices types delete_all count exists?
         exist? find pluck scroll_batches scroll_hits
         scroll_results scroll_wrappers ignore_unavailable
@@ -656,7 +656,23 @@ module Chewy
       #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/highlighting.html
       #   @param value [Hash]
       #   @return [Chewy::Search::Request]
-      %i[script_fields indices_boost rescore highlight].each do |name|
+      #
+      # @!method runtime_mappings(value)
+      #   Add a `runtime_mappings` part to the request. Further
+      #   call values are merged to the storage hash.
+      #
+      #   @example
+      #     PlacesIndex
+      #       .runtime_mappings(field1: {type: "keyword", script: {lang: "painless", source: "emit('some script here')"}})
+      #       .runtime_mappings(field2: {type: "keyword", script: {lang: "painless", source: "emit('some script here')"}})
+      #     # => <PlacesIndex::Query {..., :body=>{:runtime_mappings=>{
+      #     #      "field1"=>{:type=>"keyword", :script=>{:lang=>"painless", :source=>"emit('some script here')"}},
+      #     #      "field2"=>{:type=>"keyword", :script=>{:lang=>"painless", :source=>"emit('some script here')"}}}}}>
+      #   @see Chewy::Search::Parameters::RuntimeMappings
+      #   @see https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-search-request.html
+      #   @param value [Hash]
+      #   @return [Chewy::Search::Request]
+      %i[script_fields indices_boost rescore highlight runtime_mappings].each do |name|
         define_method name do |value|
           modify(name) { update!(value) }
         end
@@ -936,7 +952,7 @@ module Chewy
 
       # Returns and array of values for specified fields.
       # Uses `source` to restrict the list of returned fields.
-      # Fields `_id`, `_type`, `_routing` and `_index` are also supported.
+      # Fields `_id`, `_routing` and `_index` are also supported.
       #
       # @overload pluck(field)
       #   If single field is passed - it returns and array of values.

data/lib/chewy/search/scrolling.rb

@@ -29,20 +29,28 @@ module Chewy
 
         result = perform(size: batch_size, scroll: scroll)
         total = [raw_limit_value, result.fetch('hits', {}).fetch('total', {}).fetch('value', 0)].compact.min
+
+        total_batches = total / batch_size
         last_batch_size = total % batch_size
-        fetched = 0
+
+        total_batches += 1 if last_batch_size != 0
+
         scroll_id = nil
 
-        loop do
+        total_batches.times do |batch_counter|
+          last_run = total_batches - 1 == batch_counter
+
           hits = result.fetch('hits', {}).fetch('hits', [])
-          fetched += hits.size
-          hits = hits.first(last_batch_size) if last_batch_size != 0 && fetched >= total
+          hits = hits.first(last_batch_size) if last_run && last_batch_size != 0
+
+          raise Chewy::MissingHitsInScrollError if hits.empty?
+
           yield(hits) if hits.present?
           scroll_id = result['_scroll_id']
 
-          break if result['terminated_early'] || fetched >= total
+          break if result['terminated_early']
 
-          result = perform_scroll(scroll: scroll, scroll_id: scroll_id)
+          result = perform_scroll(scroll: scroll, scroll_id: scroll_id) unless last_run
         end
       ensure
         Chewy.client.clear_scroll(body: {scroll_id: scroll_id}) if scroll_id

data/lib/chewy/stash.rb

@@ -38,17 +38,21 @@ module Chewy
 
       # Selects all the journal entries for the specified indices.
       #
+      # Uses a single `terms` filter rather than a chain of `bool.should`
+      # clauses so the query depth stays constant regardless of how many
+      # indices are passed. Avoids hitting the Elasticsearch
+      # `indices.query.bool.max_nested_depth` limit (default 30) when
+      # cleaning or applying journals across many indices.
+      #
       # @param indices [Chewy::Index, Array<Chewy::Index>]
       def self.for(*something)
         something = something.flatten.compact
+        return all if something.empty?
+
         indexes = something.flat_map { |s| Chewy.derive_name(s) }
-        return none if something.present? && indexes.blank?
+        return none if indexes.blank?
 
-        scope = all
-        indexes.each do |index|
-          scope = scope.or(filter(term: {index_name: index.derivable_name}))
-        end
-        scope
+        filter(terms: {index_name: indexes.map(&:derivable_name).uniq})
       end
 
       default_import_options journal: false

data/lib/chewy/strategy/delayed_sidekiq/worker.rb

@@ -13,7 +13,7 @@ module Chewy
           local timechunks_key = prefix .. ":" .. type .. ":timechunks"
 
           -- Get timechunk_keys with scores less than or equal to the specified score
-          local timechunk_keys = redis.call('zrangebyscore', timechunks_key, '-inf', score)
+          local timechunk_keys = redis.call('zrange', timechunks_key, '-inf', score, 'byscore')
 
           -- Get all members from the sets associated with the timechunk_keys
           local members = {}

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '8.0.1'.freeze
+  VERSION = '8.3.0'.freeze
 end

data/lib/chewy.rb

@@ -31,6 +31,7 @@ end
 try_require 'kaminari'
 try_require 'kaminari/core'
 try_require 'parallel'
+try_require 'ruby-progressbar'
 
 ActiveSupport.on_load(:active_record) do
   try_require 'kaminari/activerecord'