search-engine-for-typesense 30.1.4 → 30.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fb677abb16142281c9c9171d6fba238aac168da395019672cd085818b72e726
-  data.tar.gz: 770426cb9622b18ca1bd90acef3957ac969dc89a6e781f4603599ec005494662
+  metadata.gz: ae511da617970ab104c22bde9c151ed099d9eb9c55909d9bc34f328ea56ac5f4
+  data.tar.gz: 49d4de291b6239a7f70e6bd93de83ef175916d7c403029d7a7382189fe90b9d7
 SHA512:
-  metadata.gz: fcb4690a5bedcfa92815e1157b142b107abc82fba535ed9566902b569210dac401ed3e496983af48d18747a0ce6f5452182a1cddc7611fb1004af43d7ab2117a
-  data.tar.gz: 616bd994b94675ed4be2c554b55aef5842bae91ca38e9afd16106ff282602836d98aea60e19a8beec3c864e1e5381b10da521a2ceb6f4b8184f25f50845d71b2
+  metadata.gz: ba3c5e26e351975c5c967954b3f20e0fe14f438aab7126672c1b9ad42ec1bbc15c224f5412a5d0cd778e237451af23a8a4e237731ab2c9bc2e2dabb3650256e9
+  data.tar.gz: 82766d2a92e2f2a3a81f430d066254ff83b14966a3cce4b7171102979c07e0fe53925e2aa118075b6c679f8dd0881364d5c5d681c4c56e9c819b6ecb5aceaea1

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

@@ -13,19 +13,20 @@ module SearchEngine
           # @param client [SearchEngine::Client, nil]
           # @param pre [Symbol, nil] :ensure (ensure presence) or :index (ensure + fix drift)
           # @param force_rebuild [Boolean] when true, force schema rebuild (blue/green)
-          # @return [void]
+          # @return [Hash, nil] result hash with :status, :docs_total, :success_total, :failed_total, :sample_error
           def index_collection(partition: nil, client: nil, pre: nil, force_rebuild: false)
             logical = respond_to?(:collection) ? collection.to_s : name.to_s
             puts
             puts(%(>>>>>> Indexing Collection "#{logical}"))
             client_obj = client || SearchEngine.client
 
-            if partition.nil?
-              __se_index_full(client: client_obj, pre: pre, force_rebuild: force_rebuild)
-            else
-              __se_index_partial(partition: partition, client: client_obj, pre: pre)
-            end
-            nil
+            result = if partition.nil?
+                       __se_index_full(client: client_obj, pre: pre, force_rebuild: force_rebuild)
+                     else
+                       __se_index_partial(partition: partition, client: client_obj, pre: pre)
+                     end
+
+            result.is_a?(Hash) ? result.merge(collection: logical) : { collection: logical, status: :ok }
           end
 
           def reindex_collection!(pre: nil)
@@ -66,8 +67,9 @@ module SearchEngine
               indexed_inside_apply,
               force_rebuild
             )
-            __se_full_indexation(applied, indexed_inside_apply)
+            result = __se_full_indexation(applied, indexed_inside_apply)
             __se_full_retention(applied, logical, client)
+            result
           end
 
           def __se_full_apply_if_missing(client, missing)
@@ -116,21 +118,19 @@ module SearchEngine
           end
 
           def __se_full_indexation(applied, indexed_inside_apply)
-            cascade_ok = false
+            result = nil
             if applied && indexed_inside_apply
               puts('Step 5: Indexing — skip (performed during schema apply)')
-              begin
-                cascade_ok = indexed_inside_apply.to_sym == :ok
-              rescue StandardError
-                cascade_ok = false
-              end
+              result = indexed_inside_apply if indexed_inside_apply.is_a?(Hash)
             else
               puts('Step 5: Indexing — processing')
-              idx_status = __se_index_partitions!(into: nil)
+              result = __se_index_partitions!(into: nil)
               puts('Step 5: Indexing — done')
-              cascade_ok = (idx_status == :ok)
             end
+
+            cascade_ok = result.is_a?(Hash) ? result[:status] == :ok : false
             __se_cascade_after_indexation!(context: :full) if cascade_ok
+            result
           end
 
           def __se_full_retention(applied, logical, client)
@@ -152,32 +152,33 @@ module SearchEngine
             puts("Step 1: Presence — processing → #{missing ? 'missing' : 'present'}")
             if missing
               puts('Partial: collection is not present. Quit early.')
-              return
+              return { status: :failed, docs_total: 0, success_total: 0, failed_total: 0,
+                       sample_error: 'Collection not present' }
             end
 
             puts('Step 2: Check Schema Status — processing')
             drift = __se_schema_drift?(diff)
             if drift
               puts('Partial: schema is not up-to-date. Exit early (run full indexing).')
-              return
+              return { status: :failed, docs_total: 0, success_total: 0, failed_total: 0,
+                       sample_error: 'Schema drift detected' }
             end
             puts('Step 2: Check Schema Status — in_sync')
 
             __se_preflight_dependencies!(mode: pre, client: client) if pre
 
             puts('Step 3: Partial Indexing — processing')
-            all_ok = true
+            summaries = []
             partitions.each do |p|
               summary = SearchEngine::Indexer.rebuild_partition!(self, partition: p, into: nil)
+              summaries << summary
               puts(SearchEngine::Logging::PartitionProgress.line(p, summary))
-              begin
-                all_ok &&= (summary.status == :ok)
-              rescue StandardError
-                all_ok &&= false
-              end
             end
             puts('Step 3: Partial Indexing — done')
-            __se_cascade_after_indexation!(context: :full) if all_ok
+
+            result = __se_build_index_result(summaries)
+            __se_cascade_after_indexation!(context: :full) if result[:status] == :ok
+            result
           end
 
           # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize

data/lib/search_engine/base/index_maintenance.rb

@@ -320,32 +320,51 @@ module SearchEngine
             __se_index_partitions_parallel!(parts, into, max_p)
           else
             summary = SearchEngine::Indexer.rebuild_partition!(self, partition: nil, into: into)
-            summary.status
+            __se_build_index_result([summary])
           end
         end
+
+        # Aggregate an array of Indexer::Summary structs into a single result hash.
+        # @param summaries [Array<SearchEngine::Indexer::Summary>]
+        # @return [Hash] { status:, docs_total:, success_total:, failed_total:, sample_error: }
+        def __se_build_index_result(summaries)
+          docs = 0
+          success = 0
+          failed = 0
+          sample_error = nil
+
+          Array(summaries).each do |s|
+            docs += s.docs_total.to_i
+            success += s.success_total.to_i
+            failed += s.failed_total.to_i
+            sample_error ||= __se_extract_sample_error(s)
+          end
+
+          status = if failed.positive? && success.zero?
+                     :failed
+                   elsif failed.positive?
+                     :partial
+                   else
+                     :ok
+                   end
+
+          { status: status, docs_total: docs, success_total: success, failed_total: failed, sample_error: sample_error }
+        end
+
+        private :__se_build_index_result
       end
 
       class_methods do
         # Sequential processing of partition list
         def __se_index_partitions_seq!(parts, into)
-          agg = :ok
+          summaries = []
           parts.each do |part|
             summary = SearchEngine::Indexer.rebuild_partition!(self, partition: part, into: into)
+            summaries << summary
             puts(SearchEngine::Logging::PartitionProgress.line(part, summary))
-            # Log batches individually if there are multiple batches
             __se_log_batches_from_summary(summary.batches) if summary.batches_total.to_i > 1
-            begin
-              st = summary.status
-              if st == :failed
-                agg = :failed
-              elsif st == :partial && agg == :ok
-                agg = :partial
-              end
-            rescue StandardError
-              agg = :failed
-            end
           end
-          agg
+          __se_build_index_result(summaries)
         end
       end
 
@@ -356,42 +375,37 @@ module SearchEngine
           pool = Concurrent::FixedThreadPool.new(max_p)
           ctx = SearchEngine::Instrumentation.context
           mtx = Mutex.new
-          agg = :ok
+          summaries = []
+          partition_errors = []
           begin
             parts.each do |part|
               pool.post do
                 SearchEngine::Instrumentation.with_context(ctx) do
                   summary = SearchEngine::Indexer.rebuild_partition!(self, partition: part, into: into)
                   mtx.synchronize do
+                    summaries << summary
                     puts(SearchEngine::Logging::PartitionProgress.line(part, summary))
-                    # Log batches individually if there are multiple batches
                     __se_log_batches_from_summary(summary.batches) if summary.batches_total.to_i > 1
-                    begin
-                      st = summary.status
-                      if st == :failed
-                        agg = :failed
-                      elsif st == :partial && agg == :ok
-                        agg = :partial
-                      end
-                    rescue StandardError
-                      agg = :failed
-                    end
                   end
                 end
               rescue StandardError => error
                 mtx.synchronize do
                   warn("  partition=#{part.inspect} → error=#{error.class}: #{error.message.to_s[0, 200]}")
-                  agg = :failed
+                  partition_errors << "#{error.class}: #{error.message.to_s[0, 200]}"
                 end
               end
             end
           ensure
             pool.shutdown
-            # Wait up to 1 hour, then force-kill and wait a bit more to ensure cleanup
             pool.wait_for_termination(3600) || pool.kill
             pool.wait_for_termination(60)
           end
-          agg
+          result = __se_build_index_result(summaries)
+          if partition_errors.any?
+            result[:status] = :failed
+            result[:sample_error] ||= partition_errors.first
+          end
+          result
         end
       end
 

data/lib/search_engine/bulk.rb

@@ -107,50 +107,60 @@ module SearchEngine
           cascade_count: cascade_order.size
         }
 
+        collection_results = []
         failed_collections_total = 0
 
         SearchEngine::Instrumentation.with_context(bulk: true, bulk_suppress_cascade: true, bulk_mode: mode.to_sym) do
           SearchEngine::Instrumentation.instrument('search_engine.bulk.run', payload.merge(stats)) do |ctx|
-            # Stage 1 — process referenced-first inputs (that are not referrers of other inputs)
-            stage1_list.each do |name|
-              klass = safe_collection_class(name)
-              unless klass
-                failed_collections_total += 1
-                next
-              end
-
-              case mode.to_sym
-              when :index
-                klass.index_collection
-              else
-                klass.reindex_collection!
-              end
-            end
-
-            # Stage 2 — process collected referencers once
-            cascade_order.each do |name|
-              klass = safe_collection_class(name)
-              unless klass
-                failed_collections_total += 1
-                next
-              end
-
-              case mode.to_sym
-              when :index
-                klass.index_collection(pre: :ensure, force_rebuild: true)
-              else
-                klass.reindex_collection!
-              end
-            end
+            run_stage!(mode, stage1_list, :input, collection_results)
+            run_stage!(mode, cascade_order, :cascade, collection_results)
 
+            failed_collections_total = collection_results.count { |r| r[:status] != :ok }
             ctx[:failed_collections_total] = failed_collections_total
           end
         end
 
         payload[:failed_collections_total] = failed_collections_total
+        payload[:collection_results] = collection_results
         payload.merge(stats)
       end
 
+      def run_stage!(mode, names, stage, collection_results)
+        names.each do |name|
+          klass = safe_collection_class(name)
+          unless klass
+            collection_results << unresolved_result(name, stage)
+            next
+          end
+
+          result = run_single_collection(mode, klass, stage)
+          collection_results << normalize_collection_result(result, name, stage)
+        end
+      end
+
+      def run_single_collection(mode, klass, stage)
+        case mode.to_sym
+        when :index
+          stage == :cascade ? klass.index_collection(pre: :ensure, force_rebuild: true) : klass.index_collection
+        else
+          klass.reindex_collection!
+        end
+      end
+
+      def unresolved_result(name, stage)
+        { collection: name, stage: stage, status: :failed,
+          docs_total: 0, success_total: 0, failed_total: 0,
+          sample_error: 'Unresolved collection class' }
+      end
+
+      def normalize_collection_result(result, name, stage)
+        if result.is_a?(Hash)
+          result.merge(stage: stage)
+        else
+          { collection: name, stage: stage, status: :ok }
+        end
+      end
+
       # Normalize inputs to logical collection names.
       # @param list [Array<Symbol, String, Class>]
       # @return [Array<String>]

data/lib/search_engine/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: search-engine-for-typesense
 version: !ruby/object:Gem::Version
-  version: 30.1.4
+  version: 30.1.5
 platform: ruby
 authors:
 - Nikita Shkoda
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-08 00:00:00.000000000 Z
+date: 2026-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby