algolia 3.39.1 → 3.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7efa0c7cc16401848c061d498f8490b972e2bb87c751fae945acc26104b4363a
-  data.tar.gz: 4a98837bfd4bc4ba14098628e9f1642def743ec961abc118d82f88dcf48c87cf
+  metadata.gz: 7030ad3b848a8e074b47b86a06c9b2494a1141097ce80c9e3e0a50c81e96aacb
+  data.tar.gz: 336d669b4166d8edf241d3b63c31bc51155f718282a9c91819b21625ce022091
 SHA512:
-  metadata.gz: b573eba34f313adafb0b087cc666b75c62d91434b848e77bb9c971232e5d37e1615a84dbac5337a813b487b6fca57f6f566a2c914df39fdf8d89a955ee31d65c
-  data.tar.gz: d7eac776ce519b89e7b352a6ee6618e95f91efc25859e070fd4361e7fa61456849e1ac6e57eac2fa662318a3f58eda79990bf50c2aafaeed7d5eebbf670a0621
+  metadata.gz: 0b4be15c6ca713800092aad40bacd12e508b048f082c08e76c8f14c7d70bea63788b52b1feddb33100dfaf2c0eba0ade284cbf46691f1a341eb15a8c06fd2d4c
+  data.tar.gz: a3ae3ff7bcbc1d78a9e0e4ae937d9a06b3ddad1520529ba722d95d6f2e43d4bb18a43c1d3c397c47bc5af9d892bdbe9815ed9349291ae060537f51ef5fabb5b2

data/.github/workflows/release.yml

@@ -21,7 +21,7 @@ jobs:
       - name: Install Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 4.0.3
+          ruby-version: 4.0.4
           bundler-cache: true
 
       - uses: rubygems/release-gem@e9a6361a0b14562539327c2a02373edc56dd3169

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [3.40.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.39.1...3.40.0)
+
+BREAKING CHANGES: this minor version includes breaking changes. See below for more details.
+
+- [84ebc480a8](https://github.com/algolia/api-clients-automation/commit/84ebc480a8) chore(deps): dependencies 2026-05-15 ([#6400](https://github.com/algolia/api-clients-automation/pull/6400)) by [@Fluf22](https://github.com/Fluf22/)
+- [90da6bf0ae](https://github.com/algolia/api-clients-automation/commit/90da6bf0ae) chore(deps): dependencies 2026-05-18 ([#6429](https://github.com/algolia/api-clients-automation/pull/6429)) by [@Fluf22](https://github.com/Fluf22/)
+- [77cfd0447b](https://github.com/algolia/api-clients-automation/commit/77cfd0447b) feat(ruby): add TransformationOptions for ingestion transporter configuration ([#6313](https://github.com/algolia/api-clients-automation/pull/6313)) by [@MarioAlexandruDan](https://github.com/MarioAlexandruDan/)
+- [eddd51e349](https://github.com/algolia/api-clients-automation/commit/eddd51e349) fix(specs): document abTest field on listIndices response ([#6443](https://github.com/algolia/api-clients-automation/pull/6443)) by [@eric-zaharia](https://github.com/eric-zaharia/)
+- [1d3f2c149b](https://github.com/algolia/api-clients-automation/commit/1d3f2c149b) fix(specs): clean up abTest schema on listIndices response ([#6448](https://github.com/algolia/api-clients-automation/pull/6448)) by [@Fluf22](https://github.com/Fluf22/)
+- [35bf16c848](https://github.com/algolia/api-clients-automation/commit/35bf16c848) fix(specs): BREAKING CHANGE – add searchResponsePartial fallback to searchResult oneOf ([#6350](https://github.com/algolia/api-clients-automation/pull/6350)) by [@Fluf22](https://github.com/Fluf22/)
+  - For those of you who want really clean responses without hits nor facets, we added a third fallback type to the search response. It should not impact the rest of the users.
+- [e4f6b366a1](https://github.com/algolia/api-clients-automation/commit/e4f6b366a1) feat(ruby): BREAKING CHANGE – expose maximum number of retries ([#6461](https://github.com/algolia/api-clients-automation/pull/6461)) by [@eric-zaharia](https://github.com/eric-zaharia/)
+  - We updated the default number of retries to account for customers with huge indices, and made it configurable if you prefer to fail early. The impact is that the retry time will be longer in case of issue, but it shouldn't impact most customers: those who don't have issues.
+
 ## [3.39.1](https://github.com/algolia/algoliasearch-client-ruby/compare/3.39.0...3.39.1)
 
 - [363cc2d91b](https://github.com/algolia/api-clients-automation/commit/363cc2d91b) fix(specs): Ingestion API - update destination payload ([#6320](https://github.com/algolia/api-clients-automation/pull/6320)) by [@sbellone](https://github.com/sbellone/)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    algolia (3.39.1)
+    algolia (3.40.0)
       base64 (>= 0.2.0, < 1)
       faraday (>= 1.0.1, < 3.0)
       faraday-net_http_persistent (>= 0.15, < 3)

data/lib/algolia/api/ingestion_client.rb

@@ -3588,5 +3588,76 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Ingestion::WatchResponse")
     end
 
+    # Helper: Pushes objects to the given index in chunks, optionally waiting for each batch to be processed.
+    #
+    # @param index_name [String] the `index_name` where the operation will be performed. (required)
+    # @param objects [Array] the array of objects to push to the given Algolia `index_name`. (required)
+    # @param action [String] the push action to perform on the objects. (optional, default: addObject)
+    # @param wait_for_tasks [Boolean] whether to wait until every task has been processed. (optional, default: false)
+    # @param batch_size [Integer] the size of each chunk of objects sent in a single push call. (optional, default: 1000)
+    # @param reference_index_name [String] the reference index name used for replace-all operations. (optional)
+    # @param request_options [Hash] the request options to send along with the query. (optional)
+    #
+    # @return [Array<Ingestion::WatchResponse>]
+    def chunked_push(
+      index_name,
+      objects,
+      action = Ingestion::Action::ADD_OBJECT,
+      wait_for_tasks = false,
+      batch_size = 1000,
+      reference_index_name = nil,
+      request_options = {},
+      chunked_options = nil
+    )
+      responses = []
+      offset = 0
+      wait_batch_size = batch_size / 10
+      wait_batch_size = batch_size if wait_batch_size < 1
+      total_batches = (objects.length.to_f / batch_size).ceil
+      opts = Algolia::ChunkedHelperOptions.resolve(chunked_options)
+
+      objects.each_slice(batch_size).with_index do |chunk, batch_index|
+        response = push(
+          index_name,
+          Ingestion::PushTaskPayload.new(action: action, records: chunk),
+          false,
+          reference_index_name,
+          request_options
+        )
+        responses << response
+
+        if wait_for_tasks && (responses.length % wait_batch_size == 0 || batch_index == total_batches - 1)
+          responses[offset, wait_batch_size].each do |watch_response|
+            if watch_response.event_id.nil?
+              raise ArgumentError, "received unexpected response from the push endpoint, eventID must not be nil"
+            end
+
+            retries = 0
+            loop do
+              begin
+                event = get_event(watch_response.run_id, watch_response.event_id, request_options)
+                break if event
+              rescue AlgoliaHttpError => e
+                raise e unless e.code == 404
+              end
+
+              retries += 1
+              if retries >= opts.max_retries
+                raise(
+                  ApiError,
+                  "Stopped waiting for the task after #{opts.max_retries} retries. This does not mean the operation failed; it may still complete. If you need to keep polling, retry with a higher max_retries."
+                )
+              end
+
+              sleep([retries * 1.5, 5].min)
+            end
+          end
+
+          offset += wait_batch_size
+        end
+      end
+
+      responses
+    end
   end
 end

data/lib/algolia/api/search_client.rb

@@ -6,6 +6,49 @@ require "openssl"
 require "base64"
 
 module Algolia
+  # Configuration options for the ingestion transporter used by *_with_transformation helpers.
+  # When passed to SearchClient.with_transformation or set via set_transformation_options,
+  # the ingestion transporter is eagerly created using Ingestion API defaults (25s timeouts,
+  # no compression). Only fields explicitly set here override those defaults.
+  # See https://www.algolia.com/doc/libraries/ruby/v3/methods/ingestion
+  class TransformationOptions
+    attr_accessor(
+      :region,
+      :connect_timeout,
+      :read_timeout,
+      :write_timeout,
+      :hosts,
+      :compression_type,
+      :header_params
+    )
+
+    def initialize(region, opts = {})
+      if region.nil? || region.to_s.strip.empty?
+        raise(
+          ArgumentError,
+          "`region` is required in `TransformationOptions`. See https://www.algolia.com/doc/libraries/ruby/v3/methods/ingestion"
+        )
+      end
+
+      valid_keys = %i[connect_timeout read_timeout write_timeout hosts compression_type header_params]
+      unknown = opts.keys - valid_keys
+      unless unknown.empty?
+        raise(
+          ArgumentError,
+          "Unknown TransformationOptions keys: #{unknown.join(", ")}. Valid keys are: #{valid_keys.join(", ")}"
+        )
+      end
+
+      @region = region
+      @connect_timeout = opts[:connect_timeout]
+      @read_timeout = opts[:read_timeout]
+      @write_timeout = opts[:write_timeout]
+      @hosts = opts[:hosts]
+      @compression_type = opts[:compression_type]
+      @header_params = opts[:header_params]
+    end
+  end
+
   class SearchClient
     attr_accessor :api_client
 
@@ -27,6 +70,10 @@ module Algolia
       end
 
       @api_client = Algolia::ApiClient.new(config)
+      @ingestion_transporter = nil
+      if config.transformation_options
+        @ingestion_transporter = _build_ingestion_transporter(config.transformation_options)
+      end
     end
 
     def self.create(app_id, api_key, opts = {})
@@ -49,6 +96,31 @@ module Algolia
       new(config)
     end
 
+    # Creates a SearchClient configured with a TransformationOptions for use with
+    # *_with_transformation helpers. The ingestion transporter is initialised eagerly using
+    # Ingestion API defaults (25s timeouts); set override fields on TransformationOptions to
+    # change specific defaults.
+    # See https://www.algolia.com/doc/libraries/ruby/v3/methods/ingestion
+    #
+    # @param app_id [String] the Algolia application ID. (required)
+    # @param api_key [String] the Algolia API key. (required)
+    # @param transformation_options [TransformationOptions] the transformation options including region and optional ingestion transporter overrides. (required)
+    # @param opts [Hash] additional configuration options passed to the search client. (optional)
+    # @return [SearchClient]
+    def self.with_transformation(app_id, api_key, transformation_options, opts = {})
+      opts = opts.dup
+      hosts = opts.delete(:hosts)
+      if hosts
+        config = Algolia::Configuration.new(app_id, api_key, hosts, "Search", opts)
+        client = new(config)
+      else
+        client = create(app_id, api_key, opts)
+      end
+
+      client.set_transformation_options(transformation_options)
+      client
+    end
+
     # Helper method to switch the API key used to authenticate the requests.
     #
     # @param api_key [String] the new API key to use.
@@ -3340,18 +3412,231 @@ module Algolia
       @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdateApiKeyResponse")
     end
 
+    # The parent search config MUST NOT leak into the ingestion transporter.
+    def _build_ingestion_transporter(transformation_options)
+      hosts = if transformation_options.hosts
+        transformation_options.hosts
+      else
+        [
+          Transport::StatefulHost.new(
+            "data.#{transformation_options.region}.algolia.com",
+            accept: CallType::READ | CallType::WRITE
+          )
+        ]
+      end
+
+      opts = {}
+      unless transformation_options.connect_timeout.nil?
+        opts[:connect_timeout] = transformation_options.connect_timeout
+      end
+
+      opts[:read_timeout] = transformation_options.read_timeout unless transformation_options.read_timeout.nil?
+      opts[:write_timeout] = transformation_options.write_timeout unless transformation_options.write_timeout.nil?
+      unless transformation_options.compression_type.nil?
+        opts[:compression_type] = transformation_options.compression_type
+      end
+
+      config = Algolia::Configuration.new(
+        @api_client.config.app_id,
+        @api_client.config.api_key,
+        hosts,
+        "Ingestion",
+        opts
+      )
+
+      if transformation_options.header_params
+        config.header_params = config.header_params.merge(transformation_options.header_params)
+      end
+
+      Algolia::IngestionClient.create_with_config(config)
+    end
+
+    # Helper: Sets (or replaces) the ingestion transporter used by *_with_transformation helpers.
+    #
+    # @param transformation_options [TransformationOptions] the transformation options including region and optional ingestion transporter overrides. (required)
+    def set_transformation_options(transformation_options)
+      raise ArgumentError, "`transformation_options` must not be nil" if transformation_options.nil?
+      @ingestion_transporter = _build_ingestion_transporter(transformation_options)
+    end
+
+    def assert_ingestion_transporter!
+      if @ingestion_transporter.nil?
+        raise(
+          ArgumentError,
+          "`transformation_options` must be set in the client config before calling this method. It defaults to the Ingestion API defaults. See https://www.algolia.com/doc/libraries/ruby/v3/methods/ingestion/"
+        )
+      end
+    end
+
+    # Helper: Similar to the `save_objects` method but requires a Push connector to be created first,
+    # in order to transform records before indexing them to Algolia.
+    # `set_transformation_options` must have been called, or the client created via `SearchClient.with_transformation`.
+    #
+    # @param index_name [String] the `index_name` where the operation will be performed. (required)
+    # @param objects [Array] the array of objects to store in the given Algolia `index_name`. (required)
+    # @param wait_for_tasks [Boolean] whether to wait until every task has been processed. (optional, default: false)
+    # @param batch_size [Integer] the size of each chunk of objects sent in a single push call. (optional, default: 1000)
+    # @param request_options [Hash] the request options to send along with the query. (optional)
+    #
+    # @return [Array<Ingestion::WatchResponse>]
+    def save_objects_with_transformation(
+      index_name,
+      objects,
+      wait_for_tasks = false,
+      batch_size = 1000,
+      request_options = {},
+      chunked_options = nil
+    )
+      assert_ingestion_transporter!
+
+      @ingestion_transporter.chunked_push(
+        index_name,
+        objects,
+        Ingestion::Action::ADD_OBJECT,
+        wait_for_tasks,
+        batch_size,
+        nil,
+        request_options,
+        chunked_options
+      )
+    end
+
+    # Helper: Similar to the `partial_update_objects` method but requires a Push connector to be created first,
+    # in order to transform records before indexing them to Algolia.
+    # `set_transformation_options` must have been called, or the client created via `SearchClient.with_transformation`.
+    #
+    # @param index_name [String] the `index_name` where the operation will be performed. (required)
+    # @param objects [Array] the array of objects to update in the given Algolia `index_name`. (required)
+    # @param create_if_not_exists [Boolean] whether to create objects that do not exist. (optional, default: false)
+    # @param wait_for_tasks [Boolean] whether to wait until every task has been processed. (optional, default: false)
+    # @param batch_size [Integer] the size of each chunk of objects sent in a single push call. (optional, default: 1000)
+    # @param request_options [Hash] the request options to send along with the query. (optional)
+    #
+    # @return [Array<Ingestion::WatchResponse>]
+    def partial_update_objects_with_transformation(
+      index_name,
+      objects,
+      create_if_not_exists = false,
+      wait_for_tasks = false,
+      batch_size = 1000,
+      request_options = {},
+      chunked_options = nil
+    )
+      assert_ingestion_transporter!
+
+      action = create_if_not_exists ? Ingestion::Action::PARTIAL_UPDATE_OBJECT : Ingestion::Action::PARTIAL_UPDATE_OBJECT_NO_CREATE
+
+      @ingestion_transporter.chunked_push(
+        index_name,
+        objects,
+        action,
+        wait_for_tasks,
+        batch_size,
+        nil,
+        request_options,
+        chunked_options
+      )
+    end
+
+    # Helper: Similar to the `replace_all_objects` method but requires a Push connector to be created first,
+    # in order to transform records before indexing them to Algolia.
+    # `set_transformation_options` must have been called, or the client created via `SearchClient.with_transformation`.
+    #
+    # @param index_name [String] the `index_name` to replace objects in. (required)
+    # @param objects [Array] the array of objects to store in the given Algolia `index_name`. (required)
+    # @param batch_size [Integer] the size of each chunk of objects sent in a single push call. (optional, default: 1000)
+    # @param scopes [Array] the scopes to keep from the index. (optional, default: settings, rules, synonyms)
+    # @param request_options [Hash] the request options to send along with the query. (optional)
+    #
+    # @return [Search::ReplaceAllObjectsWithTransformationResponse]
+    def replace_all_objects_with_transformation(
+      index_name,
+      objects,
+      batch_size = 1000,
+      scopes = [Search::ScopeType::SETTINGS, Search::ScopeType::RULES, Search::ScopeType::SYNONYMS],
+      request_options = {},
+      chunked_options = nil
+    )
+      assert_ingestion_transporter!
+
+      opts = Algolia::ChunkedHelperOptions.resolve(chunked_options)
+      tmp_index_name = index_name + "_tmp_" + rand(10_000_000).to_s
+
+      begin
+        copy_operation_response = operation_index(
+          index_name,
+          Search::OperationIndexParams.new(
+            operation: Search::OperationType::COPY,
+            destination: tmp_index_name,
+            scope: scopes
+          ),
+          request_options
+        )
+
+        watch_responses = @ingestion_transporter.chunked_push(
+          tmp_index_name,
+          objects,
+          Ingestion::Action::ADD_OBJECT,
+          true,
+          batch_size,
+          index_name,
+          request_options,
+          opts
+        )
+
+        wait_for_task(tmp_index_name, copy_operation_response.task_id, opts.max_retries)
+
+        copy_operation_response = operation_index(
+          index_name,
+          Search::OperationIndexParams.new(
+            operation: Search::OperationType::COPY,
+            destination: tmp_index_name,
+            scope: scopes
+          ),
+          request_options
+        )
+
+        wait_for_task(tmp_index_name, copy_operation_response.task_id, opts.max_retries)
+
+        move_operation_response = operation_index(
+          tmp_index_name,
+          Search::OperationIndexParams.new(
+            operation: Search::OperationType::MOVE,
+            destination: index_name
+          ),
+          request_options
+        )
+
+        wait_for_task(tmp_index_name, move_operation_response.task_id, opts.max_retries)
+
+        search_watch_responses = watch_responses.map do |wr|
+          Search::WatchResponse.build_from_hash(wr.to_hash)
+        end
+
+        Search::ReplaceAllObjectsWithTransformationResponse.new(
+          copy_operation_response: copy_operation_response,
+          watch_responses: search_watch_responses,
+          move_operation_response: move_operation_response
+        )
+      rescue Exception => e
+        delete_index(tmp_index_name)
+
+        raise e
+      end
+    end
+
     # Helper: Wait for a task to be published (completed) for a given `index_name` and `task_id`.
     #
     # @param index_name [String] the `index_name` where the operation was performed. (required)
     # @param task_id [Integer] the `task_id` returned in the method response. (required)
-    # @param max_retries [Integer] the maximum number of retries. (optional, default to 50)
+    # @param max_retries [Integer] the maximum number of retries. (optional, default to Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES)
     # @param timeout [Proc] the function to decide how long to wait between retries. (optional)
     # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `get_task` method.
     # @return [Http::Response] the last get_task response
     def wait_for_task(
       index_name,
       task_id,
-      max_retries = 50,
+      max_retries = Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES,
       timeout = -> (retry_count) { [retry_count * 200, 5000].min },
       request_options = {}
     )
@@ -3366,19 +3651,22 @@ module Algolia
         sleep(timeout.call(retries) / 1000.0)
       end
 
-      raise ApiError, "The maximum number of retries exceeded. (#{max_retries})"
+      raise(
+        ApiError,
+        "Stopped waiting for the task after #{max_retries} retries. This does not mean the operation failed; it may still complete. If you need to keep polling, retry with a higher max_retries."
+      )
     end
 
     # Helper: Wait for an application-level task to be published (completed) for a given `task_id`.
     #
     # @param task_id [Integer] the `task_id` returned in the method response. (required)
-    # @param max_retries [Integer] the maximum number of retries. (optional, default to 50)
+    # @param max_retries [Integer] the maximum number of retries. (optional, default to Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES)
     # @param timeout [Proc] the function to decide how long to wait between retries. (optional)
     # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `get_task` method.
     # @return [Http::Response] the last get_task response
     def wait_for_app_task(
       task_id,
-      max_retries = 50,
+      max_retries = Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES,
       timeout = -> (retry_count) { [retry_count * 200, 5000].min },
       request_options = {}
     )
@@ -3393,7 +3681,10 @@ module Algolia
         sleep(timeout.call(retries) / 1000.0)
       end
 
-      raise ApiError, "The maximum number of retries exceeded. (#{max_retries})"
+      raise(
+        ApiError,
+        "Stopped waiting for the task after #{max_retries} retries. This does not mean the operation failed; it may still complete. If you need to keep polling, retry with a higher max_retries."
+      )
     end
 
     # Helper: Wait for an API key to be added, updated or deleted based on a given `operation`.
@@ -3409,7 +3700,7 @@ module Algolia
       key,
       operation,
       api_key = Search::ApiKey.new,
-      max_retries = 50,
+      max_retries = Algolia::ChunkedHelperOptions::DEFAULT_MAX_RETRIES,
       timeout = -> (retry_count) { [retry_count * 200, 5000].min },
       request_options = {}
     )
@@ -3432,7 +3723,10 @@ module Algolia
           sleep(timeout.call(retries) / 1000.0)
         end
 
-        raise ApiError, "The maximum number of retries exceeded. (#{max_retries})"
+        raise(
+          ApiError,
+          "Stopped waiting for the task after #{max_retries} retries. This does not mean the operation failed; it may still complete. If you need to keep polling, retry with a higher max_retries."
+        )
       end
 
       while retries < max_retries
@@ -3451,7 +3745,10 @@ module Algolia
         sleep(timeout.call(retries) / 1000.0)
       end
 
-      raise ApiError, "The maximum number of retries exceeded. (#{max_retries})"
+      raise(
+        ApiError,
+        "Stopped waiting for the task after #{max_retries} retries. This does not mean the operation failed; it may still complete. If you need to keep polling, retry with a higher max_retries."
+      )
     end
 
     # Helper: Iterate on the `browse` method of the client to allow aggregating objects of an index.
@@ -3629,14 +3926,22 @@ module Algolia
     #
     # @return [BatchResponse]
     #
-    def save_objects(index_name, objects, wait_for_tasks = false, batch_size = 1000, request_options = {})
+    def save_objects(
+      index_name,
+      objects,
+      wait_for_tasks = false,
+      batch_size = 1000,
+      request_options = {},
+      chunked_options = nil
+    )
       chunked_batch(
         index_name,
         objects,
         Search::Action::ADD_OBJECT,
         wait_for_tasks,
         batch_size,
-        request_options
+        request_options,
+        chunked_options
       )
     end
 
@@ -3650,14 +3955,22 @@ module Algolia
     #
     # @return [BatchResponse]
     #
-    def delete_objects(index_name, object_ids, wait_for_tasks = false, batch_size = 1000, request_options = {})
+    def delete_objects(
+      index_name,
+      object_ids,
+      wait_for_tasks = false,
+      batch_size = 1000,
+      request_options = {},
+      chunked_options = nil
+    )
       chunked_batch(
         index_name,
         object_ids.map { |id| {"objectID" => id} },
         Search::Action::DELETE_OBJECT,
         wait_for_tasks,
         batch_size,
-        request_options
+        request_options,
+        chunked_options
       )
     end
 
@@ -3678,7 +3991,8 @@ module Algolia
       create_if_not_exists,
       wait_for_tasks = false,
       batch_size = 1000,
-      request_options = {}
+      request_options = {},
+      chunked_options = nil
     )
       chunked_batch(
         index_name,
@@ -3686,7 +4000,8 @@ module Algolia
         create_if_not_exists ? Search::Action::PARTIAL_UPDATE_OBJECT : Search::Action::PARTIAL_UPDATE_OBJECT_NO_CREATE,
         wait_for_tasks,
         batch_size,
-        request_options
+        request_options,
+        chunked_options
       )
     end
 
@@ -3707,8 +4022,10 @@ module Algolia
       action = Action::ADD_OBJECT,
       wait_for_tasks = false,
       batch_size = 1000,
-      request_options = {}
+      request_options = {},
+      chunked_options = nil
     )
+      opts = Algolia::ChunkedHelperOptions.resolve(chunked_options)
       responses = []
       objects.each_slice(batch_size) do |chunk|
         requests = chunk.map do |object|
@@ -3720,7 +4037,7 @@ module Algolia
 
       if wait_for_tasks
         responses.each do |response|
-          wait_for_task(index_name, response.task_id)
+          wait_for_task(index_name, response.task_id, opts.max_retries)
         end
       end
 
@@ -3741,8 +4058,10 @@ module Algolia
       objects,
       batch_size = 1000,
       scopes = [Search::ScopeType::SETTINGS, Search::ScopeType::RULES, Search::ScopeType::SYNONYMS],
-      request_options = {}
+      request_options = {},
+      chunked_options = nil
     )
+      opts = Algolia::ChunkedHelperOptions.resolve(chunked_options)
       tmp_index_name = index_name + "_tmp_" + rand(10_000_000).to_s
 
       begin
@@ -3762,10 +4081,11 @@ module Algolia
           Search::Action::ADD_OBJECT,
           true,
           batch_size,
-          request_options
+          request_options,
+          opts
         )
 
-        wait_for_task(tmp_index_name, copy_operation_response.task_id)
+        wait_for_task(tmp_index_name, copy_operation_response.task_id, opts.max_retries)
 
         copy_operation_response = operation_index(
           index_name,
@@ -3777,7 +4097,7 @@ module Algolia
           request_options
         )
 
-        wait_for_task(tmp_index_name, copy_operation_response.task_id)
+        wait_for_task(tmp_index_name, copy_operation_response.task_id, opts.max_retries)
 
         move_operation_response = operation_index(
           tmp_index_name,
@@ -3788,7 +4108,7 @@ module Algolia
           request_options
         )
 
-        wait_for_task(tmp_index_name, move_operation_response.task_id)
+        wait_for_task(tmp_index_name, move_operation_response.task_id, opts.max_retries)
 
         Search::ReplaceAllObjectsResponse.new(
           copy_operation_response: copy_operation_response,

data/lib/algolia/chunked_helper_options.rb

@@ -0,0 +1,15 @@
+module Algolia
+  # Optional configuration for chunked helpers that batch records and poll for task completion.
+  class ChunkedHelperOptions
+    DEFAULT_MAX_RETRIES = 100
+    attr_reader :max_retries
+
+    def initialize(max_retries: DEFAULT_MAX_RETRIES)
+      @max_retries = max_retries
+    end
+
+    def self.resolve(options)
+      options || new
+    end
+  end
+end