search-engine-for-typesense 30.1.6.11 → 30.1.6.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f539715e56d25adec8340f5ef92aa4897e8494e5dd1d17a19e9e974a440d8b9
-  data.tar.gz: 8e15d07dfd0ac820a934ef8d53b7a36c3cd86c24b1c248fd2ef1922e8f8b9622
+  metadata.gz: 4596b142a6080ea8f9941f94611f32e9c461b3e9be51bb8e024e821c68ccd498
+  data.tar.gz: 0ea309bf811b27491de030021053c888d3c4fae0047292432a7f89a46f4ad722
 SHA512:
-  metadata.gz: a9b03abc402eec4c55a781ad6f9dae88f7c1c3ffc6fd64ca5b6fba1be34202c394aceb62dc1ed9734b31bc3f9f2bdf55294a97c3c9c9db6a9440f5ba31fad28b
-  data.tar.gz: cd8c090303502de20f4d6f0852f0c769540c2cedd0ee3b6423eb6afa44bdbd5bcf2c472a610935d7114153a8cada8e80763efab0813c86e90833470034c2c7f3
+  metadata.gz: 3deec81bb58a05b8582c7081aa345cb4b1cc16b270d576ba22a0d03316590f1fdecbd885a7e5ed35842f909a3e0c278c77dce03232b81ec5091f33771fb5ec09
+  data.tar.gz: 5577de682690a81acb90e23563b5e7cdd26bfc4b90efe7c28b7d8bbe6224e5c804820829d2a7b9d5020e8941e6b022f5587c76675e5c871f6a660a4183cd23bc

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

@@ -218,11 +218,29 @@ module SearchEngine
             step = SearchEngine::Logging::StepLine.new('Partial Indexing')
             step.update('indexing')
             step.yield_line!
+
+            renderer = SearchEngine::Logging::LiveRenderer.new(
+              labels: partitions.map(&:inspect), partitions: partitions
+            )
+            renderer.start
             summaries = []
-            partitions.each do |p|
-              summary = SearchEngine::Indexer.rebuild_partition!(self, partition: p, into: nil)
-              summaries << summary
-              puts(SearchEngine::Logging::PartitionProgress.line(p, summary))
+            partitions.each_with_index do |p, idx|
+              slot = renderer[idx]
+              slot.start
+              begin
+                on_batch = ->(info) { slot.progress(**info) }
+                summary = SearchEngine::Indexer.rebuild_partition!(self, partition: p, into: nil, on_batch: on_batch)
+                slot.finish(summary)
+                summaries << summary
+              rescue StandardError => error
+                slot.finish_error(error)
+                raise
+              end
+            end
+            begin
+              renderer.stop
+            rescue StandardError
+              nil
             end
             step.finish('done')
 
@@ -230,6 +248,7 @@ module SearchEngine
             __se_cascade_after_indexation!(context: :full) if result[:status] == :ok
             result
           ensure
+            renderer&.stop
             step&.close
           end
 

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

@@ -46,46 +46,76 @@ module SearchEngine
             logical = respond_to?(:collection) ? collection.to_s : name.to_s
 
             alias_target = client.resolve_alias(logical, timeout_ms: 10_000)
-            physical = if alias_target && !alias_target.to_s.strip.empty?
-                         alias_target.to_s
-                       else
-                         live = client.retrieve_collection_schema(logical, timeout_ms: 10_000)
-                         live ? logical : nil
-                       end
+            has_alias = alias_target && !alias_target.to_s.strip.empty?
+
+            physicals = __se_list_all_physicals(logical, client)
+            bare_schema = client.retrieve_collection_schema(logical, timeout_ms: 10_000)
 
             step = SearchEngine::Logging::StepLine.new('Drop Collection')
-            if physical.nil?
+            if !has_alias && physicals.empty? && bare_schema.nil?
               step.skip('not present')
               return
             end
 
             puts
             puts(SearchEngine::Logging::Color.header(%(>>>>>> Dropping Collection "#{logical}")))
-            step.update("dropping (logical=#{logical} physical=#{physical})")
-            client.delete_collection(physical, timeout_ms: 60_000)
-            step.finish('done')
+
+            physicals.each do |name|
+              step.update("dropping physical #{name}")
+              client.delete_collection(name, timeout_ms: 60_000)
+            end
+
+            if bare_schema && !physicals.include?(logical)
+              step.update("dropping bare collection #{logical}")
+              client.delete_collection(logical, timeout_ms: 60_000)
+            end
+
+            if has_alias
+              step.update("deleting alias #{logical}")
+              client.delete_alias(logical)
+            end
+
+            step.finish("done (physicals=#{physicals.size})")
             puts(SearchEngine::Logging::Color.header(%(>>>>>> Dropped Collection "#{logical}")))
             nil
           ensure
             step&.close
           end
 
+          # @return [Array<String>] physical collection names matching the logical pattern
+          def __se_list_all_physicals(logical, client)
+            meta_timeout = begin
+              t = SearchEngine.config.timeout_ms.to_i
+              [t, 10_000].max
+            rescue StandardError
+              10_000
+            end
+
+            all_collections = Array(client.list_collections(timeout_ms: meta_timeout))
+            names = all_collections.map { |c| (c[:name] || c['name']).to_s }
+            re = /\A#{Regexp.escape(logical)}_\d{8}_\d{6}_\d{3}\z/
+            names.select { |n| re.match?(n) }
+          rescue StandardError
+            []
+          end
+
+          private :__se_list_all_physicals
+
           def recreate_collection!
             client = SearchEngine.client
             logical = respond_to?(:collection) ? collection.to_s : name.to_s
 
             alias_target = client.resolve_alias(logical)
-            physical = if alias_target && !alias_target.to_s.strip.empty?
-                         alias_target.to_s
-                       else
-                         live = client.retrieve_collection_schema(logical)
-                         live ? logical : nil
-                       end
+            has_alias = alias_target && !alias_target.to_s.strip.empty?
+            physicals = __se_list_all_physicals(logical, client)
+            bare_schema = client.retrieve_collection_schema(logical)
 
             step = SearchEngine::Logging::StepLine.new('Recreate Collection')
-            if physical
-              step.update("dropping existing (logical=#{logical} physical=#{physical})")
-              client.delete_collection(physical)
+            if has_alias || physicals.any? || bare_schema
+              step.update("dropping existing (logical=#{logical})")
+              physicals.each { |name| client.delete_collection(name) }
+              client.delete_collection(logical) if bare_schema && !physicals.include?(logical)
+              client.delete_alias(logical) if has_alias
             else
               step.update("creating (logical=#{logical})")
             end

data/lib/search_engine/base/index_maintenance.rb

@@ -274,14 +274,45 @@ module SearchEngine
 
             __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])
+            __se_index_single_with_renderer!(into)
           end
         rescue StandardError => error
           { status: :failed, docs_total: 0, success_total: 0, failed_total: 0,
             sample_error: "#{error.class}: #{error.message.to_s[0, 200]}" }
         end
 
+        def __se_index_single_with_renderer!(into)
+          docs_estimate = __se_heuristic_docs_estimate(1)
+          renderer = SearchEngine::Logging::LiveRenderer.new(
+            labels: ['single'], partitions: [nil],
+            per_partition_docs_estimates: [docs_estimate]
+          )
+          renderer.start
+
+          summary = nil
+          slot = renderer[0]
+          slot.start
+          begin
+            on_batch = ->(info) { slot.progress(**info) }
+            summary = SearchEngine::Indexer.rebuild_partition!(self, partition: nil, into: into, on_batch: on_batch)
+            slot.finish(summary)
+          rescue StandardError => error
+            slot.finish_error(error)
+            raise
+          end
+
+          begin
+            renderer.stop
+          rescue StandardError
+            nil
+          end
+          __se_build_index_result([summary])
+        ensure
+          renderer&.stop
+        end
+
+        private :__se_index_single_with_renderer!
+
         # 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: }

data/lib/search_engine/cascade.rb

@@ -143,15 +143,24 @@ into: nil
       # Perform a full reindex for a referencer collection, honoring partitioning
       # directives when present. Falls back to a single non-partitioned rebuild
       # when no partitions are configured.
+      #
+      # Strategy:
+      # 1. Try safe blue/green rebuild via index_collection(force_rebuild: true).
+      # 2. If that fails, fall through to partition-based import into the existing
+      #    collection. This is non-destructive: the collection stays available
+      #    with its current schema while documents are refreshed.
+      #
+      # The previous destructive fallback (drop + recreate) was removed because
+      # it caused availability gaps — the collection disappears entirely while
+      # being rebuilt, and if the rebuild fails, it stays gone.
+      #
       # @param ref_klass [Class]
-      # @return [void]
-      # rubocop:disable Metrics/AbcSize
+      # @return [Boolean]
       def __se_full_reindex_for_referrer(ref_klass, client:, alias_cache:)
         logical = ref_klass.respond_to?(:collection) ? ref_klass.collection.to_s : ref_klass.name.to_s
         physical = resolve_physical_collection_name(logical, client: client, cache: alias_cache)
+        coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
 
-        # For cascade full reindex, force a schema rebuild (blue/green) to
-        # refresh reference targets before importing documents.
         forced = reindex_referencer_with_fresh_schema!(
           ref_klass,
           logical,
@@ -161,10 +170,6 @@ into: nil
         )
         return true if forced
 
-        # Fallback: force full destructive reindex when forced rebuild fails.
-        dropped = reindex_referencer_with_drop!(ref_klass, logical, physical)
-        return true if dropped
-
         begin
           compiled = SearchEngine::Partitioner.for(ref_klass)
         rescue StandardError
@@ -183,12 +188,10 @@ into: nil
           parts = parts.reject { |p| p.nil? || p.to_s.strip.empty? }
 
           if parts.empty?
-            coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
             puts(SearchEngine::Logging::Color.dim(%(  Referencer "#{coll_display}" — partitions=0 → skip)))
             return false
           end
 
-          coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
           parts_str = SearchEngine::Logging::Color.bold("partitions=#{parts.size}")
           puts(%(  Referencer "#{coll_display}" — #{parts_str} parallel=#{compiled.max_parallel}))
           mp = compiled.max_parallel.to_i
@@ -207,14 +210,12 @@ into: nil
           end
 
         else
-          coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
           puts(%(  Referencer "#{coll_display}" — #{SearchEngine::Logging::Color.bold('single')}))
           SearchEngine::Indexer.rebuild_partition!(ref_klass, partition: nil, into: nil)
           executed = true
         end
         executed
       end
-      # rubocop:enable Metrics/AbcSize
 
       # Resolve logical alias to physical name with optional per-run memoization.
       # @param logical [String]
@@ -343,21 +344,6 @@ into: nil
         false
       end
 
-      def reindex_referencer_with_drop!(ref_klass, logical, physical)
-        coll_display = physical && physical != logical ? "#{logical} (physical: #{physical})" : logical
-        status_word = SearchEngine::Logging::Color.apply('force reindex (drop+index)', :yellow)
-        puts(%(  Referencer "#{coll_display}" — #{status_word}))
-
-        SearchEngine::Instrumentation.with_context(bulk_suppress_cascade: true) do
-          ref_klass.reindex_collection!
-        end
-        true
-      rescue StandardError => error
-        err_line = %(  Referencer "#{logical}" — force reindex failed: #{error.message})
-        puts(SearchEngine::Logging::Color.apply(err_line, :red))
-        false
-      end
-
       def post_partitions_to_pool!(pool, ctx, parts, ref_klass, mtx)
         parts.each do |p|
           pool.post do

data/lib/search_engine/client/services/collections.rb

@@ -57,6 +57,26 @@ module SearchEngine
           instrument(:get, path, (start ? (current_monotonic_ms - start) : 0.0), {}, request_token: start)
         end
 
+        # @param alias_name [String]
+        # @return [Hash] Typesense delete response, or { status: 404 } when alias not found
+        def delete_alias(alias_name)
+          a = alias_name.to_s
+          start = current_monotonic_ms
+          path = [Client::RequestBuilder::ALIASES_PREFIX, a].join
+
+          result = with_exception_mapping(:delete, path, {}, start) do
+            typesense.aliases[a].delete
+          end
+
+          symbolize_keys_deep(result)
+        rescue Errors::Api => error
+          return { status: 404 } if error.status.to_i == 404
+
+          raise
+        ensure
+          instrument(:delete, path, (start ? (current_monotonic_ms - start) : 0.0), {}, request_token: start)
+        end
+
         # @param alias_name [String]
         # @param physical_name [String]
         # @return [Hash]

data/lib/search_engine/client.rb

@@ -61,6 +61,14 @@ module SearchEngine
       services.fetch(:collections).retrieve_schema(collection_name, timeout_ms: timeout_ms)
     end
 
+    # Delete an alias by name. Returns { status: 404 } when alias not found.
+    # @param alias_name [String]
+    # @return [Hash]
+    # @see `https://typesense.org/docs/latest/api/aliases.html#delete-an-alias`
+    def delete_alias(alias_name)
+      services.fetch(:collections).delete_alias(alias_name)
+    end
+
     # Upsert an alias to point to the provided physical collection (atomic server-side swap).
     # @param alias_name [String]
     # @param physical_name [String]

data/lib/search_engine/indexer.rb

@@ -83,7 +83,7 @@ module SearchEngine
           enum: docs_enum,
           batch_size: nil,
           action: :upsert,
-          log_batches: partition.nil?,
+          log_batches: partition.nil? && on_batch.nil?,
           max_parallel: max_parallel,
           on_batch: on_batch
         )

data/lib/search_engine/test/offline_client.rb

@@ -56,6 +56,10 @@ module SearchEngine
         nil
       end
 
+      def delete_alias(alias_name)
+        {}
+      end
+
       def upsert_alias(alias_name, physical_name)
         {}
       end

data/lib/search_engine/version.rb

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

metadata

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