search-engine-for-typesense 30.1.6.6 → 30.1.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 685951054b6b65954ff6517a08176c8bec124c197980dec5fcfc0ebbd19f6691
-  data.tar.gz: 12e290d5e45325cb031b06f87d158b33300fdc8682d3a417ba7191940e35211e
+  metadata.gz: ed93c9aa019a0f633ad5c7cc47ec08ea303f5e51491cfc3130e677271b000e1f
+  data.tar.gz: 6446746c790fc6b1c0fa084a5ba9bebd555f5e298738f7b8800fd2717257659f
 SHA512:
-  metadata.gz: f7e7e8ab135067d43fd2cffed2dfc0fdeac7f3861c267dc47d5131c2600a7e5adee5b9267d5b326517cfe32c526a0e67d13d614312183c59ff0e496def671990
-  data.tar.gz: dcb0366fa3ddd2dbe03bc50dec6032093761eba588ae2e88116e2b939cbc8f62ea442c0857448b3d69d20cdf7eccc98b0f5d9d1ee2b2d6ce593453539d889b97
+  metadata.gz: 99aa8f0be6a9b43d0de16e402fe22cb60614861c73f26f122f0c155e3d35de33053a7822170c440bb407bcac73d7a5ba42f57ba0eda825a49fa210e369ba7ea3
+  data.tar.gz: a6526cc8752cdc5a8f61c03a55519e5cf18da1ac538e1028a881b8e5a2d147d5c44cb26b3f4fbbb46907589985564baa895166320b3c1eee230d6557f1890976

data/lib/search_engine/base/index_maintenance/lifecycle.rb

@@ -133,22 +133,37 @@ module SearchEngine
             result = nil
             step = SearchEngine::Logging::StepLine.new('Indexing')
             if applied && indexed_inside_apply
-              step.skip('performed during schema apply')
               result = indexed_inside_apply if indexed_inside_apply.is_a?(Hash)
+              if __se_result_status(result) == :ok
+                step.skip('performed during schema apply')
+              else
+                __se_finish_indexation_step(step, result)
+              end
             else
               step.update('indexing')
               step.yield_line!
               result = __se_index_partitions!(into: nil)
-              step.finish('done')
+              __se_finish_indexation_step(step, result)
             end
 
-            cascade_ok = result.is_a?(Hash) ? result[:status] == :ok : false
-            __se_cascade_after_indexation!(context: :full) if cascade_ok
+            __se_cascade_after_indexation!(context: :full) if __se_result_status(result) == :ok
             result
           ensure
             step&.close
           end
 
+          def __se_result_status(result)
+            result.is_a?(Hash) ? result[:status] : :ok
+          end
+
+          def __se_finish_indexation_step(step, result)
+            case __se_result_status(result)
+            when :ok      then step.finish('done')
+            when :partial then step.finish_warn('partial')
+            else               step.finish_warn('failed')
+            end
+          end
+
           def __se_full_retention(applied, logical, client)
             step = SearchEngine::Logging::StepLine.new('Retention')
             if applied

data/lib/search_engine/base/index_maintenance.rb

@@ -270,9 +270,9 @@ module SearchEngine
           if compiled
             parts = Array(compiled.partitions)
             max_p = compiled.max_parallel.to_i
-            return __se_index_partitions_seq!(parts, into) if max_p <= 1 || parts.size <= 1
+            return __se_index_partitions_seq!(parts, into, compiled) if max_p <= 1 || parts.size <= 1
 
-            __se_index_partitions_parallel!(parts, into, max_p)
+            __se_index_partitions_parallel!(parts, into, max_p, compiled)
           else
             summary = SearchEngine::Indexer.rebuild_partition!(self, partition: nil, into: into)
             __se_build_index_result([summary])
@@ -314,10 +314,10 @@ module SearchEngine
 
       class_methods do
         # Sequential processing of partition list with live progress rendering.
-        def __se_index_partitions_seq!(parts, into)
-          estimate = __se_per_partition_estimate(parts.size)
+        def __se_index_partitions_seq!(parts, into, compiled)
+          docs_estimates = __se_per_partition_docs_estimates(parts, compiled)
           renderer = SearchEngine::Logging::LiveRenderer.new(
-            labels: parts.map(&:inspect), partitions: parts, per_partition_estimate: estimate
+            labels: parts.map(&:inspect), partitions: parts, per_partition_docs_estimates: docs_estimates
           )
           renderer.start
 
@@ -351,12 +351,12 @@ module SearchEngine
 
       class_methods do
         # Parallel processing via bounded thread pool with live progress rendering.
-        def __se_index_partitions_parallel!(parts, into, max_p)
+        def __se_index_partitions_parallel!(parts, into, max_p, compiled)
           require 'concurrent-ruby'
 
-          estimate = __se_per_partition_estimate(parts.size)
+          docs_estimates = __se_per_partition_docs_estimates(parts, compiled)
           renderer = SearchEngine::Logging::LiveRenderer.new(
-            labels: parts.map(&:inspect), partitions: parts, per_partition_estimate: estimate
+            labels: parts.map(&:inspect), partitions: parts, per_partition_docs_estimates: docs_estimates
           )
           renderer.start
 
@@ -373,7 +373,15 @@ module SearchEngine
             warn("\n  Interrupted \u2014 stopping parallel partition workers\u2026")
           end
 
-          SearchEngine::InterruptiblePool.run(pool, on_interrupt: on_interrupt) do
+          pool_timeout = begin
+            SearchEngine.config.indexer.pool_timeout
+          rescue StandardError
+            nil
+          end
+
+          pool_status = SearchEngine::InterruptiblePool.run(
+            pool, on_interrupt: on_interrupt, timeout: pool_timeout
+          ) do
             parts.each_with_index do |part, idx|
               break if cancelled.true?
 
@@ -400,6 +408,8 @@ module SearchEngine
             end
           end
 
+          __se_flag_incomplete_slots!(renderer, parts, partition_errors, mtx, pool_timeout) if pool_status == :timed_out
+
           begin
             renderer.stop
           rescue StandardError
@@ -414,11 +424,27 @@ module SearchEngine
       end
 
       class_methods do
-        # Heuristic per-partition batch estimate for progress bars.
+        # Build an array of per-partition doc estimates.
+        # Tries per-partition counting (auto-detected from AR fetch result),
+        # fills any nils with the equal-split heuristic fallback.
+        #
+        # @param parts [Array] partition keys
+        # @param compiled [SearchEngine::Partitioner::Compiled, nil]
+        # @return [Array<Integer, nil>]
+        def __se_per_partition_docs_estimates(parts, compiled)
+          estimates = parts.map { |part| compiled&.partition_doc_count(part) }
+
+          heuristic = __se_heuristic_docs_estimate(parts.size)
+          parts.each_index.map { |i| estimates[i] || heuristic }
+        rescue StandardError
+          Array.new(parts.size, nil)
+        end
+
+        # Equal-split heuristic: total_docs / partition_count.
         # @param partition_count [Integer]
         # @return [Integer, nil]
-        def __se_per_partition_estimate(partition_count)
-          total = SearchEngine::Indexer::BulkImport.estimate_total_batches(self)
+        def __se_heuristic_docs_estimate(partition_count)
+          total = SearchEngine::Indexer::BulkImport.estimate_total_docs(self)
           return nil unless total
 
           (total.to_f / partition_count).ceil
@@ -426,7 +452,33 @@ module SearchEngine
           nil
         end
 
-        private :__se_per_partition_estimate
+        # Flag renderer slots that are still pending/in-progress after the pool
+        # timed out. Marks each as errored and appends to partition_errors so the
+        # caller raises and reports failure.
+        #
+        # @param renderer [SearchEngine::Logging::LiveRenderer]
+        # @param parts [Array] partition keys
+        # @param partition_errors [Array<StandardError>]
+        # @param mtx [Mutex]
+        # @param pool_timeout [Integer, nil] resolved timeout (seconds) from caller
+        # @return [void]
+        def __se_flag_incomplete_slots!(renderer, parts, partition_errors, mtx, pool_timeout)
+          effective_timeout = pool_timeout || SearchEngine::InterruptiblePool::GRACEFUL_TIMEOUT
+
+          parts.each_index do |idx|
+            slot = renderer[idx]
+            next if %i[done error].include?(slot.state)
+
+            error = SearchEngine::Errors::PartitionTimeout.new(
+              "partition #{parts[idx].inspect} was not processed — " \
+              "parallel pool timed out after #{effective_timeout}s"
+            )
+            slot.finish_error(error)
+            mtx.synchronize { partition_errors << error }
+          end
+        end
+
+        private :__se_per_partition_docs_estimates, :__se_heuristic_docs_estimate, :__se_flag_incomplete_slots!
       end
 
       class_methods do

data/lib/search_engine/config.rb

@@ -105,6 +105,9 @@ module SearchEngine
       attr_accessor :queue_name
       # @return [Boolean] whether to run model.count for progress bar estimates (default true)
       attr_accessor :estimate_progress
+      # @return [Integer, nil] graceful-shutdown timeout (seconds) for the parallel
+      #   partition pool. When nil, falls back to InterruptiblePool::GRACEFUL_TIMEOUT (3600s).
+      attr_accessor :pool_timeout
 
       def initialize
         @batch_size = 2000
@@ -114,6 +117,7 @@ module SearchEngine
         @dispatch = active_job_available? ? :active_job : :inline
         @queue_name = 'search_index'
         @estimate_progress = true
+        @pool_timeout = nil
       end
 
       private

data/lib/search_engine/errors.rb

@@ -120,6 +120,13 @@ module SearchEngine
     # the underlying HTTP client used by the official Typesense gem.
     class Timeout < Error; end
 
+    # Raised when one or more partitions were not processed because the
+    # parallel pool's graceful-shutdown timeout was exceeded.
+    #
+    # The pool kills remaining queued/running tasks after the timeout,
+    # leaving those partitions unindexed.
+    class PartitionTimeout < Error; end
+
     # Raised for network-level connectivity issues prior to receiving a response.
     #
     # Examples: DNS resolution failures, refused TCP connections, TLS handshake

data/lib/search_engine/indexer/bulk_import.rb

@@ -72,7 +72,7 @@ module SearchEngine
           failed_total = 0
           failed_batches_total = 0
           batches_total = 0
-          # Capture start time before processing any batches to measure total wall-clock duration
+          source_batches_done = 0
           started_at = monotonic_ms
 
           docs_enum.each do |raw_batch|
@@ -95,11 +95,13 @@ module SearchEngine
               batches << stats
               validate_soft_batch_size!(batch_size, stats[:docs_count])
               log_batch(stats, batches_total) if log_batches
-              on_batch&.call(
-                batches_done: batches_total, docs_total: docs_total,
-                success_total: success_total, failed_total: failed_total
-              )
             end
+
+            source_batches_done += 1
+            on_batch&.call(
+              batches_done: source_batches_done, docs_total: docs_total,
+              success_total: success_total, failed_total: failed_total
+            )
           end
 
           # Calculate total duration as wall-clock time from start to finish (not sum of batch durations)
@@ -195,6 +197,7 @@ module SearchEngine
             failed_total: 0,
             failed_batches_total: 0,
             batches_total: 0,
+            source_batches_done: 0,
             idx_counter: -1,
             started_at: monotonic_ms,
             mtx: Mutex.new,
@@ -314,12 +317,11 @@ module SearchEngine
         # @return [void]
         def process_single_batch_parallel(raw_batch:, into:, action:, retry_policy:, batch_size:, log_batches:,
                                           shared_state:)
-          # Each thread gets its own resources
           thread_client = SearchEngine.client
           thread_buffer = +''
           thread_idx = shared_state[:mtx].synchronize { shared_state[:idx_counter] += 1 }
 
-          snapshots = begin
+          snapshot = begin
             stats_list = import_batch_with_handling(
               client: thread_client,
               collection: into,
@@ -332,6 +334,8 @@ module SearchEngine
 
             shared_state[:mtx].synchronize do
               aggregate_stats(stats_list, shared_state, batch_size, log_batches)
+              shared_state[:source_batches_done] += 1
+              progress_snapshot(shared_state)
             end
           rescue StandardError => error
             docs_count = begin
@@ -346,27 +350,26 @@ module SearchEngine
               err_msg = "  batch_index=#{thread_idx} → error=#{error.class}: #{error.message.to_s[0, 200]}"
               warn(SearchEngine::Logging::Color.apply(err_msg, :red))
               aggregate_stats([failure_stat], shared_state, batch_size, log_batches)
+              shared_state[:source_batches_done] += 1
+              progress_snapshot(shared_state)
             end
           end
 
-          on_batch = shared_state[:on_batch]
-          snapshots&.each { |snap| on_batch&.call(**snap) }
+          shared_state[:on_batch]&.call(**snapshot) if snapshot
         end
 
         # Aggregate batch statistics thread-safely into shared state.
         #
         # Must be called within a mutex synchronization block. Updates counters,
         # appends to batches array, validates batch size, and optionally logs.
-        # Returns counter snapshots (one per stats entry) for firing callbacks
-        # outside the lock.
         #
         # @param stats_list [Array<Hash>] array of stats hashes from batch processing
         # @param shared_state [Hash] shared state hash to update (must be mutex-protected)
         # @param batch_size [Integer, nil] soft guard for logging when exceeded
         # @param log_batches [Boolean] whether to log each batch as it completes
-        # @return [Array<Hash>] counter snapshots suitable for on_batch callbacks
+        # @return [void]
         def aggregate_stats(stats_list, shared_state, batch_size, log_batches)
-          stats_list.map do |stats|
+          stats_list.each do |stats|
             shared_state[:docs_total] += stats[:docs_count].to_i
             shared_state[:success_total] += stats[:success_count].to_i
             shared_state[:failed_total] += stats[:failure_count].to_i
@@ -375,13 +378,23 @@ module SearchEngine
             shared_state[:batches] << stats
             validate_soft_batch_size!(batch_size, stats[:docs_count])
             log_batch(stats, shared_state[:batches_total]) if log_batches
-            {
-              batches_done: shared_state[:batches_total], docs_total: shared_state[:docs_total],
-              success_total: shared_state[:success_total], failed_total: shared_state[:failed_total]
-            }
           end
         end
 
+        # Build a progress snapshot from shared state for the on_batch callback.
+        # Must be called within a mutex synchronization block.
+        #
+        # @param shared_state [Hash] shared state hash (must be mutex-protected)
+        # @return [Hash] progress counters keyed by :batches_done, :docs_total, etc.
+        def progress_snapshot(shared_state)
+          {
+            batches_done: shared_state[:source_batches_done],
+            docs_total: shared_state[:docs_total],
+            success_total: shared_state[:success_total],
+            failed_total: shared_state[:failed_total]
+          }
+        end
+
         # Build a Summary object from aggregated shared state.
         #
         # Calculates total duration and constructs a Summary with all aggregated
@@ -426,14 +439,14 @@ module SearchEngine
           enum.is_a?(Enumerator) ? enum : enum.each
         end
 
-        # Estimate total batch count for progress logging.
+        # Estimate total source record count for the given model class.
         #
-        # Attempts to estimate batch count for ActiveRecord sources by counting records
-        # and dividing by batch_size. Returns nil for other source types or when estimation fails.
+        # Shared foundation for batch and doc estimates. Performs a model.count
+        # with a soft timeout to avoid blocking on slow tables.
         #
         # @param klass [Class] a {SearchEngine::Base} subclass
-        # @return [Integer, nil] estimated total batch count or nil if not estimable
-        def estimate_total_batches(klass)
+        # @return [Integer, nil] record count or nil if not estimable
+        def estimate_source_record_count(klass)
           return nil if SearchEngine.config.indexer.estimate_progress == false
           return nil unless klass.is_a?(Class)
 
@@ -447,22 +460,39 @@ module SearchEngine
           model = source_def.dig(:options, :model)
           return nil unless model.respond_to?(:count)
 
-          batch_size = source_def.dig(:options, :batch_size)
-          batch_size ||= SearchEngine.config.sources.active_record.batch_size
-          batch_size = batch_size.to_i
-          return nil unless batch_size.positive?
+          count_with_timeout(model, 10)
+        rescue StandardError
+          nil
+        end
 
-          begin
-            total_records = count_with_timeout(model, 10)
-            return nil unless total_records&.positive?
+        # Estimate total batch count for progress logging.
+        #
+        # @param klass [Class] a {SearchEngine::Base} subclass
+        # @return [Integer, nil] estimated total batch count or nil if not estimable
+        def estimate_total_batches(klass)
+          total_records = estimate_source_record_count(klass)
+          return nil unless total_records&.positive?
 
-            (total_records.to_f / batch_size).ceil
-          rescue StandardError
-            nil
-          end
+          batch_size = batch_size_for_klass(klass)
+          return nil unless batch_size&.positive?
+
+          (total_records.to_f / batch_size).ceil
+        rescue StandardError
+          nil
         end
 
-        public :estimate_total_batches
+        # Estimate total document count for doc-based progress tracking.
+        #
+        # @param klass [Class] a {SearchEngine::Base} subclass
+        # @return [Integer, nil] estimated total docs or nil if not estimable
+        def estimate_total_docs(klass)
+          count = estimate_source_record_count(klass)
+          count&.positive? ? count : nil
+        rescue StandardError
+          nil
+        end
+
+        public :estimate_total_batches, :estimate_total_docs
 
         # Thread-based soft timeout for model.count, avoiding Timeout.timeout
         # which can corrupt ActiveRecord connection state.
@@ -497,6 +527,14 @@ module SearchEngine
           klass.instance_variable_get(:@__mapper_dsl__)
         end
 
+        def batch_size_for_klass(klass)
+          dsl = mapper_dsl_for_klass(klass)
+          source_def = dsl&.dig(:source)
+          batch_size = source_def&.dig(:options, :batch_size)
+          batch_size ||= SearchEngine.config.sources.active_record.batch_size
+          batch_size.to_i
+        end
+
         # Import a single batch with error handling and recursive 413 splitting.
         #
         # Public wrapper that delegates to the internal method with batch_index set to nil,

data/lib/search_engine/interruptible_pool.rb

@@ -11,19 +11,28 @@ module SearchEngine
 
     # Execute a block that posts work to a thread pool, then wait for completion.
     #
-    # Normal path: graceful shutdown → long wait.
+    # Normal path: graceful shutdown → long wait → :ok.
+    # Timeout:     graceful wait expires → pool.kill → :timed_out.
     # Interrupt:   on_interrupt callback → pool.kill → short wait → re-raise.
     # Other error: ensure kill → short wait.
     #
     # @param pool [Concurrent::FixedThreadPool]
     # @param on_interrupt [Proc, nil] callback invoked before killing the pool
+    # @param timeout [Integer, nil] override for graceful-shutdown timeout (seconds);
+    #   defaults to {GRACEFUL_TIMEOUT} when nil
     # @yield block that posts work to the pool
-    # @return [void]
-    def self.run(pool, on_interrupt: nil)
+    # @return [Symbol] :ok on clean completion, :timed_out when the graceful timeout was exceeded
+    def self.run(pool, on_interrupt: nil, timeout: nil)
       yield
       pool.shutdown
-      pool.wait_for_termination(GRACEFUL_TIMEOUT) || pool.kill
-      pool.wait_for_termination(CLEANUP_TIMEOUT)
+      effective_timeout = timeout || GRACEFUL_TIMEOUT
+      completed = pool.wait_for_termination(effective_timeout)
+      unless completed
+        pool.kill
+        pool.wait_for_termination(CLEANUP_TIMEOUT)
+        return :timed_out
+      end
+      :ok
     rescue Interrupt
       on_interrupt&.call
       pool.kill

data/lib/search_engine/logging/live_renderer.rb

@@ -16,7 +16,7 @@ module SearchEngine
     # using {PartitionProgress.line}, preserving CI/pipe compatibility.
     #
     # @example
-    #   renderer = LiveRenderer.new(labels: parts.map(&:inspect), per_partition_estimate: 50)
+    #   renderer = LiveRenderer.new(labels: parts.map(&:inspect), per_partition_docs_estimate: 5000)
     #   renderer.start
     #   parts.each_with_index do |part, i|
     #     renderer[i].start
@@ -34,9 +34,12 @@ module SearchEngine
 
       # @param labels [Array<String>] display label for each slot (partition key)
       # @param partitions [Array, nil] raw partition values for non-TTY output (defaults to labels)
-      # @param per_partition_estimate [Integer, nil] estimated batches per partition (for progress bars)
+      # @param per_partition_docs_estimates [Array<Integer, nil>, nil] per-slot doc estimates (takes priority)
+      # @param per_partition_docs_estimate [Integer, nil] uniform doc estimate for all slots (fallback)
+      # @param per_partition_estimate [Integer, nil] deprecated batch-based estimate (last resort fallback)
       # @param io [IO] output stream (defaults to $stdout)
-      def initialize(labels:, partitions: nil, per_partition_estimate: nil, io: $stdout)
+      def initialize(labels:, partitions: nil, per_partition_docs_estimates: nil,
+                     per_partition_docs_estimate: nil, per_partition_estimate: nil, io: $stdout)
         @io = io
         @tty = Color.enabled?
         @mutex = Mutex.new
@@ -46,8 +49,13 @@ module SearchEngine
         @rendered_once = false
         nontty_cb = @tty ? nil : method(:flush_nontty_slot)
         raw = partitions || labels
+        per_slot = per_partition_docs_estimates || []
+        global_est = per_partition_docs_estimate || per_partition_estimate
         @slots = labels.each_with_index.map do |label, idx|
-          Slot.new(label: label, partition: raw[idx], estimate: per_partition_estimate, on_done: nontty_cb)
+          Slot.new(
+            label: label, partition: raw[idx], docs_estimate: per_slot[idx] || global_est,
+            on_done: nontty_cb
+          )
         end
         @viewport = resolve_viewport
       end
@@ -238,12 +246,12 @@ module SearchEngine
 
         # @param label [String] partition display label (e.g. partition key inspect)
         # @param partition [Object, nil] raw partition value for non-TTY output (defaults to label)
-        # @param estimate [Integer, nil] estimated total batches for progress bar
+        # @param docs_estimate [Integer, nil] estimated total docs for doc-based progress bar
         # @param on_done [Proc, nil] callback invoked after finish/finish_error (non-TTY flush)
-        def initialize(label:, partition: nil, estimate: nil, on_done: nil)
+        def initialize(label:, partition: nil, docs_estimate: nil, on_done: nil)
           @label = label
           @partition = partition.nil? ? label : partition
-          @estimate = estimate
+          @docs_estimate = docs_estimate
           @on_done = on_done
           @state = :pending
           @batches_done = 0
@@ -387,15 +395,16 @@ module SearchEngine
         end
 
         def build_progress_part
-          if @estimate&.positive? && @batches_done.positive?
-            ratio = @batches_done.to_f / @estimate
+          if @docs_estimate&.positive? && @docs_total.positive?
+            ratio = @docs_total.to_f / @docs_estimate
             pct = [100, (ratio * 100).round].min
             filled = [(ratio * BAR_WIDTH).round, BAR_WIDTH].min
             empty = BAR_WIDTH - filled
             bar = "\u2588" * filled + "\u2591" * empty
-            "#{bar}  #{pct}%  #{@batches_done}/#{@estimate} batches  (#{@docs_total} docs)"
+            batch_info = @batches_done.positive? ? "#{@batches_done} batches  " : ''
+            "#{bar}  #{pct}%  #{batch_info}(#{@docs_total}/#{@docs_estimate} docs)"
           elsif @batches_done.positive?
-            "#{@batches_done} batches, #{@docs_total} docs"
+            "#{@batches_done} batches  (#{@docs_total} docs)"
           else
             ''
           end

data/lib/search_engine/partitioner.rb

@@ -76,8 +76,50 @@ module SearchEngine
         end
       end
 
+      # Auto-detect doc count for a partition from the partition_fetch result.
+      # Counts the same scope that partition_fetch will enumerate — single source of truth.
+      #
+      # @param partition [Object] partition key
+      # @return [Integer, nil] doc count or nil when unavailable
+      def partition_doc_count(partition)
+        count = auto_count_from_fetch(partition)
+        count.is_a?(Integer) && count.positive? ? count : nil
+      rescue StandardError
+        nil
+      end
+
       private
 
+      # Call partition_fetch_proc and try to extract a countable relation.
+      # Calling the proc only builds a lazy AR object — no batch queries fire.
+      # The single COUNT query is the only DB cost.
+      def auto_count_from_fetch(partition)
+        return nil unless @partition_fetch_proc
+
+        result = @partition_fetch_proc.call(partition)
+        extract_count(result)
+      rescue StandardError
+        nil
+      end
+
+      def extract_count(result)
+        relation = countable_relation_from(result)
+        relation&.count
+      rescue StandardError
+        nil
+      end
+
+      def countable_relation_from(result)
+        if defined?(ActiveRecord::Batches::BatchEnumerator) &&
+           result.is_a?(ActiveRecord::Batches::BatchEnumerator)
+          return result.instance_variable_get(:@relation)
+        end
+
+        return result if defined?(ActiveRecord::Relation) && result.is_a?(ActiveRecord::Relation)
+
+        nil
+      end
+
       def validate_hook_arity!(proc_obj, name:)
         ar = proc_obj.arity
         return if ar == 1 || ar.negative?

data/lib/search_engine/version.rb

@@ -3,5 +3,5 @@
 module SearchEngine
   # Current gem version.
   # @return [String]
-  VERSION = '30.1.6.6'
+  VERSION = '30.1.6.8'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: search-engine-for-typesense
 version: !ruby/object:Gem::Version
-  version: 30.1.6.6
+  version: 30.1.6.8
 platform: ruby
 authors:
 - Nikita Shkoda