chewy 6.0.0 → 7.6.0

data/lib/chewy/{type → index}/import/bulk_request.rb

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Import
       # Adds additional features to elasticsearch-api bulk method:
       # * supports Chewy index suffix if necessary;
@@ -10,12 +10,12 @@ module Chewy
       #
       # @see https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/bulk.rb
       class BulkRequest
-        # @param type [Chewy::Type] a type for the request
+        # @param index [Chewy::Index] an index for the request
         # @param suffix [String] an index name optional suffix
         # @param bulk_size [Integer] bulk size in bytes
         # @param bulk_options [Hash] options passed to the elasticsearch-api bulk method
-        def initialize(type, suffix: nil, bulk_size: nil, **bulk_options)
-          @type = type
+        def initialize(index, suffix: nil, bulk_size: nil, **bulk_options)
+          @index = index
           @suffix = suffix
           @bulk_size = bulk_size - 1.kilobyte if bulk_size # 1 kilobyte for request header and newlines
           @bulk_options = bulk_options
@@ -33,7 +33,7 @@ module Chewy
           return [] if body.blank?
 
           request_bodies(body).each_with_object([]) do |request_body, results|
-            response = @type.client.bulk request_base.merge(body: request_body) if request_body.present?
+            response = @index.client.bulk(**request_base.merge(body: request_body)) if request_body.present?
 
             next unless response.try(:[], 'errors')
 
@@ -47,8 +47,7 @@ module Chewy
 
         def request_base
           @request_base ||= {
-            index: @type.index_name(suffix: @suffix),
-            type: @type.type_name
+            index: @index.index_name(suffix: @suffix)
           }.merge!(@bulk_options)
         end
 

data/lib/chewy/{type → index}/import/journal_builder.rb

@@ -1,24 +1,23 @@
 module Chewy
-  class Type
+  class Index
     module Import
       class JournalBuilder
-        def initialize(type, index: [], delete: [])
-          @type = type
+        def initialize(index, to_index: [], delete: [])
           @index = index
+          @to_index = to_index
           @delete = delete
         end
 
         def bulk_body
-          Chewy::Type::Import::BulkBuilder.new(
-            Chewy::Stash::Journal::Journal,
-            index: [
-              entries(:index, @index),
+          Chewy::Index::Import::BulkBuilder.new(
+            Chewy::Stash::Journal,
+            to_index: [
+              entries(:index, @to_index),
               entries(:delete, @delete)
             ].compact
           ).bulk_body.each do |item|
             item.values.first.merge!(
-              _index: Chewy::Stash::Journal.index_name,
-              _type: Chewy::Stash::Journal::Journal.type_name
+              _index: Chewy::Stash::Journal.index_name
             )
           end
         end
@@ -27,9 +26,9 @@ module Chewy
 
         def entries(action, objects)
           return unless objects.present?
+
           {
-            index_name: @type.index.derivable_name,
-            type_name: @type.type_name,
+            index_name: @index.derivable_name,
             action: action,
             references: identify(objects).map { |item| Base64.encode64(::Elasticsearch::API.serializer.dump(item)) },
             created_at: Time.now.utc
@@ -37,7 +36,7 @@ module Chewy
         end
 
         def identify(objects)
-          @type.adapter.identify(objects)
+          @index.adapter.identify(objects)
         end
       end
     end

data/lib/chewy/{type → index}/import/routine.rb

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Import
       # This class performs the import routine for the options and objects given.
       #
@@ -20,7 +20,7 @@ module Chewy
       # when the document doesn't exist only if `update_failover` option is true. In order to
       # restore, it indexes such an objects completely on the next iteration.
       #
-      # @see Chewy::Type::Import::ClassMethods#import
+      # @see Chewy::Index::Import::ClassMethods#import
       class Routine
         BULK_OPTIONS = %i[
           suffix bulk_size
@@ -33,18 +33,18 @@ module Chewy
           refresh: true,
           update_fields: [],
           update_failover: true,
-          batch_size: Chewy::Type::Adapter::Base::BATCH_SIZE
+          batch_size: Chewy::Index::Adapter::Base::BATCH_SIZE
         }.freeze
 
         attr_reader :options, :parallel_options, :errors, :stats, :leftovers
 
         # Basically, processes passed options, extracting bulk request specific options.
-        # @param type [Chewy::Type] chewy type
-        # @param options [Hash] import options, see {Chewy::Type::Import::ClassMethods#import}
-        def initialize(type, **options)
-          @type = type
+        # @param index [Chewy::Index] chewy index
+        # @param options [Hash] import options, see {Chewy::Index::Import::ClassMethods#import}
+        def initialize(index, **options)
+          @index = index
           @options = options
-          @options.reverse_merge!(@type._default_import_options)
+          @options.reverse_merge!(@index._default_import_options)
           @options.reverse_merge!(journal: Chewy.configuration[:journal])
           @options.reverse_merge!(DEFAULT_OPTIONS)
           @bulk_options = @options.slice(*BULK_OPTIONS)
@@ -61,27 +61,28 @@ module Chewy
           @leftovers = []
         end
 
-        # Creates the journal index and the type corresponding index if necessary.
+        # Creates the journal index and the corresponding index if necessary.
         # @return [Object] whatever
         def create_indexes!
-          Chewy::Stash::Journal.create if @options[:journal]
+          Chewy::Stash::Journal.create if @options[:journal] && !Chewy.configuration[:skip_journal_creation_on_import]
           return if Chewy.configuration[:skip_index_creation_on_import]
-          @type.index.create!(**@bulk_options.slice(:suffix)) unless @type.index.exists?
+
+          @index.create!(**@bulk_options.slice(:suffix)) unless @index.exists?
         end
 
-        # The main process method. Converts passed objects to thr bulk request body,
-        # appends journal entires, performs this request and handles errors performing
+        # The main process method. Converts passed objects to the bulk request body,
+        # appends journal entries, performs this request and handles errors performing
         # failover procedures if applicable.
         #
         # @param index [Array<Object>] any acceptable objects for indexing
         # @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(@type, index: index, delete: delete, fields: @options[:update_fields])
+          bulk_builder = BulkBuilder.new(@index, to_index: index, delete: delete, fields: @options[:update_fields])
           bulk_body = bulk_builder.bulk_body
 
           if @options[:journal]
-            journal_builder = JournalBuilder.new(@type, index: index, delete: delete)
+            journal_builder = JournalBuilder.new(@index, to_index: index, delete: delete)
             bulk_body.concat(journal_builder.bulk_body)
           end
 
@@ -126,11 +127,11 @@ module Chewy
           errors_to_cleanup.each { |error| errors.delete(error) }
 
           failed_objects = index_objects_by_id.values_at(*failed_ids_for_reimport)
-          BulkBuilder.new(@type, index: failed_objects).bulk_body
+          BulkBuilder.new(@index, to_index: failed_objects).bulk_body
         end
 
         def bulk
-          @bulk ||= BulkRequest.new(@type, **@bulk_options)
+          @bulk ||= BulkRequest.new(@index, **@bulk_options)
         end
       end
     end

data/lib/chewy/{type → index}/import.rb

@@ -1,43 +1,42 @@
-require 'chewy/type/import/journal_builder'
-require 'chewy/type/import/bulk_builder'
-require 'chewy/type/import/bulk_request'
-require 'chewy/type/import/routine'
+require 'chewy/index/import/journal_builder'
+require 'chewy/index/import/bulk_builder'
+require 'chewy/index/import/bulk_request'
+require 'chewy/index/import/routine'
 
 module Chewy
-  class Type
+  class Index
     module Import
       extend ActiveSupport::Concern
 
-      IMPORT_WORKER = lambda do |type, options, total, ids, index|
-        ::Process.setproctitle("chewy [#{type}]: import data (#{index + 1}/#{total})")
-        routine = Routine.new(type, **options)
-        type.adapter.import(*ids, routine.options) do |action_objects|
+      IMPORT_WORKER = lambda do |index, options, total, ids, iteration|
+        ::Process.setproctitle("chewy [#{index}]: import data (#{iteration + 1}/#{total})")
+        routine = Routine.new(index, **options)
+        index.adapter.import(*ids, routine.options) do |action_objects|
           routine.process(**action_objects)
         end
         {errors: routine.errors, import: routine.stats, leftovers: routine.leftovers}
       end
 
-      LEFTOVERS_WORKER = lambda do |type, options, total, body, index|
-        ::Process.setproctitle("chewy [#{type}]: import leftovers (#{index + 1}/#{total})")
-        routine = Routine.new(type, **options)
+      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
       end
 
       module ClassMethods
         # @!method import(*collection, **options)
-        # Basically, one of the main methods for type. Performs any objects import
-        # to the index for a specified type. Does all the objects handling routines.
+        # Basically, one of the main methods for an index. Performs any objects import
+        # to the index. Does all the objects handling routines.
         # Performs document import by utilizing bulk API. Bulk size and objects batch
         # size are controlled by the corresponding options.
         #
         # It accepts ORM/ODM objects, PORO, hashes, ids which are used by adapter to
-        # fetch objects from the source depenting on the used adapter. It destroys
-        # passed objects from the index if they are not in the default type scope
+        # fetch objects from the source depending on the used adapter. It destroys
+        # passed objects from the index if they are not in the default scope
         # or marked for destruction.
         #
-        # It handles parent-child relationships: if the object parent_id has been
-        # changed it destroys the object and recreates it from scratch.
+        # It handles parent-child relationships with a join field reindexing children when the parent is reindexed.
         #
         # Performs journaling if enabled: it stores all the ids of the imported
         # objects to a specialized index. It is possible to replay particular import
@@ -51,15 +50,15 @@ module Chewy
         #
         # Utilizes `ActiveSupport::Notifications`, so it is possible to get imported
         # objects later by listening to the `import_objects.chewy` queue. It is also
-        # possible to get the list of occured errors from the payload if something
+        # possible to get the list of occurred errors from the payload if something
         # went wrong.
         #
         # Import can also be run in parallel using the Parallel gem functionality.
         #
         # @example
-        #   UsersIndex::User.import(parallel: true) # imports everything in parallel with automatic workers number
-        #   UsersIndex::User.import(parallel: 3) # using 3 workers
-        #   UsersIndex::User.import(parallel: {in_threads: 10}) # in 10 threads
+        #   UsersIndex.import(parallel: true) # imports everything in parallel with automatic workers number
+        #   UsersIndex.import(parallel: 3) # using 3 workers
+        #   UsersIndex.import(parallel: {in_threads: 10}) # in 10 threads
         #
         # @see https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/bulk.rb
         # @param collection [Array<Object>] and array or anything to import
@@ -74,7 +73,7 @@ module Chewy
         # @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
         # @return [true, false] false in case of errors
         def import(*args)
-          import_routine(*args).blank?
+          intercept_import_using_strategy(*args).blank?
         end
 
         # @!method import!(*collection, **options)
@@ -85,8 +84,10 @@ module Chewy
         #
         # @raise [Chewy::ImportFailed] in case of errors
         def import!(*args)
-          errors = import_routine(*args)
+          errors = intercept_import_using_strategy(*args)
+
           raise Chewy::ImportFailed.new(self, errors) if errors.present?
+
           true
         end
 
@@ -94,7 +95,7 @@ module Chewy
         # `bulk_size` and `suffix`.
         #
         # @see https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/bulk.rb
-        # @see Chewy::Type::Import::Bulk
+        # @see Chewy::Index::Import::BulkRequest
         # @param options [Hash{Symbol => Object}] besides specific import options, it accepts all the options suitable for the bulk API call like `refresh` or `timeout`
         # @option options [String] suffix bulk API chunk size in bytes; if passed, the request is performed several times for each chunk, empty by default
         # @option options [Integer] bulk_size bulk API chunk size in bytes; if passed, the request is performed several times for each chunk, empty by default
@@ -111,11 +112,11 @@ module Chewy
         # or normal composing under the hood.
         #
         # @param object [Object] a data source object
-        # @param crutches [Object] optional crutches object; if ommited - a crutch for the single passed object is created as a fallback
+        # @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::Type::Crutch::Crutches.new self, [object]
+          crutches ||= Chewy::Index::Crutch::Crutches.new self, [object]
 
           if witchcraft? && root.children.present?
             cauldron(fields: fields).brew(object, crutches)
@@ -126,8 +127,35 @@ module Chewy
 
       private
 
+        def intercept_import_using_strategy(*args)
+          args_clone = args.deep_dup
+          options = args_clone.extract_options!
+          strategy = options.delete(:strategy)
+
+          return import_routine(*args) if strategy.blank?
+
+          ids = args_clone.flatten
+          return {} if ids.blank?
+          return {argument: {"#{strategy} supports ids only!" => ids}} unless ids.all? do |id|
+            id.respond_to?(:to_i)
+          end
+
+          case strategy
+          when :delayed_sidekiq
+            begin
+              Chewy::Strategy::DelayedSidekiq::Scheduler.new(self, ids, options).postpone
+              {} # success. errors handling convention
+            rescue StandardError => e
+              {scheduler: {e.message => ids}}
+            end
+          else
+            {argument: {"unsupported strategy: '#{strategy}'" => ids}}
+          end
+        end
+
         def import_routine(*args)
-          return if args.first.blank? && !args.first.nil?
+          return if !args.first.nil? && empty_objects_or_scope?(args.first)
+
           routine = Routine.new(self, **args.extract_options!)
           routine.create_indexes!
 
@@ -138,8 +166,16 @@ module Chewy
           end
         end
 
+        def empty_objects_or_scope?(objects_or_scope)
+          if objects_or_scope.respond_to?(:empty?)
+            objects_or_scope.empty?
+          else
+            objects_or_scope.blank?
+          end
+        end
+
         def import_linear(objects, routine)
-          ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
+          ActiveSupport::Notifications.instrument 'import_objects.chewy', index: self do |payload|
             adapter.import(*objects, routine.options) do |action_objects|
               routine.process(**action_objects)
             end
@@ -153,17 +189,25 @@ module Chewy
         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
 
-          ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
+          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, &IMPORT_WORKER.curry[self, routine.options, batches.size])
+            results = ::Parallel.map_with_index(
+              batches,
+              routine.parallel_options,
+              &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])
+              results = ::Parallel.map_with_index(
+                batches,
+                routine.parallel_options,
+                &LEFTOVERS_WORKER.curry[self, routine.options, batches.size]
+              )
               errors.concat(results.flatten(1))
             end
 

data/lib/chewy/{type → index}/mapping.rb

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Mapping
       extend ActiveSupport::Concern
 
@@ -13,42 +13,39 @@ module Chewy
       end
 
       module ClassMethods
-        # Defines root object for mapping and is optional for type
+        # Defines root object for mapping and is optional for index
         # definition. Use it only if you need to pass options for root
         # object mapping, such as `date_detection` or `dynamic_date_formats`
         #
         # @example
         #   class UsersIndex < Chewy::Index
-        #     define_type User do
-        #       # root object defined implicitly and optionless for current type
-        #       field :full_name, type: 'keyword'
-        #     end
+        #     index_scope User
+        #     # root object defined implicitly and optionless for current type
+        #     field :full_name, type: 'keyword'
         #   end
         #
         #   class CarsIndex < Chewy::Index
-        #     define_type Car do
-        #       # explicit root definition with additional options
-        #       root dynamic_date_formats: ['yyyy-MM-dd'] do
-        #         field :model_name, type: 'keyword'
-        #       end
+        #     index_scope Car
+        #     # explicit root definition with additional options
+        #     root dynamic_date_formats: ['yyyy-MM-dd'] do
+        #       field :model_name, type: 'keyword'
         #     end
         #   end
         #
         def root(**options)
-          self.root_object ||= Chewy::Fields::Root.new(type_name, **Chewy.default_root_options.merge(options))
+          self.root_object ||= Chewy::Fields::Root.new(:root, **Chewy.default_root_options.merge(options))
           root_object.update_options!(**options)
           yield if block_given?
           root_object
         end
 
-        # Defines mapping field for current type
+        # Defines mapping field for index
         #
         # @example
         #   class UsersIndex < Chewy::Index
-        #     define_type User do
-        #       # passing all the options to field definition:
-        #       field :full_name, analyzer: 'special'
-        #     end
+        #     index_scope User
+        #     # passing all the options to field definition:
+        #     field :full_name, analyzer: 'special'
         #   end
         #
         # The `type` is optional and defaults to `string` if not defined:
@@ -138,14 +135,13 @@ module Chewy
         #   # Suppose that a user has posts and each post has ratings
         #   # avg_post_rating is the mean of all ratings
         #   class UsersIndex < Chewy::Index
-        #     define_type User do
-        #       field :posts do
-        #         field :rating
-        #       end
-        #
-        #       agg :avg_rating do
-        #         { avg: { field: 'posts.rating' } }
-        #       end
+        #     index_scope User
+        #     field :posts do
+        #       field :rating
+        #     end
+        #
+        #     agg :avg_rating do
+        #       { avg: { field: 'posts.rating' } }
         #     end
         #   end
         def agg(name, &block)
@@ -157,11 +153,10 @@ module Chewy
         #
         # @example
         #   class CarsIndex < Chewy::Index
-        #     define_type Car do
-        #       template 'model.*', type: 'text', analyzer: 'special'
-        #       field 'model', type: 'object' # here we can put { de: 'Der Mercedes', en: 'Mercedes' }
-        #                                     # and template will be applyed to this field
-        #     end
+        #     index_scope Car
+        #     template 'model.*', type: 'text', analyzer: 'special'
+        #     field 'model', type: 'object' # here we can put { de: 'Der Mercedes', en: 'Mercedes' }
+        #                                   # and template will be applied to this field
         #   end
         #
         # Name for each template is generated with the following
@@ -172,18 +167,18 @@ module Chewy
         #   template 'title.*', mapping_hash # dot in template causes "path_match" using
         #   template /tit.+/, mapping_hash # using "match_pattern": "regexp"
         #   template /title\..+/, mapping_hash # "\." - escaped dot causes "path_match" using
-        #   template /tit.+/, type: 'text', mapping_hash # "match_mapping_type" as the optionsl second argument
+        #   template /tit.+/, type: 'text', mapping_hash # "match_mapping_type" as an optional second argument
         #   template template42: {match: 'hello*', mapping: {type: 'object'}} # or even pass a template as is
         #
-        def template(*args)
-          root.dynamic_template(*args)
+        def template(*args, **options)
+          root.dynamic_template(*args, **options)
         end
         alias_method :dynamic_template, :template
 
         # Returns compiled mappings hash for current type
         #
         def mappings_hash
-          root.mappings_hash[type_name.to_sym].present? ? root.mappings_hash : {}
+          root.mappings_hash
         end
 
         # Check whether the type has outdated_sync_field defined with a simple value.

data/lib/chewy/index/observe/active_record_methods.rb

@@ -0,0 +1,87 @@
+module Chewy
+  class Index
+    module Observe
+      module Helpers
+        def update_proc(index_name, *args, &block)
+          options = args.extract_options!
+          method = args.first
+
+          proc do
+            reference = if index_name.is_a?(Proc)
+              if index_name.arity.zero?
+                instance_exec(&index_name)
+              else
+                index_name.call(self)
+              end
+            else
+              index_name
+            end
+
+            index = Chewy.derive_name(reference)
+
+            next if Chewy.strategy.current.name == :bypass
+
+            backreference = if method && method.to_s == 'self'
+              self
+            elsif method
+              send(method)
+            else
+              instance_eval(&block)
+            end
+
+            index.update_index(backreference, options)
+          end
+        end
+
+        def extract_callback_options!(args)
+          options = args.extract_options!
+          result = options.each_key.with_object({}) do |key, hash|
+            hash[key] = options.delete(key) if %i[if unless].include?(key)
+          end
+          args.push(options) unless options.empty?
+          result
+        end
+      end
+
+      extend Helpers
+
+      module ActiveRecordMethods
+        extend ActiveSupport::Concern
+
+        def run_chewy_callbacks
+          chewy_callbacks.each { |callback| callback.call(self) }
+        end
+
+        def update_chewy_indices
+          Chewy.strategy.current.update_chewy_indices(self)
+        end
+
+        included do
+          class_attribute :chewy_callbacks, default: []
+        end
+
+        class_methods do
+          def initialize_chewy_callbacks
+            if Chewy.use_after_commit_callbacks
+              after_commit :update_chewy_indices, on: %i[create update]
+              after_commit :run_chewy_callbacks, on: :destroy
+            else
+              after_save :update_chewy_indices
+              after_destroy :run_chewy_callbacks
+            end
+          end
+
+          def update_index(type_name, *args, &block)
+            callback_options = Observe.extract_callback_options!(args)
+            update_proc = Observe.update_proc(type_name, *args, &block)
+            callback = Chewy::Index::Observe::Callback.new(update_proc, callback_options)
+
+            initialize_chewy_callbacks if chewy_callbacks.empty?
+
+            self.chewy_callbacks = chewy_callbacks.dup << callback
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/observe/callback.rb

@@ -0,0 +1,34 @@
+module Chewy
+  class Index
+    module Observe
+      class Callback
+        def initialize(executable, filters = {})
+          @executable = executable
+          @if_filter = filters[:if]
+          @unless_filter = filters[:unless]
+        end
+
+        def call(context)
+          return if !@if_filter.nil? && !eval_filter(@if_filter, context)
+          return if !@unless_filter.nil? && eval_filter(@unless_filter, context)
+
+          eval_proc(@executable, context)
+        end
+
+      private
+
+        def eval_filter(filter, context)
+          case filter
+          when Symbol then context.send(filter)
+          when Proc then eval_proc(filter, context)
+          else filter
+          end
+        end
+
+        def eval_proc(executable, context)
+          executable.arity.zero? ? context.instance_exec(&executable) : executable.call(context)
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/observe.rb

@@ -0,0 +1,17 @@
+require 'chewy/index/observe/callback'
+require 'chewy/index/observe/active_record_methods'
+
+module Chewy
+  class Index
+    module Observe
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def update_index(objects, options = {})
+          Chewy.strategy.current.update(self, objects, options)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/specification.rb

@@ -36,6 +36,7 @@ module Chewy
         filter = {ids: {values: [@index.derivable_name]}}
         document = Chewy::Stash::Specification.filter(filter).first
         return {} unless document
+
         JSON.load(Base64.decode64(document.specification)) # rubocop:disable Security/JSONLoad
       end