chewy 8.0.1 → 8.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36ec23aabab2b6b62d9425ad6505f5589958400f21411c90d9808113336aac35
-  data.tar.gz: 0b082e6327fa4092477c7888714662f791a940b9a1045047ce7a183d41656f2c
+  metadata.gz: 34d773f10bf67d60eca51ff91a6d668186eea74515bb5b31a5fd5ce814dac3c7
+  data.tar.gz: 334c6e92185369170b9f4d534029b69c218bb3c0cabfe6e4c11fd79268c19587
 SHA512:
-  metadata.gz: ad839b902eeb12a5f94547e21f0ed9b2d078be1869b0070be7698fd357edde8d6d759502301dd823eb53d8a3fa42bd6d5584cee53dd482df6c05d1b46e2d110a
-  data.tar.gz: 3fdef90ea2c73f41274556d5f001e7931bcbbb9b2bdd02df6204fbd75c5b8139ed2cbff00cd448922e8215d2f35f6f3695bd52505db2f30cd20968b54732c401
+  metadata.gz: 24bde735bcfc4f1bfec8b146cdcc5024d049e1405ccfbbae5e6f57f53a89aa9a6951063b00251a2f87fafac3632e1640fddc64038c7337e9147a0b9d6740f984
+  data.tar.gz: d2d84b1d2d3b07bde52699dfc54ed3b9ac8b9b71c5d79ca204851abab06bf53a41f0591ded6cdab59be5bf87522374dc10ff01d180891bcf81d73d33b009e180

data/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## master (unreleased)
+
+### New Features
+
+### Bug Fixes
+
+### Changes
+
+## 8.3.0 (2026-06-03)
+
+### New Features
+
+* New compiled compose path is now the default for every index. Chewy generates one `__chewy_compose__` method per index from the field tree on first import and reuses it for every object, replacing the iterative `Fields::Root#compose` loop. Typical document composition is 3-4× faster than the iterative path and matches `witchcraft!` performance without any extra dependencies. `update_fields:` partial imports are also covered via per-fields-set memoized methods.
+
+### Bug Fixes
+
+### Changes
+
+* **Deprecation:** `Chewy::Index.witchcraft!` is deprecated and will be removed in a future major release. It now prints a deprecation warning and is no longer required for fast composition — the compiled compose path described above is the default and delivers equivalent throughput without `method_source` / `parser` / `prism` / `unparser`. The `parser` / `prism` / `unparser` requires are now lazy and only loaded when an index actually calls `witchcraft!`, eliminating ~24 MiB of boot-time allocations and ~1 MiB of retained memory for apps that don't use it ([#644](https://github.com/toptal/chewy/issues/644)).
+
+* [#1028](https://github.com/toptal/chewy/pull/1028): Remove the obsolete `_type` field from mock response helpers (`Chewy::Minitest::Helpers`, `Chewy::Rspec::Helpers`), `EVERFIELDS`, and `Chewy::Index::Wrapper` accessors. Elasticsearch removed `_type` from search responses in 8.0 (ES 7 already returned only the placeholder `_doc`), so these references no longer matched real responses. Also removes the long-obsolete `_parent` entry from `EVERFIELDS`. ([@mattmenefee][])
+
+## 8.2.1 (2026-06-01)
+
+### New Features
+
+### Bug Fixes
+
+* Fix `import_count` on relations with multiple `.select(...)` clauses so the bounded progressbar is used instead of silently falling back to the unbounded spinner. Bare `.count` produced `SELECT COUNT(col1, col2, ...)` (invalid SQL); `count(:all)` is used for relations. ([#1026](https://github.com/toptal/chewy/pull/1026))
+
+### Changes
+
+## 8.2.0 (2026-05-29)
+
+### New Features
+
+* Add `progressbar:` option to `import`/`import!` and a `PROGRESS=1` rake env toggle for `chewy:reset` / `chewy:update`. The bar is opt-in (default `false`), supports a `:unbounded` spinner mode that skips the `import_count` query, and is safe in parallel mode — workers stay process-based, the bar is incremented in the parent via `Parallel`'s `finish:` callback. Reintroduces the feature originally added in [#787](https://github.com/toptal/chewy/pull/787) and reverted in [#800](https://github.com/toptal/chewy/pull/800) without the GVL regression.
+
+### Bug Fixes
+
+* Fix race condition during `reset!` where the unsuffixed concrete index could be recreated by a concurrent process between the delete and the alias creation, causing the alias creation to fail with an index/alias name collision.
+  The delete + alias-add are now performed in a single atomic `_aliases` cluster state update via the `remove_index` action.
+  No public API or layout change.
+* [#992](https://github.com/toptal/chewy/issues/992): `import(update_fields: [])` is now a no-op (zero fields to update) instead of triggering a full document reindex. The default of `update_fields` is now `nil` (still performs a full reindex). Behavior change: any caller passing an explicit empty array previously got a silent full reimport; they will now skip the update.
+
+### Changes
+
+* [#1024](https://github.com/toptal/chewy/pull/1024): Replace deprecated `ZRANGEBYSCORE` with `ZRANGE ... BYSCORE` in the `delayed_sidekiq` worker Lua script. `ZRANGEBYSCORE` has been deprecated in Redis since 6.2.0.
+
+## 8.1.0 (2026-05-28)
+
+### New Features
+
+* [#887](https://github.com/toptal/chewy/pull/887): Add support [runtime_mappings](https://www.elastic.co/guide/en/elasticsearch/reference/current/runtime-search-request.html). ([@TakuyaKurimoto](https://github.com/TakuyaKurimoto))
+* [#996](https://github.com/toptal/chewy/pull/996): Add `context:` option to `import`/`import!` for passing custom data to crutch blocks and field value procs without redundant DB queries.
+
+### Bug Fixes
+
+* [#878](https://github.com/toptal/chewy/issues/878): Flatten `Chewy::Stash::Journal.for` to use a single `terms` filter instead of a chain of `bool.should` clauses. Fixes Elasticsearch `indices.query.bool.max_nested_depth` errors when applying or cleaning the journal across many indices.
+
+### Changes
+
+* [#916](https://github.com/toptal/chewy/pull/916): Raise error in #scroll_batches when search backend returns a failure. ([@tomdev][])
+* [#1008](https://github.com/toptal/chewy/pull/1008): Promote Elasticsearch to a native GitHub Actions service with a health-check gate, replacing the fragile `docker compose` + `sleep 15` approach. ([@mattmenefee][])
+* [#1010](https://github.com/toptal/chewy/pull/1010): Add Chewy 7/ES 7 to Chewy 8/ES 8 migration guide and fix stale `Elasticsearch::Transport` namespace references in docs. ([@mattmenefee][])
+* [#1011](https://github.com/toptal/chewy/pull/1011): Replace deprecated `Sidekiq::Testing` API with new `Sidekiq 8.1+` testing API and silence Sidekiq logger during spec runs. ([@mattmenefee][], [@mjankowski][])
+* [#1013](https://github.com/toptal/chewy/pull/1013): Fix `drop_indices` test helper to use `format: 'json'` for ES version portability. If you define a custom `drop_indices` helper in your test suite, update it to use `Chewy.client.cat.indices(format: 'json')` instead of parsing the text-format response. ([@mattmenefee][])
+* [#1014](https://github.com/toptal/chewy/pull/1014): Improve contributing documentation with development setup instructions, PR workflow, and grammar fixes. ([@mattmenefee][])
+
 ## 8.0.1 (2026-03-12)
 
 ### New Features
@@ -874,10 +943,12 @@
 [@marshall]: https://github.com/marshall
 [@matchbookmac]: https://github.com/matchbookmac
 [@matthee]: https://github.com/matthee
+[@mattmenefee]: https://github.com/mattmenefee
 [@mattzollinhofer]: https://github.com/mattzollinhofer
 [@menglewis]: https://github.com/menglewis
 [@mikeyhogarth]: https://github.com/mikeyhogarth
 [@milk1000cc]: https://github.com/milk1000cc
+[@mjankowski]: https://github.com/mjankowski
 [@mkcode]: https://github.com/mkcode
 [@mpeychich]: https://github.com/mpeychich
 [@mrbrdo]: https://github.com/mrbrdo
@@ -901,6 +972,7 @@
 [@socialchorus]: https://github.com/socialchorus
 [@taylor-au]: https://github.com/taylor-au
 [@TikiTDO]: https://github.com/TikiTDO
+[@tomdev]: https://github.com/tomdev
 [@undr]: https://github.com/undr
 [@Vitalina-Vakulchyk]: https://github.com/Vitalina-Vakulchyk
 [@webgago]: https://github.com/webgago

data/README.md

@@ -1,7 +1,5 @@
 [![Gem Version](https://badge.fury.io/rb/chewy.svg)](http://badge.fury.io/rb/chewy)
 [![GitHub Actions](https://github.com/toptal/chewy/actions/workflows/ruby.yml/badge.svg)](https://github.com/toptal/chewy/actions/workflows/ruby.yml)
-[![Code Climate](https://codeclimate.com/github/toptal/chewy.svg)](https://codeclimate.com/github/toptal/chewy)
-[![Inline docs](http://inch-ci.org/github/toptal/chewy.svg?branch=master)](http://inch-ci.org/github/toptal/chewy)
 
 # Chewy
 
@@ -47,7 +45,7 @@ Chewy aims to support all Ruby and Rails versions that are currently maintained
 
 ### Ruby
 
-Chewy is compatible with MRI 3.2-3.4.
+Chewy is compatible with MRI 3.2-4.0.
 
 ### Elasticsearch compatibility matrix
 
@@ -220,7 +218,6 @@ end
     },
     "_data":{
       "_index":"users",
-      "_type":"_doc",
       "_id":"1",
       "_score":0.9808291,
       "_source":{
@@ -238,7 +235,7 @@ end
 
 - [Getting Started](docs/getting_started.md) — end-to-end tutorial building search for a media library
 - [Configuration](docs/configuration.md) — client settings, update strategies, notifications, integrations
-- [Indexing](docs/indexing.md) — index definition, field types, crutches, witchcraft, index manipulation
+- [Indexing](docs/indexing.md) — index definition, field types, crutches, compiled compose path, index manipulation
 - [Import](docs/import.md) — import options, raw import, journaling
 - [Querying](docs/querying.md) — search requests, pagination, scopes, scroll, loading
 - [Rake Tasks](docs/rake_tasks.md) — all rake tasks and parallelization
@@ -274,19 +271,7 @@ Use the standard client settings with your Cloud credentials (API key or user/pa
 
 ## Contributing
 
-1. Fork it (http://github.com/toptal/chewy/fork)
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Implement your changes, cover it with specs and make sure old specs are passing
-4. Commit your changes (`git commit -am 'Add some feature'`)
-5. Push to the branch (`git push origin my-new-feature`)
-6. Create new Pull Request
-
-Use the following Rake tasks to control the Elasticsearch cluster while developing, if you prefer native Elasticsearch installation over the dockerized one:
-
-```bash
-rake elasticsearch:start # start Elasticsearch cluster on 9250 port for tests
-rake elasticsearch:stop # stop Elasticsearch
-```
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup instructions, how to run tests, and the pull request workflow.
 
 ## Copyright
 

data/lib/chewy/errors.rb

@@ -37,6 +37,9 @@ module Chewy
     end
   end
 
+  class MissingHitsInScrollError < Error
+  end
+
   class ImportScopeCleanupError < Error
   end
 

data/lib/chewy/fields/root.rb

@@ -3,10 +3,12 @@ module Chewy
     class Root < Chewy::Fields::Base
       attr_reader :dynamic_templates, :id
 
+      DEFAULT_VALUE = -> { self }
+
       def initialize(name, **options)
         super
 
-        @value ||= -> { self }
+        @value ||= DEFAULT_VALUE
         @dynamic_templates = []
       end
 
@@ -61,8 +63,8 @@ module Chewy
       # @param fields [Array<Symbol>] a list of fields to compose, every field will be composed if empty
       # @return [Hash] JSON-ready hash with stringified keys
       #
-      def compose(object, crutches = nil, fields: [])
-        result = evaluate([object, crutches])
+      def compose(object, crutches = nil, fields: [], context: {})
+        result = evaluate([object, crutches, context])
 
         if children.present?
           child_fields = if fields.present?
@@ -72,7 +74,7 @@ module Chewy
           end
 
           child_fields.each_with_object({}) do |field, memo|
-            memo.merge!(field.compose(result, crutches) || {})
+            memo.merge!(field.compose(result, crutches, context) || {})
           end.as_json
         elsif fields.present?
           result.as_json(only: fields, root: false)

data/lib/chewy/index/actions.rb

@@ -7,12 +7,13 @@ module Chewy
       extend ActiveSupport::Concern
 
       module ClassMethods
-        # Checks index existance. Returns true or false
+        # Checks index existance. Supports suffixes. Returns true or false
         #
         #   UsersIndex.exists? #=> true
+        #   UsersIndex.exists?('11-2024') #=> false
         #
-        def exists?
-          client.indices.exists(index: index_name)
+        def exists?(suffix = nil)
+          client.indices.exists(index: index_name(suffix: suffix))
         end
 
         # Creates index and applies mappings and settings.
@@ -163,16 +164,17 @@ module Chewy
             ))
             original_index_settings suffixed_name
 
-            delete if indexes.blank?
-            client.indices.update_aliases body: {actions: [
-              *indexes.map do |index|
-                {remove: {index: index, alias: general_name}}
-              end,
-              {add: {index: suffixed_name, alias: general_name}}
-            ]}
+            actions = indexes.map { |index| {remove: {index: index, alias: general_name}} }
+            actions << {add: {index: suffixed_name, alias: general_name}}
+            if indexes.blank? && exists?
+              index_names = client.indices.get_alias(index: general_name).keys
+              actions << {remove_index: {index: index_names.join(',')}}
+            end
+
+            client.indices.update_aliases body: {actions: actions}
             client.indices.delete index: indexes if indexes.present?
 
-            self.journal.apply(start_time, **import_options) if apply_journal
+            self.journal.apply(start_time, **import_options.except(:progressbar)) if apply_journal
             result
           else
             purge!

data/lib/chewy/index/adapter/object.rb

@@ -146,6 +146,23 @@ module Chewy
           collection.each_slice(options[:batch_size], &block)
         end
 
+        # Returns the count of objects that would be imported. Used by the
+        # progressbar feature to set the total. Mirrors {#import_args} input
+        # handling but does not enumerate batches.
+        #
+        # @return [Integer]
+        def import_count(*args)
+          args = args.dup
+          args.extract_options!
+          collection = if args.empty? && @target.respond_to?(import_all_method)
+            @target.send(import_all_method)
+          else
+            args.flatten(1).compact
+          end
+
+          collection.count
+        end
+
         # This method is used internally by the request DSL when the
         # collection of ORM/ODM objects is requested.
         #

data/lib/chewy/index/adapter/orm.rb

@@ -96,6 +96,26 @@ module Chewy
         end
         alias_method :import_references, :import_fields
 
+        # Returns the count of records that would be imported. Used by the
+        # progressbar feature to set the total. Accepts the same shapes as
+        # {#import}: nothing (uses default scope), a relation, or an array
+        # of ids/objects.
+        #
+        # @return [Integer]
+        def import_count(*args)
+          args = args.dup
+          args.extract_options!
+          collection = if args.empty?
+            default_scope
+          elsif args.first.is_a?(relation_class)
+            args.first
+          else
+            args.flatten.compact
+          end
+
+          collection.is_a?(relation_class) ? collection.count(:all) : collection.count
+        end
+
         def load(ids, **options)
           scope = all_scope_where_ids_in(ids)
           additional_scope = options[options[:_index].to_sym].try(:[], :scope) || options[:scope]

data/lib/chewy/index/compiled.rb

@@ -0,0 +1,235 @@
+module Chewy
+  class Index
+    # Compiled compose path. Default for all indexes.
+    #
+    # Generates a single `__chewy_compose__` method per index from the
+    # field tree (no Ruby source parsing of user procs). Bakes the
+    # per-field arity into the call site and inlines hash construction,
+    # removing the per-field iteration + dispatch overhead of the legacy
+    # plain compose path. Proc bodies are NOT inlined — procs are called
+    # via `.call`. In exchange there are no parser/unparser/method_source
+    # deps and no Ruby/Prism version coupling.
+    #
+    # `fields:` selection is supported: a dedicated method is generated
+    # and memoized per unique fields set.
+    #
+    # Falls back to the plain `Chewy::Fields::Root#compose` path when the
+    # field tree uses features the compiler does not handle:
+    # ignore_blank, geo_point, custom root value.
+    module Compiled
+      extend ActiveSupport::Concern
+
+      class UNSUPPORTED < StandardError
+      end
+
+      COMPILE_MUTEX = Mutex.new
+
+      module ClassMethods
+        # Returns true when this index can use the compiled path for the
+        # given compose call. Builds the per-fields method if needed.
+        def compiled_compose_available?(fields)
+          return false if witchcraft?
+          return false unless root&.children&.present?
+
+          ensure_compiled_compose_for!(fields)
+        rescue UNSUPPORTED
+          false
+        end
+
+        def compiled_compose(object, crutches, context, fields)
+          send(compiled_method_name(fields), object, crutches, context)
+        end
+
+        def compiled_procs
+          @compiled_procs ||= []
+        end
+
+        # Build (and cache) the compiled compose method for the given
+        # fields restriction. Returns true on success, false / raises on
+        # unsupported. Thread-safe: compilation under a process-wide
+        # mutex prevents two threads from interleaving appends into
+        # @compiled_procs and baking duplicate indices into class_eval'd
+        # method bodies.
+        def ensure_compiled_compose_for!(fields)
+          key = fields_key(fields)
+          built = (@compiled_compose_built ||= {})
+          return built[key] if built.key?(key)
+
+          COMPILE_MUTEX.synchronize do
+            return built[key] if built.key?(key)
+
+            method_name = compiled_method_name(fields)
+            source      = Compiler.new(self, fields: fields, method_name: method_name).build
+            class_eval(source, __FILE__, __LINE__)
+            built[key] = true
+          end
+        rescue UNSUPPORTED
+          (@compiled_compose_built ||= {})[fields_key(fields)] = false
+          raise
+        end
+
+        # Clears compiled-method cache and rebuilds-on-next-call. Hooked
+        # from `Mapping.field` so a `field` added after the first compose
+        # is picked up rather than absent from a stale generated method.
+        # Existing singleton methods remain defined (they shadow until
+        # rebuilt) but the cache flag is dropped so the next compose
+        # rebuilds and reassigns them.
+        def invalidate_compiled_compose!
+          @compiled_compose_built = nil
+          @compiled_procs = nil
+          @compiled_default_ready = false
+        end
+
+        def compiled_method_name(fields)
+          key = fields_key(fields)
+          return :__chewy_compose__ if key.empty?
+
+          :"__chewy_compose__#{key}"
+        end
+
+      private
+
+        # Distinct field sets are kept distinct by hashing the joined,
+        # sorted symbol names rather than joining with a separator that
+        # collides with `_` inside field names (e.g. [:full_name, :id]
+        # vs [:full, :name_id]). Hex-encoding the digest keeps the
+        # method name a valid Ruby identifier.
+        def fields_key(fields)
+          return ''.freeze if fields.nil? || fields.empty?
+
+          require 'digest'
+          Digest::SHA1.hexdigest(fields.map(&:to_sym).sort.join("\0"))[0, 12]
+        end
+      end
+
+      class Compiler
+        IDENTIFIER_RE = /\A[A-Za-z_][A-Za-z0-9_]*[!?=]?\z/
+
+        def initialize(index, fields: [], method_name: :__chewy_compose__)
+          @index       = index
+          @procs       = index.compiled_procs
+          @counter     = 0
+          @fields      = fields.map(&:to_sym)
+          @method_name = method_name
+        end
+
+        def build
+          check_root_value!(@index.root)
+          body = compose_children_src(@index.root, 'o0', restrict: @fields)
+          <<~RUBY
+            def self.#{@method_name}(o0, crutches, context)
+              #{body}.as_json
+            end
+          RUBY
+        end
+
+      private
+
+        def check_root_value!(root)
+          v = root.instance_variable_get(:@value)
+          return if v.equal?(Chewy::Fields::Root::DEFAULT_VALUE)
+
+          raise UNSUPPORTED, 'custom root value proc not supported by compiled path'
+        end
+
+        def compose_children_src(parent_field, obj_var, restrict: [])
+          children = parent_field.children
+          children = children.select { |f| restrict.include?(f.name) } if restrict.any?
+          # Plain Base#compose_children merges per-field hashes, so a field
+          # redeclared with the same name is silently last-wins. Match that
+          # here to avoid Ruby's "duplicate key" warning on the generated
+          # literal hash.
+          children = children.reverse.uniq(&:name).reverse
+
+          pairs = children.map do |f|
+            raise UNSUPPORTED, "field #{f.name}" if unsupported?(f)
+
+            # Use Ruby's literal-inspect for the key so names with quotes,
+            # backslashes, `#{}`, or other special characters are safely
+            # serialised — never raw-interpolated into source.
+            "#{f.name.to_s.inspect} => #{field_value_src(f, obj_var)}"
+          end
+          "{ #{pairs.join(', ')} }"
+        end
+
+        # Features the compiler refuses; caller falls back to plain.
+        # Join fields are supported via Field#value returning a proc.
+        def unsupported?(field)
+          return true if field.options.key?(:ignore_blank)
+          return true if field.options[:type].to_s == 'geo_point'
+
+          false
+        end
+
+        def field_value_src(field, parent_obj_var)
+          fetch = fetch_src(field, parent_obj_var)
+          return fetch if !field.children.present? || field.multi_field?
+
+          child_var = "o#{next_counter}"
+          raw_var   = "#{child_var}_raw"
+          children_src = compose_children_src(field, child_var)
+          <<~RUBY.chomp
+            (#{raw_var} = #{fetch}
+            if #{raw_var}.nil?
+              nil
+            elsif #{raw_var}.respond_to?(:to_ary)
+              #{raw_var}.to_ary.map { |#{child_var}| #{children_src} }
+            else
+              #{child_var} = #{raw_var}
+              #{children_src}
+            end)
+          RUBY
+        end
+
+        def fetch_src(field, obj_var)
+          v = field.value
+          if v.is_a?(Proc)
+            idx = @procs.size
+            @procs << v
+            procs_ref = "compiled_procs[#{idx}]"
+            param_count = positional_param_count(v)
+            case v.arity
+            when 0
+              "#{obj_var}.instance_exec(&#{procs_ref})"
+            else
+              # Pass only as many of (object, crutches, context) as the
+              # proc actually declares. This keeps lambdas with optional
+              # args (negative arity like `->(o, c=nil)`) from being
+              # called with too many arguments. Anything beyond context
+              # truncates to all three.
+              args = [obj_var, 'crutches', 'context'].first(param_count)
+              "#{procs_ref}.call(#{args.join(', ')})"
+            end
+          else
+            method_name = v.is_a?(Symbol) || v.is_a?(String) ? v.to_s : field.name.to_s
+            raise UNSUPPORTED, "non-identifier field accessor: #{method_name.inspect}" unless safe_identifier?(method_name)
+
+            # Mirror Base#value_by_name_proc: hash key-or-string fallback,
+            # method send otherwise.
+            "(#{obj_var}.is_a?(Hash) ? " \
+              "(#{obj_var}.key?(:#{method_name}) ? #{obj_var}[:#{method_name}] : #{obj_var}['#{method_name}']) : " \
+              "#{obj_var}.#{method_name})"
+          end
+        end
+
+        # Number of positional parameters declared by `proc`, counting
+        # required + optional. Splats and keyword args contribute one
+        # bucket each so the caller still passes all three context args.
+        def positional_param_count(proc)
+          params = proc.parameters
+          required = params.count { |type, _| %i[req opt].include?(type) }
+          has_splat = params.any? { |type, _| type == :rest }
+          has_splat ? 3 : [required, 3].min
+        end
+
+        def safe_identifier?(name)
+          IDENTIFIER_RE.match?(name.to_s)
+        end
+
+        def next_counter
+          @counter += 1
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/crutch.rb

@@ -9,9 +9,12 @@ module Chewy
       end
 
       class Crutches
-        def initialize(index, collection)
+        attr_reader :context
+
+        def initialize(index, collection, context = {})
           @index = index
           @collection = collection
+          @context = context
           @crutches_instances = {}
         end
 
@@ -26,7 +29,14 @@ module Chewy
         end
 
         def [](name)
-          @crutches_instances[name] ||= @index._crutches[:"#{name}"].call(@collection)
+          @crutches_instances[name] ||= begin
+            block = @index._crutches[:"#{name}"]
+            if block.arity > 1 || block.arity < -1
+              block.call(@collection, @context)
+            else
+              block.call(@collection)
+            end
+          end
         end
       end
 

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

@@ -13,11 +13,12 @@ module Chewy
         # @param to_index [Array<Object>] objects to index
         # @param delete [Array<Object>] objects or ids to delete
         # @param fields [Array<Symbol, String>] and array of fields for documents update
-        def initialize(index, to_index: [], delete: [], fields: [])
+        def initialize(index, to_index: [], delete: [], fields: nil, context: {})
           @index = index
           @to_index = to_index
           @delete = delete
-          @fields = fields.map!(&:to_sym)
+          @fields = fields&.map(&:to_sym)
+          @context = context
         end
 
         # Returns ES API-ready bulk requiest body.
@@ -42,10 +43,12 @@ module Chewy
       private
 
         def crutches_for_index
-          @crutches_for_index ||= Chewy::Index::Crutch::Crutches.new @index, @to_index
+          @crutches_for_index ||= Chewy::Index::Crutch::Crutches.new @index, @to_index, @context
         end
 
         def index_entry(object)
+          return [] if @fields&.empty?
+
           entry = {}
           entry[:_id] = index_object_ids[object] if index_object_ids[object]
           entry[:routing] = routing(object) if join_field?
@@ -257,13 +260,13 @@ module Chewy
         end
 
         def data_for(object, fields: [], crutches: crutches_for_index)
-          @index.compose(object, crutches, fields: fields)
+          @index.compose(object, crutches, fields: fields, context: @context)
         end
 
         def parent_changed?(data, old_parent)
           return false unless old_parent
           return false unless join_field?
-          return false unless @fields.include?(join_field.to_sym)
+          return false unless @fields&.include?(join_field.to_sym)
           return false unless data.key?(join_field)
 
           # The join field value can be a hash, e.g.: